darcs - qt.core

repos / qt.core / headdiff

Break API compatibility for qt:with-app and qt:exec & spellcheck --> to head

Sun Mar 13 20:40:35 CET 2011 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix loading on OSX.

Thanks to Elliott Slaughter

Sat Apr 3 14:34:21 CEST 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Account for possible lisp-object metatype id change when loading an image.

Sat Feb 20 22:04:46 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* cleanup

Sat Feb 20 22:02:38 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Make qt:application cleanup more stable

Sat Feb 20 22:00:30 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* support all from qt:variant conversions.

Mon Feb 15 16:33:05 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Build a shared library not a module.

Fixes a build error on OS X.

Thu Feb 4 16:06:38 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Test building libclsmokeqtcore

Thu Feb 4 10:22:53 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Add qvector.cpp

Sat Jan 30 16:40:15 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Get the QList size using Lisp instead of an external C function.

Tue Jan 26 17:19:51 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix define-qlist-wrapper usage for other modules. (i.e. qt.gui)

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

* Export delete-app since other modules (qt.gui) might like to add methods to it.

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

* Use ELT instead of AREF for sequences in vector translations.

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

* Allow other modules to define QList<Foo*> conversions.

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

* Fix error reporting on signal-slot connection failure.

Sat Jan 23 23:17:35 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QVector<T> translation

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

* Split up in qt.core.

- Fix qt:with-core-app

- cleanup name prefixes

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

diff -rN -u old-qt.core/TODO new-qt.core/TODO

--- old-qt.core/TODO 2014-10-30 07:30:21.000000000 +0100

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

@@ -1 +0,0 @@

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

diff -rN -u old-qt.core/cl-smoke.qt.core.asd new-qt.core/cl-smoke.qt.core.asd

--- old-qt.core/cl-smoke.qt.core.asd 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/cl-smoke.qt.core.asd 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,42 @@

+(defsystem :cl-smoke.qt.core

+ :name :cl-smoke.qt.core

+ :version (0 0 1)

+ :author "Tobias Rautenkranz"

+ :license "GPL with linking exception"

+ :description "Smoke Qt core bindings."

+ :depends-on (:cl-smoke.smoke :cffi :alexandria)

+ :components

+ ((:module "src"

+ :components

+ ((:file "package")

+ (:module "lib" :depends-on ("package"))

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

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

+ (:file "event" :depends-on ("qt.core"))

+ (:file "object" :depends-on ("qt.core" "signal-slot" "qstring" "event"))

+ (:file "operator" :depends-on ("qt.core" "object"))

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

+ (:file "qstring" :depends-on ("qt.core"))

+ (:file "list" :depends-on ("qt.core"))

+ (:file "vector" :depends-on ("qt.core" "signal-slot"))

+ (:file "msg-handler" :depends-on ("lib" "qt.core"))

+ (:file "timer" :depends-on ("qt.core"))

+ (:file "i18n" :depends-on ("qt.core"))

+ (:file "lisp-object" :depends-on ("qt.core" "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.core" "lib" "qstring"))

+ (:file "variant" :depends-on ("qt.core" "qstring" "lisp-object"))

+ (:file "properties" :depends-on ("variant"))))))

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

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

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

diff -rN -u old-qt.core/examples/hello-world.lisp new-qt.core/examples/hello-world.lisp

--- old-qt.core/examples/hello-world.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/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.core/examples/package.lisp new-qt.core/examples/package.lisp

--- old-qt.core/examples/package.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/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.core/qt.mbd new-qt.core/qt.mbd

--- old-qt.core/qt.mbd 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/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)

- ((package :initarg :package)))

-;;; 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 (:package :cl-smoke.qt-impl))

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

diff -rN -u old-qt.core/src/application.lisp new-qt.core/src/application.lisp

--- old-qt.core/src/application.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/application.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,9 +1,6 @@

-(in-package :cl-smoke.qt-impl)

-(declaim (optimize (debug 3)))

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

(defvar *app*)

-(defvar *widgets* nil)

(defvar qt:*exec-p* t

"Run exec if true and not otherwise.")

@@ -19,63 +16,58 @@

"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 '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,

+(defun ensure-app (&optional

+ (application 'qt:core-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

+ (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 "Delete the active application." "Active application not created by QT:WITH-APP.")

- (smoke::delete-pointer (smoke::pointer (qt:core-application.instance))

- (find-class 'qt:core-application)))

- (foreign-free argv)

- (foreign-free argc)

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

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

- (let ((app (make-instance 'qt:application :args (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

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

- (cxx:quit (qt:app))

- (setf *widgets* nil)

- ;; Call the destructer; -> 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))

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

+(defgeneric delete-app (application)

+ (:method (application)

+ (unless (null-pointer-p (smoke:pointer application))

+ (cxx:quit application)

+ ;; Call the destructor; -> destructed callback is called,

+ ;; (~QApplication() is virtual) which takes care of cleanup on the

+ ;; Lisp side.

+ (smoke::delete-pointer (smoke:pointer application) (class-of application)))

(makunbound '*app*)))

+(defun kill-app ()

+ (delete-app (qt:app)))

(defmacro with-application ((ensure-app remove-app) &body body)

(let ((cleanup-p (gensym)))

`(multiple-value-bind (*app* ,cleanup-p) ,ensure-app

@@ -84,31 +76,21 @@

(when ,cleanup-p

,remove-app)))))

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

- "Ensures that a APPLICATION instance exists,

-evaluates BODY and executes the APPLICATION instance after BODY.

-The instance can be accessed with:

-APP.

-Can be nested.

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

-from BODY."

- `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:application) (kill-app))

- ,@body))

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

- `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:core-application) (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.core::ensure-app 'qt:core-application) (kill-app))

+ ,@body))

-(defun qt:exec (&rest widgets)

- "Executes APP."

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

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

(when qt:*exec-p*

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

- (cxx:quit (qt:app))

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

+ (cxx:quit (qt:app))

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

:report-function

#'(lambda (stream)

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

@@ -117,4 +99,5 @@

(declare (ignore condition))

(and (qt:app-p)

(find-restart 'continue)))))

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

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

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

diff -rN -u old-qt.core/src/event.lisp new-qt.core/src/event.lisp

--- old-qt.core/src/event.lisp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/event.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,10 @@

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

+(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 'pointer)

+ (upcast event (find-class 'qt:child-event)))

+ (change-class event 'qt:child-event)))

+ event)

diff -rN -u old-qt.core/src/i18n.lisp new-qt.core/src/i18n.lisp

--- old-qt.core/src/i18n.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/i18n.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

(defun qt:tr (message &optional context)

"Returns the translated MESSAGE for CONTEXT or

diff -rN -u old-qt.core/src/lib/CMakeLists.txt new-qt.core/src/lib/CMakeLists.txt

--- old-qt.core/src/lib/CMakeLists.txt 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lib/CMakeLists.txt 2014-10-30 07:30:21.000000000 +0100

@@ -8,13 +8,14 @@

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

+set(QT_SMOKE_SOURCES qt_smoke.cpp

+ qstring.cpp qstringlist.cpp lisp_object.cpp qlist.cpp qvector.cpp)

+add_library(clsmokeqtcore SHARED ${QT_SMOKE_SOURCES})

+target_link_libraries(clsmokeqtcore ${QT_LIBRARIES})

+set_target_properties(clsmokeqtcore

PROPERTIES

SOVERSION "0.0"

VERSION "0.0.1")

-install(TARGETS qt-smoke-extra

- LIBRARY DESTINATION lib)

+install(TARGETS clsmokeqtcore LIBRARY DESTINATION lib)

diff -rN -u old-qt.core/src/lib/lisp-object.cpp new-qt.core/src/lib/lisp-object.cpp

--- old-qt.core/src/lib/lisp-object.cpp 2014-10-30 07:30:21.000000000 +0100

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

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

-#include "lisp-object.h"

-#include <QtGlobal>

-#include <QtDebug>

-namespace cl_smoke {

-namespace qt {

-/** @struct lisp_object::data

- * @internal

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

- * the destructor callback when it is deleted.

- */

-/** @typedef lisp_object::destructor

- * Destructor.

- * @param id The ID

- */

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

-/** Constructor. */

-lisp_object::data::data()

-: id(id),

- is_set(false)

-{ }

-/** Constructor.

- * @param id The ID.

- */

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

-: id(id),

- is_set(true)

-{ }

-/** Destructor. */

-lisp_object::data::~data()

- Q_ASSERT_X(lisp_object::destruct, __func__,

- "call setup_lisp_object() first.");

- if (this->is_set)

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

-/** @class lisp_object

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

- *

- * The registered destructor callback is called when

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

- *

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

- */

-/** Constructor. */

-lisp_object::lisp_object()

- : d(new data())

-{ }

-/** Constructor.

- * @param id the ID

- */

-lisp_object::lisp_object(int id)

- : d(new data(id))

-{ }

-/** Constructor.

- * @param other the lisp_object to copy

- */

-lisp_object::lisp_object(const lisp_object& other)

- : d(other.d)

-{ }

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

- * Gets the ID.

- *

- * @return the ID

- */

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

- * Determines werter the ID is set.

- *

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

- */

-/** Sets a new ID.

- * @param id the ID

- */

-void

-lisp_object::set_id(int id)

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

- d = new data(id);

-} // namespace qt

-} // namespace cl_smoke

-using namespace cl_smoke::qt;

-/** Initialize the lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param destruct destructor callback

- *

- * @return the QMetaType ID of lisp_object

- */

-int

-qt_smoke_setup_lisp_object(void* destruct)

- Q_ASSERT(destruct != NULL);

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

- return qRegisterMetaType<lisp_object>();

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

- * @relates cl_smoke::qt::lisp_object

- * @param object the lisp_object.

- *

- * @return the ID

- */

-int

-qt_smoke_lisp_object_id(const void* object)

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

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

- * @relates cl_smoke::qt::lisp_object

- * @param object the object

- *

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

- */

-int

-qt_smoke_lisp_object_set(const void* object)

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

-/** Makes a new lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param id the ID

- *

- * @return A new lisp_object instance.

- */

-void*

-qt_smoke_make_lisp_object(int id)

- return new lisp_object(id);

-/** Deletes a lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param object the lisp_object

- */

-void*

-qt_smoke_free_lisp_object(void* object)

- delete static_cast<lisp_object*>(object);

-#include <QVariant>

-/** Gets the lisp_object of a QVariant.

- * @relates cl_smoke::qt::lisp_object

- * @param variant the QVariant

- *

- * @return a new lisp_object.

- */

-void*

-qt_smoke_lisp_object_value(const void* variant)

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

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

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

diff -rN -u old-qt.core/src/lib/lisp-object.h new-qt.core/src/lib/lisp-object.h

--- old-qt.core/src/lib/lisp-object.h 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/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

diff -rN -u old-qt.core/src/lib/lisp_object.cpp new-qt.core/src/lib/lisp_object.cpp

--- old-qt.core/src/lib/lisp_object.cpp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/lib/lisp_object.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,181 @@

+#include "lisp_object.h"

+#include "cl_smoke_qt.h"

+#include <QtGlobal>

+#include <QtDebug>

+#include <QVariant>

+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

+ */

+CL_SMOKE_QT_EXPORT int

+cl_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

+ */

+CL_SMOKE_QT_EXPORT unsigned int

+cl_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.

+ */

+CL_SMOKE_QT_EXPORT int

+cl_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.

+ */

+CL_SMOKE_QT_EXPORT void*

+cl_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

+ */

+CL_SMOKE_QT_EXPORT void*

+cl_smoke_free_lisp_object(void* object)

+ delete static_cast<lisp_object*>(object);

+/** Gets the lisp_object of a QVariant.

+ * @relates cl_smoke::qt::lisp_object

+ * @param variant the QVariant

+ *

+ * @return a new lisp_object.

+ */

+CL_SMOKE_QT_EXPORT void*

+cl_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.core/src/lib/lisp_object.h new-qt.core/src/lib/lisp_object.h

--- old-qt.core/src/lib/lisp_object.h 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/lib/lisp_object.h 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,83 @@

+#ifndef LISP_OBJECT_H

+#define LISP_OBJECT_H

+#include "cl_smoke_qt.h"

+#include <QMetaType>

+#include <QSharedData>

+#include <QExplicitlySharedDataPointer>

+#include <smoke.h>

+extern "C"

+ CL_SMOKE_QT_EXPORT int

+ cl_smoke_setup_lisp_object(void* destruct);

+ CL_SMOKE_QT_EXPORT unsigned int

+ cl_smoke_lisp_object_id(const void* object);

+ CL_SMOKE_QT_EXPORT int

+ cl_smoke_lisp_object_is_set(const void* object);

+ CL_SMOKE_QT_EXPORT void*

+ cl_smoke_make_lisp_object(unsigned int id);

+ CL_SMOKE_QT_EXPORT void*

+ cl_smoke_free_lisp_object(void* object);

+ CL_SMOKE_QT_EXPORT void*

+ cl_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

+ ::cl_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.core/src/lib/qlist.cpp new-qt.core/src/lib/qlist.cpp

--- old-qt.core/src/lib/qlist.cpp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lib/qlist.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -12,5 +12,4 @@

DEFINE_QLIST_WRAPPER_PTR(void)

DEFINE_QLIST_WRAPPER(QByteArray)

} // extern "C"

diff -rN -u old-qt.core/src/lib/qlist.h new-qt.core/src/lib/qlist.h

--- old-qt.core/src/lib/qlist.h 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lib/qlist.h 2014-10-30 07:30:21.000000000 +0100

@@ -1,9 +1,10 @@

#ifndef CL_SMOKE_QT_QLIST_H

#define CL_SMOKE_QT_QLIST_H

-#include <QList>

#include "cl_smoke_qt.h"

+#include <QList>

/** @file

@@ -31,20 +32,14 @@

/** @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) \

+cl_smoke_free_list_ ## NAME (void* list) \

{ \

delete static_cast<QList< TYPE >*>(list); \

} \

CL_SMOKE_QT_EXPORT void* \

-qt_smoke_make_list_ ## NAME () \

+cl_smoke_make_list_ ## NAME () \

{ \

return new QList< TYPE >(); \

} \

@@ -55,14 +50,14 @@

#define DEFINE_QLIST_WRAPPER_PTR_PART(NAME, TYPE) \

CL_SMOKE_QT_EXPORT const void* \

-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \

+cl_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) \

+cl_smoke_list_ ## NAME ## _append(void* list, void* data) \

{ \

static_cast<QList< TYPE >*>(list) \

->append(static_cast<TYPE>(data)); \

@@ -73,14 +68,14 @@

#define DEFINE_QLIST_WRAPPER_VALUE_PART(NAME, TYPE) \

CL_SMOKE_QT_EXPORT const void* \

-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \

+cl_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) \

+cl_smoke_list_ ## NAME ## _append(void* list, void* data) \

{ \

static_cast<QList< TYPE >*>(list) \

->append(*static_cast<TYPE*>(data)); \

diff -rN -u old-qt.core/src/lib/qstring.cpp new-qt.core/src/lib/qstring.cpp

--- old-qt.core/src/lib/qstring.cpp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lib/qstring.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -1,5 +1,4 @@

#include <QString>

-#include <QtDebug>

#include "cl_smoke_qt.h"

@@ -14,9 +13,8 @@

* @return a pointer to a newly allocated char array.

CL_SMOKE_QT_EXPORT void*

-qt_smoke_qstring_to_byte_array(const void* qstring)

+cl_smoke_qstring_to_byte_array(const void* qstring)

{

- Q_ASSERT(qstring);

const QString* string = static_cast<const QString*>(qstring);

return new QByteArray(string->toLocal8Bit());

@@ -26,7 +24,7 @@

* @param qstring the QString to free

CL_SMOKE_QT_EXPORT void

-qt_smoke_free_qstring(void* qstring)

+cl_smoke_free_qstring(void* qstring)

{

delete static_cast<QString*>(qstring);

}

@@ -38,7 +36,7 @@

* @return a newly allocated QString

CL_SMOKE_QT_EXPORT void*

-qt_smoke_string_to_qstring(const char* data, int length)

+cl_smoke_string_to_qstring(const char* data, int length)

{

return new QString(QString::fromLocal8Bit(data, length));

}

diff -rN -u old-qt.core/src/lib/qstringlist.cpp new-qt.core/src/lib/qstringlist.cpp

--- old-qt.core/src/lib/qstringlist.cpp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lib/qstringlist.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -1,8 +1,7 @@

+#include "cl_smoke_qt.h"

#include <QStringList>

#include <QtDebug>

-#include <cstring>

-#include "cl_smoke_qt.h"

/** @file

* @brief QStringList conversion. */

@@ -15,7 +14,7 @@

* @return the number of items

CL_SMOKE_QT_EXPORT int

-qt_smoke_string_list_size(const void* string_list)

+cl_smoke_string_list_size(const void* string_list)

{

Q_ASSERT(string_list);

return static_cast<const QStringList*>(string_list)->size();

@@ -28,7 +27,7 @@

* @return a new allocated byte-array

CL_SMOKE_QT_EXPORT void*

-qt_smoke_string_list_at(const void* string_list, int index)

+cl_smoke_string_list_at(const void* string_list, int index)

{

Q_ASSERT(string_list);

const QStringList* list = static_cast<const QStringList*>(string_list);

@@ -42,7 +41,7 @@

* @param string_list the QStringList to free

CL_SMOKE_QT_EXPORT void

-qt_smoke_free_string_list(void* string_list)

+cl_smoke_free_string_list(void* string_list)

{

delete static_cast<QStringList*>(string_list);

}

@@ -52,7 +51,7 @@

* @return a new QStringList

CL_SMOKE_QT_EXPORT void*

-qt_smoke_make_string_list()

+cl_smoke_make_string_list()

{

return new QStringList();

}

@@ -63,7 +62,7 @@

* @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)

+cl_smoke_string_list_append(void* string_list, const char* data, int length)

{

static_cast<QStringList*>(string_list)->append(QString::fromLocal8Bit(data, length));

}

diff -rN -u old-qt.core/src/lib/qt-smoke.cpp new-qt.core/src/lib/qt-smoke.cpp

--- old-qt.core/src/lib/qt-smoke.cpp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/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"

diff -rN -u old-qt.core/src/lib/qt_smoke.cpp new-qt.core/src/lib/qt_smoke.cpp

--- old-qt.core/src/lib/qt_smoke.cpp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/lib/qt_smoke.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,53 @@

+#include "cl_smoke_qt.h"

+#include <qnamespace.h>

+#include <QEvent>

+#include <QtDebug>

+/** @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

+cl_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*

+cl_smoke_meta_object(void* object)

+ Q_ASSERT(object);

+ static_cast<QObject*>(object)->metaObject();

+} // extern "C"

diff -rN -u old-qt.core/src/lib/qvector.cpp new-qt.core/src/lib/qvector.cpp

--- old-qt.core/src/lib/qvector.cpp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/lib/qvector.cpp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,27 @@

+#include "cl_smoke_qt.h"

+#include <QVector>

+#include <QPoint>

+extern "C" {

+/** Construct a 0 sized QVector.

+ * Since the QVectorData is QVectorData::shared_null the template type does not matter.

+ * @return A null QVector

+ */

+CL_SMOKE_QT_EXPORT void*

+cl_smoke_make_qvector()

+ return new QVector<QPoint>();

+/** Deletes a null QVector. i.e.: The QVectorData pointer is 0.

+ * @param qvector a null QVector

+ */

+CL_SMOKE_QT_EXPORT void

+cl_smoke_delete_qvector(void* qvector)

+ delete static_cast<QVector<QPoint>*>(qvector);

+} // extern "C"

diff -rN -u old-qt.core/src/lisp-object.lisp new-qt.core/src/lisp-object.lisp

--- old-qt.core/src/lisp-object.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/lisp-object.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,37 +1,43 @@

-(in-package :cl-smoke.qt-impl)

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

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

- (incf id)))

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

+ (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 cl-smoke-setup-lisp-object :int

(destruct :pointer))

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

+(defcfun cl-smoke-lisp-object-id :unsigned-int

(object :pointer))

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

+(defcfun cl-smoke-lisp-object-is-set :int

(object :pointer))

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

- (id :int))

+(defcfun cl-smoke-make-lisp-object :pointer

+ (id :unsigned-int))

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

+(defcfun cl-smoke-free-lisp-object :void

(object :pointer))

(defcallback destruct-cxx-lisp-object :void

- ((id :int))

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

+ (cl-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))

(assert (>= *cxx-lisp-object-metatype*

(smoke::value qt:meta-type.+user+))

(*cxx-lisp-object-metatype*)

@@ -41,20 +47,20 @@

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

+ (cl-smoke-make-lisp-object id)))

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

"Deletes the lisp_object at POINTER."

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

+ (cl-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,

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

+ (gethash (cl-smoke-lisp-object-id pointer)

*cxx-lisp-objects*)

(assert present-p (value present-p)

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

diff -rN -u old-qt.core/src/list.lisp new-qt.core/src/list.lisp

--- old-qt.core/src/list.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/list.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,69 +1,117 @@

-(in-package :cl-smoke.qt-impl)

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

-(defmacro define-qlist-wrapper (type-name &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))

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

- ()

- (:actual-type :pointer))

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

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

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

- ,@(loop for type-name in (ensure-list type-name) collect

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

- ',list-type))

- ,@(loop for type-name in (ensure-list type-name) collect

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

- ,@(loop for type-name in (ensure-list type-name) collect

- `(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 *smoke-module* ,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)))))

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

- list ;; FIXME allow seqence and define element type

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

-(define-qlist-wrapper "QVariant")

-(define-qlist-wrapper ("QObject*" "QWidget*") "void")

-(define-qlist-wrapper "QByteArray")

+(defbitfield qlist-data-flags

+ :sharable)

+(defcstruct qlist-data

+ (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int)))

+ (alloc :int)

+ (begin :int)

+ (end :int)

+ (flags qlist-data-flags)

+ (array :pointer))

+(defcstruct qlist

+ (data (:pointer qlist-data)))

+(defun qlist-size (qlist)

+ (let ((data (foreign-slot-value qlist 'qlist 'data)))

+ (- (foreign-slot-value data 'qlist-data 'end)

+ (foreign-slot-value data 'qlist-data 'begin))))

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

+ (macrolet ((c-name (name)

+ `(nth-value 1 ,name))

+ (fun-names-let (name-pre-post-fixes &body body)

+ `(flet (,@(mapcar

+ #'(lambda (npp)

+ `(,(first npp) (type)

+ (values

+ (intern (string-upcase

+ (concatenate 'string

+ ,(second npp)

+ type

+ ,(third npp)))

+ ,*package*)

+ (concatenate 'string

+ (substitute #\_ #\-

+ ,(second npp))

+ type

+ (substitute #\_ #\-

+ ,(third npp))))))

+ name-pre-post-fixes))

+ ,@body)))

+ (fun-names-let ((list-free "cl-smoke-free-list-")

+ (list-make "cl-smoke-make-list-")

+ (list-at "cl-smoke-list-" "-at")

+ (list-append "cl-smoke-list-" "-append"))

+ (defmacro define-qlist-wrapper (type-name element-type &optional (c-name nil c-name-p)

+ &key def-cfuns)

+ (let* ((c-name (or c-name type-name))

+ (type c-name)

+ (lisp-type (symbolicate 'qlist- element-type)))

+ `(progn

+ ,(when (or (not c-name-p) def-cfuns)

+ `(progn

+ (defcfun ,(c-name (list-free type)) :void

+ "Frees LIST."

+ (list :pointer))

+ (defcfun ,(c-name (list-make type)) :pointer

+ "Makes a list.")

+ (defcfun ,(c-name (list-at type)) :pointer

+ "Returns the a newly constructed copy of the element at

+ position AT of LIST."

+ (list :pointer)

+ (index :int))

+ (defcfun ,(c-name (list-append type)) :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-list- type-name) (list-pointer)

+ (declare (optimize (speed 3)))

+ (let ((vector (make-array (qlist-size

+ list-pointer))))

+ (dotimes (index (length vector) vector)

+ (setf (elt vector index)

+ ;; FIXME the returned object is not wrapped by Smoke

+ ;; -> change this?

+ (object-to-lisp

+ (,(list-at type)

+ list-pointer index)

+ (make-smoke-type ,(symbolicate '*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-list- type-name)

+ ,(list-free type)))

+ ;; From Lisp

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

+ (let ((qlist (,(list-make type))))

+ (loop for element across list do

+ (,(list-append type)

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

+ (make-cleanup-pointer

+ qlist

+ (function ,(list-free type)))))

+ (defun ,(symbolicate lisp-type '-p) (list)

+ (every #'(lambda (element)

+ ;(typep element ',element-type))

+ (typep element (find-class ',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 lisp-type '-p)))

+ ,(symbolicate 'coerce- lisp-type)))))))))

+(define-qlist-wrapper "QVariant" qt:variant)

+(define-qlist-wrapper "QByteArray" qt:byte-array)

+(define-qlist-wrapper "QObject*" qt:object "void" :def-cfuns t)

diff -rN -u old-qt.core/src/msg-handler.lisp new-qt.core/src/msg-handler.lisp

--- old-qt.core/src/msg-handler.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/msg-handler.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,26 +1,24 @@

-(in-package :cl-smoke.qt-impl)

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

-(cffi:defcenum qt-msg-type

- (:debug-message)

- (:warning-message)

- (:critical-message)

- (:fatal-message))

+;; 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

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

+ (#.(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-when (:load-toplevel)

- (register-msg-handler))

+(eval-startup (:load-toplevel)

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

diff -rN -u old-qt.core/src/object.lisp new-qt.core/src/object.lisp

--- old-qt.core/src/object.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/object.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,11 +1,18 @@

-(in-package :cl-smoke.qt-impl)

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

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

- (defmethod cxx:static-meta-object ((class (eql (find-class 'qt: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))))

+;; 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 cl-smoke-meta-object :pointer (object :pointer))

+(defun meta-object (object)

+ (make-instance 'qt:meta-object

+ :pointer (cl-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)))

@@ -26,8 +33,21 @@

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

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

@@ -55,22 +75,51 @@

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

-(defun find-smoke-parent (object)

- "Returns the first parent of OBJECT or OBJECT that is a Smoke class.

- (the destructed callback is called when the object is freed.)"

- ;; FIXME allow usage of non smoke objects by connecting to the

- ;; destroyed() signal.

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

- (if (not (null-pointer-p (smoke::pointer parent)))

- (if (smoke::has-pointer-p (smoke::pointer parent))

- parent

- (find-smoke-parent parent))

- (error "No smoke parent found."))))

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

@@ -84,25 +133,26 @@

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

(parent-p object))

(smoke::transfer-ownership-to object

- (find-smoke-parent object))))

+ (ensure-smoke-parent object))))

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

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

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

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

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

@@ -118,7 +168,7 @@

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

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

(error (make-condition 'wrapper-gc

- :class-name (name class)

+ :object-class class

:pointer pointer)))

(error (condition)

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

@@ -135,10 +185,12 @@

;;;

-;;; The event-notify callback get called by QCoreApplication,

-;;; on notification of an event.

+;;; 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:

;;;

-;;; The DATA argument is an array of size three, containing the pointers:

;;; void* receiver

;;; void* event

;;; void* result

@@ -147,44 +199,49 @@

;;; Returning true marks the event as handled; false on the other hand

;;; leaves the event processing unchanged.

;;;

-;;; See: QCoreApplication::notifyInternal(QObject *receiver, QEvent *event)

+;;; 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 (make-instance 'qt:event

- :pointer (cffi:mem-aref data :pointer 1))))

+ (event (cast-event

+ (make-instance 'qt:event

+ :pointer (cffi:mem-aref data :pointer 1)))))

(enum-case (cxx:type event)

(qt:event.+child-added+

- (let ((child-event (make-instance 'qt:child-event

- :pointer

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

- (tg:cancel-finalization (cxx:child child-event))

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

- (unless receiver

- (setf receiver (find-smoke-parent (cxx:child child-event))))

- (smoke::transfer-ownership-to (cxx:child child-event) receiver))))

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

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

- :pointer (smoke::upcast event

- (find-class 'qt: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)))

- (assert receiver)

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

+ ;; 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

+ (cffi:defcfun cl-smoke-register-event-notify :boolean

(event-notify :pointer)))

(defun register-event-notify ()

- (let ((ret (qt-smoke-register-event-notify (cffi:callback event-notify))))

+ (let ((ret (cl-smoke-register-event-notify (cffi:callback event-notify))))

(unless ret

- (error "The Qt event-notify callback table is full."))))

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

-(smoke:eval-startup ()

+(eval-startup ()

(register-event-notify))

diff -rN -u old-qt.core/src/operator.lisp new-qt.core/src/operator.lisp

--- old-qt.core/src/operator.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/operator.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

(defun cxx:= (object &rest more-objects)

(if (null more-objects)

@@ -6,9 +6,11 @@

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

+ (if (typep object 'smoke-standard-object)

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

+ (no-applicable-cxx-method ()

+ (cxx:operator== object o)))

+ (qt:operator== object o)))

more-objects)))

(defun cxx:/= (object &rest more-objects)

@@ -88,13 +90,6 @@

(index)

"Index ~A for ~A requested, but the length is ~A"

index object (cxx:size object))

- ;; FIXME smoke generates no destructor for QByteRef

- ;; kaylptusCxxToSmoke.pm 954:

- ;; # Also, if the class has no explicit destructor, generate a default one.

- ;; if ( !$hasDestructor && !$hasPrivatePureVirtual && !$isGlobalSpace && $classNode->{NodeType} ne 'namespace' ) {

- ;; > $hasPublicDestructor = 1;

- ;; > $hasPublicProtectedConstructor = 1;

- ;;

(cxx:operator= (cxx:operator[] object index)

new-value)

diff -rN -u old-qt.core/src/ownership.lisp new-qt.core/src/ownership.lisp

--- old-qt.core/src/ownership.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/ownership.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,79 +1 @@

-(in-package :cl-smoke.qt-impl)

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

-;; Allocates return value

-;; QLineEdit::createStandardContextMenu()

-;; parent

-;; QListwidgetitem

-;; Relases ownership

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

-;; etc

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

diff -rN -u old-qt.core/src/package.lisp new-qt.core/src/package.lisp

--- old-qt.core/src/package.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/package.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,8 +1,13 @@

-(defpackage :cl-smoke.qt-impl

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

+(defpackage :cl-smoke.qt.core

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

+ (:export #:define-qvector-translations

+ #:with-application

+ #:delete-app

+ #:ensure-app

+ #:kill-app))

(defpackage :cl-smoke.qt

- (:use) ;; do not use :cl to prevent collition with TIME and CHAR

+ (:use) ;; do not use :cl to prevent collision with TIME and CHAR

(:nicknames :qt)

(:export #:app

#:app-p

diff -rN -u old-qt.core/src/painter.lisp new-qt.core/src/painter.lisp

--- old-qt.core/src/painter.lisp 2014-10-30 07:30:21.000000000 +0100

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

@@ -1,16 +0,0 @@

-(in-package :cl-smoke.qt-impl)

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

- "Binds a PAINTER instance for PAINT-DEVICE to PAINTER

- during the evaulation of BODY.

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

-still active and not yet garbage collected painters."

- `(let ((,painter (make-instance 'qt: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))))

diff -rN -u old-qt.core/src/properties.lisp new-qt.core/src/properties.lisp

--- old-qt.core/src/properties.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/properties.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,8 +1,29 @@

-(in-package :cl-smoke.qt-impl)

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

(defun reverse-lispify (symbol)

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

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

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

@@ -12,33 +33,48 @@

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

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

- (make-instance 'qt:variant

- :args (list new-value)))

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

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

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

+ (sort-symbols

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

(:method ((symbol symbol))

(qt:class-properties (find-class symbol))))

@@ -50,10 +86,12 @@

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

(defun dynamic-properties (object)

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

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

- (nconc (dynamic-properties object)

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

+ (declare (type qt:object object))

+ (sort-symbols

+ (nconc (dynamic-properties object)

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

diff -rN -u old-qt.core/src/qstring.lisp new-qt.core/src/qstring.lisp

--- old-qt.core/src/qstring.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/qstring.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,66 +1,57 @@

-(in-package :cl-smoke.qt-impl)

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

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

+(defcfun cl-smoke-string-to-qstring :pointer

(data :string)

(length :int))

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

+(defcfun cl-smoke-free-qstring :void

(string :pointer))

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

+(defcfun cl-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.

+;;; 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*))))

-(define-parse-method qstring ()

- (make-instance 'qstring))

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

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

- "data")))

- (defmethod cxx:data ((array qt: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 'qt: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))

+ (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 (cl-smoke-qstring-to-byte-array qstring))))

+(define-to-lisp-translation ("QString" "const QString&")

+ from-qstring cl-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))

- #'(lambda (pointer)

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

- nil))))

+ (cl-smoke-string-to-qstring data length))

+ #'cl-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.core/src/qt.core.lisp new-qt.core/src/qt.core.lisp

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

+++ new-qt.core/src/qt.core.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,39 @@

+;;;

+;;; 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.core)

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

+ (define-smoke-module :cl-smoke.qt libsmokeqtcore

+ (*qt-core-smoke* "qtcore_Smoke")

+ (init-qt-smoke "init_qtcore_Smoke"))

+ (define-foreign-library libclsmokeqtcore

+ (:darwin "libclsmokeqtcore.dylib")

+ (:unix "libclsmokeqtcore.so")

+ (t (:default "libclsmokeqtcore")))

+ (use-foreign-library libclsmokeqtcore))

diff -rN -u old-qt.core/src/qt.lisp new-qt.core/src/qt.lisp

--- old-qt.core/src/qt.lisp 2014-10-30 07:30:21.000000000 +0100

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

@@ -1,40 +0,0 @@

-;;;

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

- #-mudballs

- (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.core/src/signal-slot/connect.lisp new-qt.core/src/signal-slot/connect.lisp

--- old-qt.core/src/signal-slot/connect.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/signal-slot/connect.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

(defgeneric qt:connect (qsignal slot &optional type)

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

@@ -13,7 +13,9 @@

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

+ (if (typep signal-arg '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)

@@ -39,9 +41,10 @@

(defmethod qt:connect ((sender qsignal) (function function) &optional type)

(let ((slot (make-instance 'qslot

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

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

@@ -63,6 +66,14 @@

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

@@ -70,18 +81,18 @@

(:method (receiver (function function))

"Returns a slot for RECEIVER that calls function

with RECEIVER as the first argument."

- (let ((slot (qt:make-slot #'(lambda (&rest args)

- (apply function (cxx:parent *this*)

- args)))))

- (cxx:set-parent slot receiver)

- slot)))

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

+ (if (string= name normalized-name) ;; Avoid infinite recursion

form

`(qt:get-slot ,receiver ,normalized-name)))

form))

@@ -95,7 +106,7 @@

(if (stringp name)

(let ((normalized-name (cxx:data

(qt:meta-object.normalized-signature name))))

- (if (string= name normalized-name) ;; Avoid loop

+ (if (string= name normalized-name) ;; Avoid infinite recursion

form

`(qt:get-signal ,sender ,normalized-name)))

form))

@@ -103,39 +114,43 @@

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

+ (or type qt:+auto-connection+))

+ (cerror "Ignore"

+ "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) (qt:qslot (name qt-slot)))

+ (cerror "Ignore"

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

+ (cerror "Ignore"

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

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

+ :arg0 (qsender qt-signal)

:slot-function function

:argument-types

- (method-arguments-type

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

- signal-id))))

+ (method-arguments-type (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)))

@@ -147,13 +162,11 @@

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

+ (check-argument-types (method-arguments-type (qsender qt-signal)

signal-id)

(arguments slot))

(setf (slot-value slot 'arguments)

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

- signal-id)))

+ (method-arguments-type (qsender qt-signal) signal-id)))

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

slot (id slot)

type (types (arguments slot)))

@@ -166,12 +179,10 @@

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

+ (method-arguments-type (receiver slot)

slot-id))

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

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

- slot-id)))

+ (method-arguments-type (receiver slot) slot-id)))

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

(receiver slot) slot-id

type

@@ -183,8 +194,8 @@

(qt:meta-object.connect sender signal-id

receiver slot-id

(if (null type)

- (value qt:+auto-connection+)

- (value type))

+ qt:+auto-connection+

+ type)

types))

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

diff -rN -u old-qt.core/src/signal-slot/signal-slot.lisp new-qt.core/src/signal-slot/signal-slot.lisp

--- old-qt.core/src/signal-slot/signal-slot.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/signal-slot/signal-slot.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

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

diff -rN -u old-qt.core/src/signal-slot/signal.lisp new-qt.core/src/signal-slot/signal.lisp

--- old-qt.core/src/signal-slot/signal.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/signal-slot/signal.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,5 +1,4 @@

-(in-package :cl-smoke.qt-impl)

-(declaim (optimize (debug 3)))

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

(defclass qsignal-mixin ()

((signal-object :accessor signal-object

@@ -49,18 +48,17 @@

argument-types))

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

#'(lambda (&rest args)

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

- )

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

(defun find-slot-id (receiver slot)

"Returns the ID of RECEIVER from SLOT."

- ;; For efficency assume that SLOT is normalized and fallback

- ;; to normalzing when not. (Just like Qt does.)

+ ;; 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)

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

+ (qt:meta-object.normalized-signature slot))))

(when (< id 0)

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

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

@@ -70,52 +68,53 @@

(defun make-lisp-object (object)

- (smoke::make-cleanup-pointer (make-cxx-lisp-object object)

- #'qt-smoke-free-lisp-object))

+ (make-cleanup-pointer (make-cxx-lisp-object object)

+ #'cl-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)

+ (if (typep type 'smoke-type)

+ (smoke:convert-argument argument type)

(progn (assert (typep argument type)

()

- "The argument ~S is not of type ~S.")

+ "The argument ~S is not of type ~S."

+ argument type)

(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

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

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

+ (= 0 (type-id type))

+ (= 13 (type-id type)))

(foreign-slot-value

- (mem-aref (pointer stack)

+ (mem-aref (smoke::call-stack-pointer stack)

'smoke::smoke-stack-item

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

(foreign-slot-pointer

- (mem-aref (pointer stack)

+ (mem-aref (smoke::call-stack-pointer stack)

'smoke::smoke-stack-item

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

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

- (null-pointer))

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

- (id qsignal)

- args)))))

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

diff -rN -u old-qt.core/src/signal-slot/slot.lisp new-qt.core/src/signal-slot/slot.lisp

--- old-qt.core/src/signal-slot/slot.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/signal-slot/slot.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,10 +1,10 @@

-(in-package :cl-smoke.qt-impl)

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

(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 function specified")

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

@@ -30,6 +30,7 @@

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

@@ -48,13 +49,13 @@

(defun find-signal-id (sender signal)

"Returns the ID of SIGNAL from SENDER."

- ;; For efficency assume that SIGNAL is normalized and fallback

- ;; to normalzing when not. (Just like Qt does.)

+ ;; 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)

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

+ (qt:meta-object.normalized-signature signal))))

(when (< id 0)

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

signal (class-of sender)))

diff -rN -u old-qt.core/src/signal-slot/translate.lisp new-qt.core/src/signal-slot/translate.lisp

--- old-qt.core/src/signal-slot/translate.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/signal-slot/translate.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,22 +1,29 @@

-(in-package :cl-smoke.qt-impl)

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

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

+(defun find-type (smoke-module name &optional start end)

+ (let ((type (make-smoke-type smoke-module (subseq name start end))))

+ (assert (not (zerop (id type)))

+ ()

+ "No type named ~S found in ~A."

+ (subseq name start end) smoke-module)

+ type))

+(defun method-arguments-type (object index)

+ "Returns a type name list for the arguments of method INDEX of OBJECTs metaobject."

+ (let* ((metaobject (cxx:meta-object object))

+ (signature (cxx:signature (cxx:method metaobject index)))

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

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

(argument-types ())

- (last-pos (length arguments)))

+ (last-pos (length arguments))

+ (smoke-module (smoke (class-of object))))

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

while pos

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

- (setf last-pos pos))

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

+ (setf last-pos pos))

(when (> last-pos 0)

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

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

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

@@ -27,7 +34,7 @@

(nconc values

(list

(typecase (first types)

- (smoke::smoke-type

+ (smoke-type

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

(first types)))

@@ -37,26 +44,26 @@

(defun disown-object (object)

(tg:cancel-finalization object)

- (unless (smoke::virtual-destructor-p (class-of object))

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

+ (unless (virtual-destructor-p (class-of object))

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

+ (if (class-p type)

+ (if (pointer-p type)

+ (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 (object-to-lisp pointer type)))

+ (ecase (type-id type)

+ (0 (if-let ((translation (gethash (name type) *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)))

@@ -75,22 +82,23 @@

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

+ (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 (qt:meta-type.type (smoke::name smoke-type))))

+ (smoke-standard-object

+ (if (pointer-p smoke-type)

+ (error "Not implemented: pointer type.") ;;qmetatype.+voidstar+

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

(assert (/= 0 type)

(type)

"The type ~S has no QMetaType."

- (smoke::name smoke-type))

+ (name smoke-type))

type)))

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

@@ -98,7 +106,7 @@

(defun types (smoke-types)

"Returns a newly allocated array of QMetaType IDs of SMOKE-TYPES."

- ;;FIXME free TYPES on error.

+ ;; FIXME free TYPES on error.

(let ((types (cffi:foreign-alloc :int :count (1+ (length smoke-types))))

(index 0))

(dolist (type smoke-types)

diff -rN -u old-qt.core/src/string-list.lisp new-qt.core/src/string-list.lisp

--- old-qt.core/src/string-list.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/string-list.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,61 +1,49 @@

-(in-package :cl-smoke.qt-impl)

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

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

+(defcfun cl-smoke-string-list-size :int

(string-list :pointer))

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

+(defcfun cl-smoke-string-list-at :pointer

(string-list :pointer)

(index :int))

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

+(defcfun cl-smoke-free-string-list :void

(string-list :pointer))

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

+(defcfun cl-smoke-make-string-list :pointer)

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

+(defcfun cl-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))))

+(defun from-string-list (string-list)

+ (let ((vector (make-array (cl-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

+ :pointer (cl-smoke-string-list-at

string-list index)))))))

+(define-to-lisp-translation ("QStringList" "const QStringList&")

+ from-string-list cl-smoke-free-string-list)

+(defun coerce-string-list (sequence)

+ (let ((string-list (cl-smoke-make-string-list)))

+ (map nil

+ #'(lambda (string)

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

+ (cl-smoke-string-list-append string-list data length)))

+ sequence)

+ (make-cleanup-pointer

+ string-list #'cl-smoke-free-string-list)))

-(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 'string-list))

- #'(lambda (pointer)

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

- nil))))

+(defun string-list-p (sequence)

+ (every #'stringp sequence))

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

- (vector string) coerce-string-list)

+ (and (vector string)

+ (satisfies string-list-p))

+ coerce-string-list)

diff -rN -u old-qt.core/src/timer.lisp new-qt.core/src/timer.lisp

--- old-qt.core/src/timer.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/timer.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

(defclass single-shot-timer (qt:object)

((function :initarg :function

@@ -25,6 +25,7 @@

`(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.core/src/variant.lisp new-qt.core/src/variant.lisp

--- old-qt.core/src/variant.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/src/variant.lisp 2014-10-30 07:30:21.000000000 +0100

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

-(in-package :cl-smoke.qt-impl)

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

(defmethod print-object ((variant qt:variant) stream)

"Print the type and value of the variant."

@@ -15,16 +15,16 @@

"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 :args (list value))

+ (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 :args (list (aref octets 0))))

+ (1 (make-instance 'qt:char :arg0 (aref octets 0)))

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

- (aref octets 1))))

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

@@ -34,7 +34,7 @@

(cxx:is-low-surrogate char)))

(defun qt:from-char (char)

- "Returns the lisp character represented by CHAR."

+ "Returns the Lisp character represented by CHAR."

(assert (not (surrogate-p char))

(char)

"The char ~A is part of a surrogate.")

@@ -54,11 +54,11 @@

(princ (qt:from-char char) stream))))

-;; FIXME include in MAKE-VARIANT?

+;; 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

+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

@@ -66,48 +66,69 @@

object))

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

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

+(defcfun cl-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 copy-object-from-pointer (class pointer)

+ (make-instance class :arg0 (make-instance class :pointer pointer)))

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

+(eval-startup ()

+;; *cxx-lisp-object-metatype* can change when loading an image

+(eval '

+ (macrolet

+ ((variant-conversions ((variant) &body types)

+ (let* ((special-types '(long-long ulong-long map list hash))

+ (exclude-types

+ (append '(63) ;; ColorGroup

+ (mapcar #'(lambda (s)

+ (value

+ (symbol-value

+ (intern (format nil "VARIANT.+~A+" s)

+ :qt))))

+ special-types)))

+ (qt-types (loop for i from 1 to (value qt:variant.+user-type+)

+ when (and (qt:variant.type-to-name i)

+ ;; type-to-name returns longlong but

+ ;; should be LongLong

+ (not (member i exclude-types)))

+ collect

+ (smoke::lispify (qt:variant.type-to-name i)

+ :qt))))

+ `(ecase (cxx:user-type ,variant)

+ ,@(loop for type in (append special-types

+ (remove nil qt-types))

+ collect

+ `(,(value (symbol-value

+ (let ((*package*

+ (find-package :cl-smoke.qt)))

+ (symbolicate 'variant.+ type '+))))

+ ,(if (fboundp (intern (format nil "TO-~A" type) :cxx))

+ `(,(intern (format nil "TO-~A" type) :cxx) ,variant)

+ `(copy-object-from-pointer

+ ;; intern since these types are in

+ ;; qt.gui not qt.core

+ (intern ,(symbol-name type) :qt)

+ (cxx:const-data ,variant)))))

+ ,@(loop for type in types

+ collect

+ `(,(eval (first type))

+ ,@(rest 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))

+ (*cxx-lisp-object-metatype*

+ (let* ((lisp-object (cl-smoke-lisp-object-value (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."

diff -rN -u old-qt.core/src/vector.lisp new-qt.core/src/vector.lisp

--- old-qt.core/src/vector.lisp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.core/src/vector.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -0,0 +1,123 @@

+;; see: "Inside the Qt 4 Containers"

+;; http://doc.trolltech.com/qq/qq19-containers.html#sequentialcontainers

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

+(defcfun cl-smoke-make-qvector :pointer)

+(defcfun cl-smoke-delete-qvector :void

+ (vector :pointer))

+(defbitfield qvector-data-flags

+ :sharable

+ :capacity)

+(defcstruct qvector-data

+ (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int)))

+ (alloc :int)

+ (size :int)

+ (flags qvector-data-flags))

+(defcstruct qvector-type-data

+ (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int)))

+ (alloc :int)

+ (size :int)

+ (flags qvector-data-flags)

+ (array :pointer))

+;; FIXME We assume QVector to be a POD struct, which is not

+;; neccesarily the case.

+(defcstruct qvector

+ (data (:pointer qvector-data)))

+(defun qvector-size (qvector)

+ (foreign-slot-value (foreign-slot-value qvector 'qvector 'data)

+ 'qvector-data 'size))

+(defun qvector-elt (qvector index element-type)

+ (pointer-to-lisp

+ (cffi:inc-pointer

+ (foreign-slot-pointer (foreign-slot-value qvector 'qvector 'data)

+ 'qvector-type-data 'array)

+ (* index (type-size element-type)))

+ element-type))

+(defun from-qvector (qvector element-type)

+ (let ((result (make-array (qvector-size qvector))))

+ (dotimes (i (length result) result)

+ (setf (elt result i)

+ (qvector-elt qvector i element-type)))))

+(defcfun memcpy :pointer

+ (destination :pointer)

+ (source :pointer)

+ (size :unsigned-int))

+(defun make-qvector (element-type elements)

+ (let* ((length (length elements))

+ (element-size (type-size element-type))

+ (data (foreign-alloc :char :count (+ (foreign-type-size 'qvector-data)

+ (* length element-size))))

+ (darray (foreign-slot-pointer data 'qvector-type-data 'array))

+ (vector (cl-smoke-make-qvector)))

+ (unless (stack-p element-type)

+ (error "FIXME: TODO"))

+ (if (class-p element-type)

+ (dotimes (i length)

+ (memcpy (inc-pointer darray (* i element-size))

+ (pointer (elt elements i))

+ element-size))

+ (dotimes (i length)

+ (setf (mem-aref darray (type-foreign-keyword element-type) i)

+ (elt elements i))))

+ (setf (mem-ref data :int) 1) ;; ref count

+ (with-foreign-slots ((ref alloc size flags)

+ data qvector-data)

+ (setf alloc length ;; allocated size

+ size length

+ flags :sharable)

+ (setf (foreign-slot-value vector 'qvector 'data)

+ data))

+ vector))

+(defun deref (basic-atomic-int-pointer)

+ ;; decrement and return true when the new value is non-zero

+ (cxx:deref

+ (make-instance 'qt:basic-atomic-int :pointer basic-atomic-int-pointer)))

+(defun free-qvector (vector)

+ (unless (null-pointer-p (foreign-slot-value vector 'qvector 'data))

+ (let ((data (foreign-slot-value vector 'qvector 'data)))

+ (unless (deref (foreign-slot-pointer data 'qvector-type-data 'ref))

+ (foreign-free data)))

+ (setf (foreign-slot-value vector 'qvector 'data)

+ (null-pointer)))

+ (cl-smoke-delete-qvector vector))

+(defmacro define-qvector-translations (element-type lisp-type)

+ `(progn

+ (defun ,(symbolicate 'from-vector- element-type) (elements)

+ (make-cleanup-pointer

+ (make-qvector (make-smoke-type *smoke-module* ,element-type)

+ elements)

+ #'free-qvector))

+ (defun ,(symbolicate 'vector- element-type '-p) (sequence)

+ (every #'(lambda (element)

+ (typep element ',lisp-type))

+ sequence))

+ (defun ,(symbolicate 'to-vector- element-type) (pointer)

+ (from-qvector pointer (make-smoke-type *smoke-module* ,element-type)))

+ (define-from-lisp-translation (,(format nil "QVector<~A>" element-type)

+ ;; FIXME QImage::setColorTable

+ ;; has an "const QVector<QRgb>"

+ ;; argument!

+ ,(format nil "const QVector<~A>" element-type)

+ ,(format nil "const QVector<~A>&" element-type))

+ (and vector

+ (satisfies ,(symbolicate 'vector- element-type '-p)))

+ ,(symbolicate 'from-vector- element-type))

+ (define-to-lisp-translation (,(format nil "QVector<~A>" element-type)

+ ,(format nil "const QVector<~A>&" element-type))

+ ,(symbolicate 'to-vector- element-type)

+ free-qvector)))

+(define-qvector-translations "double" double-float)

diff -rN -u old-qt.core/test.lisp new-qt.core/test.lisp

--- old-qt.core/test.lisp 2014-10-30 07:30:21.000000000 +0100

+++ new-qt.core/test.lisp 2014-10-30 07:30:21.000000000 +0100

@@ -1,25 +1,16 @@

+v v v v v v v

+cmake ./

+make

+*************

+cmake ./ || exit 1

+make || exit 1

+^ ^ ^ ^ ^ ^ ^

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.core)

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

(sb-ext:quit)

diff -rN -u old-qt.core/tests/test.lisp new-qt.core/tests/test.lisp

--- old-qt.core/tests/test.lisp 2014-10-30 07:30:21.000000000 +0100

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

@@ -1 +0,0 @@

-(mb:test :qt.tests)

Crece desde el pueblo el futuro / crece desde el pie

RSS