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

* Fix loading on OSX.

Thanks to Elliott Slaughter

- (:unix "libclsmokeqtcore.so")

+ (:darwin "libclsmokeqtcore.dylib")

+ (:unix "libclsmokeqtcore.so")

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.

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

- (remove nil qt-types))

- collect

- (if (symbolp type)

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

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

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

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

* cleanup

- list-pointer))))

+ list-pointer))))

- (smoke:object-to-lisp

+ (object-to-lisp

- (smoke:make-smoke-type ,(symbolicate '*smoke-module*)

- ,type-name)))))))

+ (make-smoke-type ,(symbolicate '*smoke-module*)

+ ,type-name)))))))

-(defun from-vector-point (elements)

- (make-cleanup-pointer

- (make-qvector (make-smoke-type *smoke-module* "QPoint")

- elements)

- #'free-qvector))

-

-(defun vector-point-p (sequence)

- (every #'(lambda (element) (typep element 'qt:point))

- sequence))

-

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

* Make qt:application cleanup more stable

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

- (setf (slot-value application 'pointer) (null-pointer))

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

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

* support all from qt:variant conversions.

-(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 (cl-smoke-lisp-object-value (pointer variant)))

- (value))

- (setf value (translate-cxx-lisp-object lisp-object))

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

- value))))

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

+ (remove nil qt-types))

+ collect

+ (if (symbolp type)

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

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

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.

-add_library(clsmokeqtcore MODULE ${QT_SMOKE_SOURCES})

+add_library(clsmokeqtcore SHARED ${QT_SMOKE_SOURCES})

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

* Test building libclsmokeqtcore

+cmake ./ || exit 1

+make || exit 1

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

* Add qvector.cpp

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

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.

-CL_SMOKE_QT_EXPORT int \

-cl_smoke_list_ ## NAME ## _size(const void* list) \

-{ \

- return static_cast<const QList< TYPE >*>(list)->size(); \

-} \

-\

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

+

- (fun-names-let ((list-size "cl-smoke-list-" "-size")

- (list-free "cl-smoke-free-list-")

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

- (defcfun ,(c-name (list-size type)) :int

- "Returns the size of LIST."

- (list :pointer))

- (let ((vector (make-array (,(list-size type)

+ (declare (optimize (speed 3)))

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

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)

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

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

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.

+ #:delete-app

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

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

-(defun qvector-aref (qvector index element-type)

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

- (setf (aref result i)

- (qvector-aref qvector i element-type)))))

+ (setf (elt result i)

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

- (pointer (aref elements i))

+ (pointer (elt elements i))

- (aref elements i))))

+ (elt elements i))))

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

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

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

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

- (type (string-upcase c-name))

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

- `(progn

- (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_size") :int

- "Returns the size of LIST."

- (list :pointer))

- (defcfun ,(concatenate 'string "cl_smoke_free_list_" c-name) :void

- "Frees LIST."

- (list :pointer))

- (defcfun ,(concatenate 'string "cl_smoke_make_list_" c-name) :pointer

- "Makes a list.")

- (defcfun ,(concatenate 'string "cl_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 "cl_smoke_list_" c-name "_append") :pointer

- "Appends NEW-ELEMENT to LIST."

- (list :pointer)

- (new-element :pointer))

- ;; To Lisp

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

- `(defun ,(symbolicate 'from- type-name) (list-pointer)

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

- type '-size)

- list-pointer))))

- (dotimes (index (length vector) vector)

- (setf (aref vector index)

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

- ;; -> change this? [_$_]

- (smoke::object-to-lisp

- (,(symbolicate 'cl-smoke-list-

- type '-at)

- list-pointer index)

- (smoke::make-smoke-type *smoke-module*

- ,type-name)))))))

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

- `(define-to-lisp-translation

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

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

- ,(symbolicate 'from- type-name)

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

- ;; From Lisp

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

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

- (loop for element across list do

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

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

- (make-cleanup-pointer

- qlist

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

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

- (every #'(lambda (element)

- (typep element ',element-type))

- list))

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

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

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

- ;; FIXME allow sequence

- (and (vector ,element-type)

- (satisfies ,(symbolicate list-type '-p)))

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

+(eval-when (:compile-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-size "cl-smoke-list-" "-size")

+ (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-size type)) :int

+ "Returns the size of LIST."

+ (list :pointer))

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

+ (let ((vector (make-array (,(list-size type)

+ list-pointer))))

+ (dotimes (index (length vector) vector)

+ (setf (elt vector index)

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

+ ;; -> change this? [_$_]

+ (smoke:object-to-lisp

+ (,(list-at type)

+ list-pointer index)

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

-;; FIXME it would be nice to have QList<QVariant> as fallback for any

-;; list we can not convert otherwise. e.g.: '("a" 1)

-(define-qlist-wrapper ("QObject*" "QWidget*") qt:object "void")

+

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

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

* Fix error reporting on signal-slot connection failure.

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

+ (cerror "Ignore"

+ "Failed to connect ~A ~A to ~A ~A."

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

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

+ (cerror "Ignore"

+ "Failed to disconnect everything connected to ~A."

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

* QVector<T> translation

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

- (setf (slot-value event 'smoke::pointer)

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

+ (setf (slot-value event 'pointer)

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

-set(QT_SMOKE_SOURCES qt_smoke.cpp qstring.cpp qstringlist.cpp lisp_object.cpp qlist.cpp)

+set(QT_SMOKE_SOURCES qt_smoke.cpp

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

+

-

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

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

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

+ (no-applicable-cxx-method ()

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

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

+ (:export #:define-qvector-translations

+ #:with-application

+ #:ensure-app

+ #:kill-app))

- (if (typep signal-arg 'smoke::smoke-type)

+ (if (typep signal-arg 'smoke-type)

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

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

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

+ #'cl-smoke-free-lisp-object))

- (if (typep type 'smoke::smoke-type)

- (smoke::convert-argument argument type)

+ (if (typep type 'smoke-type)

+ (smoke:convert-argument argument type)

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

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

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

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

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

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

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

- (smoke::smoke-type

+ (smoke-type

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

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

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

+ (remove-object (pointer object)))

- (if (smoke::class-p type)

- (if (smoke::pointer-p type)

- (smoke::object-to-lisp (mem-ref pointer :pointer) type)

+ (if (class-p type)

+ (if (pointer-p type)

+ (object-to-lisp (mem-ref pointer :pointer) type)

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

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

- (0 (if-let ((translation (gethash (name type) smoke::*to-lisp-translations*)))

+ (disown-object (object-to-lisp pointer type)))

+ (ecase (type-id type)

+ (0 (if-let ((translation (gethash (name type) *to-lisp-translations*)))

- (smoke::smoke-standard-object

- (if (smoke::pointer-p smoke-type)

+ (smoke-standard-object

+ (if (pointer-p smoke-type)

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

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

- (smoke::name smoke-type))

+ (name smoke-type))

- (let* ((lisp-object (cl-smoke-lisp-object-value (smoke::pointer variant)))

+ (let* ((lisp-object (cl-smoke-lisp-object-value (pointer variant)))

+;; 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-aref (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 (aref result i)

+ (qvector-aref 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 (aref elements i))

+ element-size))

+ (dotimes (i length)

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

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

+

+(defun from-vector-point (elements)

+ (make-cleanup-pointer

+ (make-qvector (make-smoke-type *smoke-module* "QPoint")

+ elements)

+ #'free-qvector))

+

+(defun vector-point-p (sequence)

+ (every #'(lambda (element) (typep element 'qt:point))

+ sequence))

+

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

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

-(defpackage qt-system

- (:use :cl :asdf))

-

-(in-package qt-system)

-

-(asdf:defsystem :qt

- :name :qt

+(defsystem :cl-smoke.qt.core

+ :name :cl-smoke.qt.core

- :description "Smoke Qt bindings."

- :depends-on (:smoke :smoke :cffi :alexandria)

+ :description "Smoke Qt core bindings."

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

- (:file "qt" :depends-on ("package" "lib"))

- (:file "ownership" :depends-on ("qt"))

- (:file "event" :depends-on ("qt"))

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

- (:file "operator" :depends-on ("qt" "object"))

- (:file "application" :depends-on ("qt" "properties"))

- (:file "qstring" :depends-on ("qt"))

- (:file "list" :depends-on ("qt"))

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

- (:file "painter" :depends-on ("qt"))

- (:file "timer" :depends-on ("qt"))

- (:file "i18n" :depends-on ("qt"))

- (:file "lisp-object" :depends-on ("qt" "lib"))

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

- (:file "string-list" :depends-on ("qt" "lib" "qstring"))

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

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

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

-(defmethod asdf:perform ((operation test-op) (c (eql (find-system :qt))))

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

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

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

+ nil)

+

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

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

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

-(defmethod operation-done-p ((o test-op) (c (eql (find-system :cl-smoke.qt.core))))

- nil)

-

-(defvar *widgets* nil)

- (application 'qt:application)

+ (application 'qt:core-application)

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

+ (app (make-instance application :args (list argc argv))))

+(defgeneric delete-app (application)

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

+ (setf (slot-value application 'pointer) (null-pointer))

+ (makunbound '*app*)))

+

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

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

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

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

- ;; QApplication::allWidgets().

- ;; [_$_]

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

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

- (tg:cancel-finalization widget)))

- (cxx:quit (qt:app))

- (setf *widgets* nil)

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

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

- ;; Lisp side.

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

- (setf (slot-value (qt:app) 'pointer) (null-pointer))

- (makunbound '*app*))

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

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

- "Ensures that a APPLICATION instance exists, [_$_]

-evaluates BODY and executes the APPLICATION instance after BODY.

-The instance can be accessed with:

-QT:APP.

-

-Can be nested.

-

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

-from BODY."

- (assert (null options)

- (options)

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

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

- ,@body))

-

- (if qt:*exec-p*

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

- (cxx:quit (qt:app))

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

- :report-function

- #'(lambda (stream)

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

- :test-function

- #'(lambda (condition)

- (declare (ignore condition))

- (and (qt:app-p)

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

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

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

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

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

+ (when qt:*exec-p*

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

+ (cxx:quit (qt:app))

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

+ :report-function

+ #'(lambda (stream)

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

+ :test-function

+ #'(lambda (condition)

+ (declare (ignore condition))

+ (and (qt:app-p)

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

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

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

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

+add_library(clsmokeqtcore MODULE ${QT_SMOKE_SOURCES})

+target_link_libraries(clsmokeqtcore ${QT_LIBRARIES})

+set_target_properties(clsmokeqtcore

-install(TARGETS qt-smoke-extra

- LIBRARY DESTINATION lib)

+install(TARGETS clsmokeqtcore LIBRARY DESTINATION lib)

-#include "lisp-object.h"

+#include "lisp_object.h"

+

+#include "cl_smoke_qt.h"

+#include <QVariant>

-int

-qt_smoke_setup_lisp_object(void* destruct)

+CL_SMOKE_QT_EXPORT int

+cl_smoke_setup_lisp_object(void* destruct)

-unsigned int

-qt_smoke_lisp_object_id(const void* object)

+CL_SMOKE_QT_EXPORT unsigned int

+cl_smoke_lisp_object_id(const void* object)

-int

-qt_smoke_lisp_object_is_set(const void* object)

+CL_SMOKE_QT_EXPORT int

+cl_smoke_lisp_object_is_set(const void* object)

-void*

-qt_smoke_make_lisp_object(unsigned int id)

+CL_SMOKE_QT_EXPORT void*

+cl_smoke_make_lisp_object(unsigned int id)

-void*

-qt_smoke_free_lisp_object(void* object)

+CL_SMOKE_QT_EXPORT void*

+cl_smoke_free_lisp_object(void* object)

-#include <QVariant>

-void*

-qt_smoke_lisp_object_value(const void* variant)

+CL_SMOKE_QT_EXPORT void*

+cl_smoke_lisp_object_value(const void* variant)

+#include "cl_smoke_qt.h"

+

-#include "cl_smoke_qt.h"

-

- qt_smoke_setup_lisp_object(void* destruct);

+ cl_smoke_setup_lisp_object(void* destruct);

- qt_smoke_lisp_object_id(const void* object);

+ cl_smoke_lisp_object_id(const void* object);

- qt_smoke_lisp_object_is_set(const void* object);

+ cl_smoke_lisp_object_is_set(const void* object);

- qt_smoke_make_lisp_object(unsigned int id);

+ cl_smoke_make_lisp_object(unsigned int id);

- qt_smoke_free_lisp_object(void* object);

+ cl_smoke_free_lisp_object(void* object);

- qt_smoke_lisp_object_value(const void* variant);

+ cl_smoke_lisp_object_value(const void* variant);

- ::qt_smoke_setup_lisp_object(void* destruct);

+ ::cl_smoke_setup_lisp_object(void* destruct);

-#include <QList>

+#include <QList>

+

-qt_smoke_list_ ## NAME ## _size(const void* list) \

+cl_smoke_list_ ## NAME ## _size(const void* list) \

-qt_smoke_free_list_ ## NAME (void* list) \

+cl_smoke_free_list_ ## NAME (void* list) \

-qt_smoke_make_list_ ## NAME () \

+cl_smoke_make_list_ ## NAME () \

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

+cl_smoke_list_ ## NAME ## _at(const void* list, int index) \

-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \

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

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

+cl_smoke_list_ ## NAME ## _at(const void* list, int index) \

-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \

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

-#include <QtDebug>

-qt_smoke_qstring_to_byte_array(const void* qstring)

+cl_smoke_qstring_to_byte_array(const void* qstring)

- Q_ASSERT(qstring);

-qt_smoke_free_qstring(void* qstring)

+cl_smoke_free_qstring(void* qstring)

-qt_smoke_string_to_qstring(const char* data, int length)

+cl_smoke_string_to_qstring(const char* data, int length)

+#include "cl_smoke_qt.h"

+

-#include <cstring>

-

-#include "cl_smoke_qt.h"

-qt_smoke_string_list_size(const void* string_list)

+cl_smoke_string_list_size(const void* string_list)

-qt_smoke_string_list_at(const void* string_list, int index)

+cl_smoke_string_list_at(const void* string_list, int index)

-qt_smoke_free_string_list(void* string_list)

+cl_smoke_free_string_list(void* string_list)

-qt_smoke_make_string_list()

+cl_smoke_make_string_list()

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

+#include "cl_smoke_qt.h"

+

-#include "cl_smoke_qt.h"

-

-qt_smoke_register_event_notify(void* callback)

+cl_smoke_register_event_notify(void* callback)

-qt_smoke_meta_object(void* object)

+cl_smoke_meta_object(void* object)

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

+(defcfun cl-smoke-setup-lisp-object :int

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

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

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

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

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

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

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

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

- (qt-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))

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

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

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

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

+ (cl-smoke-free-lisp-object pointer))

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

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

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

+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_size") :int

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

+ (defcfun ,(concatenate 'string "cl_smoke_free_list_" c-name) :void

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

+ (defcfun ,(concatenate 'string "cl_smoke_make_list_" c-name) :pointer

- (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_at") :pointer

+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_at") :pointer

- (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_append") :pointer

+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_append") :pointer

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

+ (let ((vector (make-array (,(symbolicate 'cl-smoke-list-

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

+ (,(symbolicate 'cl-smoke-list-

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

+ ,(symbolicate 'cl-smoke-free-list- type)))

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

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

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

+ (,(symbolicate 'cl-smoke-list- type '-append)

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

+ (function ,(symbolicate 'cl-smoke-free-list- type)))))

-(defcfun qt-smoke-meta-object :pointer (object :pointer))

+(defcfun cl-smoke-meta-object :pointer (object :pointer))

- :pointer (qt-smoke-meta-object (pointer object))))

+ :pointer (cl-smoke-meta-object (pointer object))))

- (cffi:defcfun qt-smoke-register-event-notify :boolean

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

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

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

-(declaim (optimize (debug 3)))

-;; undo-stack

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

- undo-command)

-

-

-#|

-;; FIXME TODO

-;; application

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

- ;; NOT QString style

- style) ;; STATIC [_$_]

-

-

-;; core-application

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

- event) ;; STATIC

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

- event) ;; STATIC

-|#

-

-;; AbstractFileEngine::beginEntryList return value

-

-;; grid-layout

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

- row column)

- item)

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

- row column row-span)

- item)

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

- row column row-span colum-span)

- item)

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

- row column row-span colum-span aligment)

- item)

-

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

- item)

-

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

-

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

- type creator)

- creator)

-

-

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

- item)

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

- item)

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

- column item)

- item)

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

- row item)

- item)

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

- row column item)

- item)

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

- row item)

- item)

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

- item)

- item)

-

-

-;; Allocates return value

-;; QLineEdit::createStandardContextMenu()

-

-;; parent

-;; QListwidgetitem

-

-

-;; Releases ownership

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

-;; etc

-

-(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 evaluation of BODY.

-

-Makes sure the painter ends after BODY; thus preventing problems with [_$_]

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

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

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

- (,painter)

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

- ,painter ,paint-device)

- (unwind-protect

- (progn ,@body)

- (cxx:end ,painter))))

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

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

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

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

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

+(defcfun cl-smoke-qstring-to-byte-array :pointer

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

+ :pointer (cl-smoke-qstring-to-byte-array qstring))))

- from-qstring qt-smoke-free-qstring)

+ from-qstring cl-smoke-free-qstring)

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

- #'qt-smoke-free-qstring))

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

+ #'cl-smoke-free-qstring))

-;;; Copyright (C) 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

+;;; Copyright (C) 2009, 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

-(define-smoke-module :cl-smoke.qt libsmokeqt

- (*qt-smoke* "qt_Smoke")

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

-

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

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

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

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

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

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

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

+

+ (define-foreign-library libclsmokeqtcore

+ (:unix "libclsmokeqtcore.so")

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

+ (use-foreign-library libclsmokeqtcore))

- (method-arguments-type

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

- signal-id))))

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

+ signal-id))))

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

- (qsender qt-signal))

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

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

- signal-id)))

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

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

- (receiver slot))

+ (method-arguments-type (receiver slot)

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

- slot-id)))

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

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

+ #'cl-smoke-free-lisp-object))

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

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

+ argument type)

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

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

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

+ (let ((type (smoke::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 (metaobject index)

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

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

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

- (last-pos (length arguments)))

+ (last-pos (length arguments))

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

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

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

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

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

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

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

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

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

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

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

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

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

+ (let ((vector (make-array (cl-smoke-string-list-size string-list)

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

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

- from-string-list qt-smoke-free-string-list)

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

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

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

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

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

- string-list #'qt-smoke-free-string-list)))

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

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

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

- (let* ((lisp-object (qt-smoke-lisp-object-value (smoke::pointer variant)))

+ (let* ((lisp-object (cl-smoke-lisp-object-value (smoke::pointer variant)))

-(asdf:operate 'asdf:load-op :qt)

-(asdf:operate 'asdf:test-op :qt)

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

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

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

* Support ASDF instead of Mudballs.

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

- ("event" (:needs "qt"))

- ("object" (:needs "qt" "signal-slot" "qstring" "event"))

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

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

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

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

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

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

-(mb:test :qt.tests)

+(defpackage qt-system

+ (:use :cl :asdf))

+

+(in-package qt-system)

+

+(asdf:defsystem :qt

+ :name :qt

+ :version (0 0 1)

+ :author "Tobias Rautenkranz"

+ :license "GPL with linking exception"

+ :description "Smoke Qt bindings."

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

+

+ :components [_$_]

+ ((:module "src"

+ :components

+ ((:file "package")

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

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

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

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

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

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

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

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

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

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

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

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

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

+ (:file "lisp-object" :depends-on ("qt" "lib"))

+ (:module "signal-slot"

+ :serial t

+ :depends-on ("lisp-object")

+ :components

+ ((:file "signal-slot")

+ (:file "translate" :depends-on ("signal-slot"))

+ (:file "signal" :depends-on ("translate"))

+ (:file "slot" :depends-on ("signal"))

+ (:file "connect" :depends-on ("slot"))))

+ (:file "string-list" :depends-on ("qt" "lib" "qstring"))

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

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

+

+(defmethod asdf:perform ((operation test-op) (c (eql (find-system :qt))))

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

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

- #-mudballs

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

-

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

+(asdf:operate 'asdf:test-op :qt)

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

* Install msg-handler also when starting from an image

-(eval-when (:load-toplevel)

+(eval-startup (:load-toplevel)

- (*qt-smoke* "qt_Smoke")

+ (*qt-smoke* "qt_Smoke")

-

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

* Convert C++ exceptions to a qFatal

+#include <exception>

+

+static void

+terminate()

+{

+ qFatal("caught an exception.");

+}

+

+ std::set_terminate(terminate);

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

* Cleanup msg-handler

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

-;; Smokegenerator

+

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

- (register-msg-handler))

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

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

* Better Lisp vector to QList<*> conversion.

-(defmacro define-qlist-wrapper (type-name &optional c-name)

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

- (loop for element in list do

+ (loop for element across list do

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

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

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

+ (every #'(lambda (element)

+ (typep element ',element-type))

+ list))

- list ;; FIXME allow sequence and define element type

+ ;; FIXME allow sequence

+ (and (vector ,element-type)

+ (satisfies ,(symbolicate list-type '-p)))

-(define-qlist-wrapper "QVariant")

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

-(define-qlist-wrapper "QByteArray")

+;; FIXME it would be nice to have QList<QVariant> as fallback for any

+;; list we can not convert otherwise. e.g.: '("a" 1)

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

+

+(define-qlist-wrapper ("QObject*" "QWidget*") qt:object "void")

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

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

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

-;;; ignored.

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

+ ;;; QMetaObject::invokeMethod(), but for signal-slot connection it is

+ ;;; ignored.

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

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

+(defun string-list-p (sequence)

+ (every #'stringp sequence))

+

- (vector string) coerce-string-list)

+ (and (vector string)

+ (satisfies string-list-p))

+ coerce-string-list)

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

* Update to the new smokegenerator.

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

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

+;; Smokegenerator

+(define-pointer-typedef "void(*)(QtMsgType,const char*)" foreign-pointer)

+(define-pointer-typedef "unsigned char*" foreign-pointer)

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

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

-

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

-(eval-startup ()

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

+(defvar *toplevel-objects* nil)

+

- (smoke::transfer-ownership-to parent (ensure-smoke-parent parent)))

+ (if (null-pointer-p (smoke:pointer (cxx:parent parent)))

+ (push parent *toplevel-objects*)

+ (smoke::transfer-ownership-to parent (ensure-smoke-parent parent))))

+(declaim (optimize (debug 3)))

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

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

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

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

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

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

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

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

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

- ;; [_$_]

- ;; RESOLUTION:

- ;; wait for KDE 4.4 -- the new smoke_generator should fix this.

- "data")))

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

+ "constData")))

+ (defmethod cxx:const-data ((array qt:byte-array))

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

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

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

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

- (prin1 (cxx:data object) stream))))

+ (when (smoke::const-p object)

+ (princ "CONST " stream))

+ (prin1 (cxx:const-data object) stream))))

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

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

- (value qt:+auto-connection+)

- (value type))

+ qt:+auto-connection+

+ type)

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

* Fix double space when printing a qt:object.

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

+ (print-unreadable-object (object stream :type t :identity t)

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

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

+ (prin1 (cxx:data object) stream))))

+

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

* qt:event upcasting cleanup

- ("object" (:needs "qt" "signal-slot" "qstring"))

+ ("event" (:needs "qt"))

+ ("object" (:needs "qt" "signal-slot" "qstring" "event"))

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

+

+(defun cast-event (event)

+ (enum-case (cxx:type event)

+ ((qt:event.+child-added+ qt:event.+child-removed+

+ qt:event.+child-polished+)

+ (setf (slot-value event 'smoke::pointer)

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

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

+ event)

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

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

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

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.

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

+ ("object" (:needs "qt" "signal-slot" "qstring"))

- (cerror "Delete the active application." "Active application not created by QT:WITH-APP.")

+ (cerror (format nil "Delete the active application ~A."

+ (qt:core-application.instance))

+ "Active application not created by QT:WITH-APP.")

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

+ * @return @c true on success and @c false otherwise

+/** Returns the most specific QMetaObject of the QObject instance @a object.

+ * Used to determine the actual class of an object. Smoke can not be used since it calls the

+ * metaObject() of the class the method was called for.

+ *

+ * @param object A QObject

+ *

+ * @return QMetaObject

+ */

+CL_SMOKE_QT_EXPORT void*

+qt_smoke_meta_object(void* object)

+{

+ Q_ASSERT(object);

+ static_cast<QObject*>(object)->metaObject();[_^I_][_$_]

+}

+

+

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

+ ;; To Lisp

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

+ `(defun ,(symbolicate 'from- type-name) (list-pointer)

- list))))

+ list-pointer))))

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

+ list-pointer index)

+ (smoke::make-smoke-type *smoke-module*

+ ,type-name)))))))

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

+ `(define-to-lisp-translation

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

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

+ ,(symbolicate 'from- type-name)

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

+ ;; From Lisp

- (smoke::make-cleanup-pointer

+ (make-cleanup-pointer

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

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

+;; QtMsgHandler is a typedef for a pointer.

+(define-pointer-typedef "QtMsgHandler" foreign-pointer)

+

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

+;; Smoke always calls the method of the class the object is assumed to

+;; be and not the most specific method like required for virtual

+;; methods. Thus we implement a virtual metaObject() method to

+;; determine the actual class. This is only needed for objects not

+;; constructed by Smoke, since otherwise we would know the most

+;; specific class.

+(defcfun qt-smoke-meta-object :pointer (object :pointer))

+(defun meta-object (object)

+ (make-instance 'qt:meta-object

+ :pointer (qt-smoke-meta-object (pointer object))))

+

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

- (not (null-pointer-p (smoke::pointer-call (smoke::make-smoke-method-from-name (find-class 'qt:object)

- "parent")

- (smoke::pointer 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.

+;; FIXME this might not be that smart.

+(eval-startup ()

+ (defparameter *destroyed-slot* (qt:make-slot

+ #'(lambda (object)

+ (foreign-funcall-pointer

+ (get-callback 'smoke::destructed)

+ () :pointer (smoke:pointer object))))))

+

+(defun ensure-smoke-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 for ~A." object))))

+ (assert (not (null-pointer-p (smoke:pointer parent)))

+ ()

+ "The object ~A has not parent." object)

+ (unless (smoke::has-pointer-p (smoke:pointer parent))

+ ;; Before we ADD-OBJECT PARENT it must know its real class to

+ ;; prevent a clash when the same pointer is returned by a

+ ;; function with a more specific type.

+ (change-class parent [_$_]

+ ;; Note: there can be classes that are not known

+ ;; to Smoke, like KDE's OxygenStyle that might

+ ;; be seen by the event-notify callback. But

+ ;; it's probably save to assume the user will

+ ;; never use those.

+ (let ((class-name (cxx:class-name (meta-object parent))))

+ (smoke::lispify class-name (ecase (char class-name 0)

+ (#\Q :qt)

+ (#\K :kde)))))

+ (smoke::add-object parent)

+ (qt:connect (qt:get-signal parent "destroyed(QObject*)")

+ *destroyed-slot* qt:+direct-connection+)

+ (tg:cancel-finalization parent)

+ (smoke::transfer-ownership-to parent (ensure-smoke-parent parent)))

+ parent))

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

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

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

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

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

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

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

- :class-name (name class)

+ :object-class class

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

+ (setf receiver (ensure-smoke-parent (cxx:child child-event))))

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

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

-

-(define-parse-method qstring ()

- (make-instance 'qstring))

-

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

- "data")))

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

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

+ "data")))

+ (defmethod cxx: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))))))

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

+(defun from-qstring (qstring)

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

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

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

- (declare (ignore param))

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

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

+ from-qstring qt-smoke-free-qstring)

- #'(lambda (pointer)

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

- nil))))

+ #'qt-smoke-free-qstring))

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

+ (if (typep signal-arg 'smoke::smoke-type)

+ (assert (smoke-type= signal-arg slot-arg))

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

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

+ :arg0 (signal-object sender)

+

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

+

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

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

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

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

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

+ :arg0 (qsender qt-signal)

- (if (smoke::has-pointer-p (smoke:pointer (qsender qt-signal)))

- (setf (cxx:parent slot) (qsender qt-signal))

- ;; when QT-SIGNAL is not a Smoke instance.

- (progn

- (unless (qt:property-p (qsender qt-signal) 'connected-slots)

- (setf (qt:property (qsender qt-signal) 'connected-slots)

- (qt:make-lisp-variant (list))))

- (setf (qt:property (qsender qt-signal) 'connected-slots)

- (qt:make-lisp-variant

- (cons slot

- (qt:property (qsender qt-signal) 'connected-slots))))))

- :initform (error "no function specified")

+ :initform (error "no slot function specified")

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

- (if (null cffi-type)

- (progn [_$_]

- pointer)

- (convert-from-foreign pointer

- cffi-type))))

+ (0 (if-let ((translation (gethash (name type) smoke::*to-lisp-translations*)))

+ ;; Do not free stack allocated stuff (e.g.: QString); that is the callers

+ ;; responisbility.

+ (funcall (car translation) pointer)

+ (error "Do not know how to convert the type ~A to Lisp." type)))

-(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 (qt-smoke-string-list-size string-list)

+ :initial-element ""

+ :element-type 'string)))

+ [_$_]

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

+ from-string-list qt-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 coerce-string-list (sequence)

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

+ (map nil

+ #'(lambda (string)

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

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

+ sequence)

+ (make-cleanup-pointer

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

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

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

- ;; Set the sender as the slots parent,

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

- ;;

- ;; FIXME: unset parent 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.

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

+ ;; 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 (smoke::has-pointer-p (smoke:pointer (qsender qt-signal)))

+ (setf (cxx:parent slot) (qsender qt-signal))

+ ;; when QT-SIGNAL is not a Smoke instance.

+ (progn

+ (unless (qt:property-p (qsender qt-signal) 'connected-slots)

+ (setf (qt:property (qsender qt-signal) 'connected-slots)

+ (qt:make-lisp-variant (list))))

+ (setf (qt:property (qsender qt-signal) 'connected-slots)

+ (qt:make-lisp-variant

+ (cons slot

+ (qt:property (qsender qt-signal) 'connected-slots))))))

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

* Remove unnecessary #'cxx:data calls.

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

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

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

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

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

* support packages for symbols as property names.

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

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

+ ("application" (:needs "qt" "properties"))

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

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

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

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

+ (let* ((argc (smoke:make-auto-pointer

+ (foreign-alloc :int :initial-element (length args))))

+ (argv (smoke:make-auto-pointer

+ (foreign-alloc :string :initial-contents args)))

+ (app (make-instance 'qt:application :args (list argc argv))))

+ ;; argc and argv must remain valid during the lifetime of APP.

+ (setf (qt:property app 'cmdline-args) [_$_]

+ (qt:make-lisp-variant (list argc argv)))

+ (tg:cancel-finalization app)

+ (values app t)))))

- (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 destructor; -> destructed callback is called,

- ;; (~QApplication() is virtual) which takes care of cleanup

- ;; on the Lisp side.

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

- (setf (slot-value (qt:app) 'pointer) (null-pointer))

- (makunbound '*app*)))

+(defun kill-app ()

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

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

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

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

+ ;; QApplication::allWidgets().

+ ;; [_$_]

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

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

+ (tg:cancel-finalization widget)))

+ (cxx:quit (qt:app))

+ (setf *widgets* nil)

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

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

+ ;; Lisp side.

+ (smoke::delete-pointer (smoke:pointer (qt:app)) (class-of (qt:app)))

+ (setf (slot-value (qt:app) 'pointer) (null-pointer))

+ (makunbound '*app*))

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

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

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

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

+;;; See: QCoreApplication::notifyInternal(QObject *receiver, QEvent

+;;; *event)

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

- ;; that have been constructed by Smoke.

+ ;; it was constructed by Smoke or not. Only take ownership of

+ ;; objects that have been constructed by Smoke.

+ ;; RESOLUTION:

+ ;; wait for KDE 4.4 -- the new smoke_generator should fix this.

-still active and not yet garbage collected painters."

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

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

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

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

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

-

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

+ (declare (type qt:object object)

+ (type (or string symbol) name))

+ (declare (type qt:object object)

+ (type (or string symbol) name))

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

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

+ (sort-symbols

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

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

+ (map 'list (compose #'lispify-property-name #'cxx:data)

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

-;;; e.g.

+;;; e.g.:

+;;; Use emacs 23 for better unicode support.

-

- ;; FIXME: unset parent on disconnect

- ;; this no not critical because the slot object

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

- ;; connect it to other signals.

+ ;;

+ ;; FIXME: unset parent 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.

- (apply #'emit (signal-object object) args))) [_$_]

- )

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

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

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

+ ;; For efficiency assume that SLOT is normalized and fallback to

+ ;; normalizing when not. (Just like Qt does.)

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

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

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

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

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

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

-;;; it is ignored.

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

+;;; QMetaObject::invokeMethod(), but for signal-slot connection it is

+;;; ignored.

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

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

+ ;; For efficiency assume that SIGNAL is normalized and fallback to

+ ;; normalizing when not. (Just like Qt does.)

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

- (setf last-pos pos))

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

+ (setf last-pos pos))

- ;; By value means that they are allocated by the C++ signal

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

- ;; frees the object when the slot returns.

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

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

- (error "FOO");;qmetatype.+voidstar+

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

- ;;FIXME free TYPES on error.

+ ;; FIXME free TYPES on error.

- (make-instance 'qt:variant :args (list value))

+ (make-instance 'qt:variant :arg0 value)

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

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

- (aref octets 1))))

+ (aref octets 1))))

- "Returns the lisp character represented by CHAR."

+ "Returns the Lisp character represented by CHAR."

-;; FIXME include in MAKE-VARIANT?

+;; FIXME include in MAKE-VARIANT? how??

-The variant contains the actual Lisp object

+The variant contains the actual Lisp object VALUE

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

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

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

+ (error "No smoke parent found for ~A." object))))

- (mem-aref (pointer stack)

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

- (mem-aref (pointer stack)

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

- [_$_]

+

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

* Fix nested #'qt:exec

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

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

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

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.

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

+lisp_object::data::data(unsigned int id)

-lisp_object::lisp_object(int id)

+lisp_object::lisp_object(unsigned int id)

-lisp_object::set_id(int id)

+lisp_object::set_id(unsigned int id)

-int

+unsigned int

-qt_smoke_lisp_object_set(const void* object)

+qt_smoke_lisp_object_is_set(const void* object)

-qt_smoke_make_lisp_object(int id)

+qt_smoke_make_lisp_object(unsigned int id)

- CL_SMOKE_QT_EXPORT int

+ CL_SMOKE_QT_EXPORT unsigned int

- qt_smoke_lisp_object_set(const void* object);

+ qt_smoke_lisp_object_is_set(const void* object);

- qt_smoke_make_lisp_object(int id);

+ qt_smoke_make_lisp_object(unsigned int id);

- typedef void (*destructor)(int id);

+ typedef void (*destructor)(unsigned int id);

- lisp_object(int id);

+ lisp_object(unsigned int id);

- inline int

+ inline unsigned int

- set_id(int id);

+ set_id(unsigned int id);

- data(int id);

+ data(unsigned int id);

- int id;

+ unsigned int id;

+ (declare (type (smoke::c-integer :unsigned-int) id))

- (incf id)))

-

+ (loop do

+ (setf id

+ (logand (1- (expt 2 (* 8 (foreign-type-size :unsigned-int) )))

+ (1+ id)))

+ while (nth-value 1 (gethash id *cxx-lisp-objects*)))

+ id))

+ [_$_]

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

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

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

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

- (id :int))

+ (id :unsigned-int))

- ((id :int))

+ ((id :unsigned-int))

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

-(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:eval-startup (:load-toplevel :compile-toplevel :execute)

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

+ (activate qsignal (id qsignal) (argument-types qsignal) arguments))

+

+(defun activate (object id types arguments)

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

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

+ do

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

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

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

-(declaim (optimize (debug 3)))

-

-

- ;; Call the destructer; -> destructed callback is called,

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

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

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

-APP.

+QT:APP.

+ (assert (null options)

+ (options)

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

- ,@body))

+ ,@body))

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

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

+ (assert (null options)

+ (options)

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

- ,@body))

+ ,@body))

-

-(defun qt:exec (&rest widgets)

- "Executes APP."

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

- (when qt:*exec-p*

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

- (cxx:quit (qt:app))

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

- :report-function

- #'(lambda (stream)

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

- :test-function

- #'(lambda (condition)

- (declare (ignore condition))

- (and (qt:app-p)

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

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

+(defun qt:exec ()

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

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

+instance."

+ (if qt:*exec-p*

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

+ (cxx:quit (qt:app))

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

+ :report-function

+ #'(lambda (stream)

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

+ :test-function

+ #'(lambda (condition)

+ (declare (ignore condition))

+ (and (qt:app-p)

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

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

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

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

-When beeing received as an argument by a slot,

+When being received as an argument by a slot,

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

- ',list-type))

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

+ ',list-type))

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

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

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

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

- type '-size)

- list))))

- (dotimes (index (length vector) vector)

- (setf (aref vector index)

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

- ;; -> change this? [_$_]

- (smoke::object-to-lisp

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

- type '-at)

- list index)

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

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

- `(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-from-lisp-translation (,(format nil "const QList<~A>&" type-name)

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

+ list ;; FIXME allow sequence and define element type

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

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

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

+ ;; We receive child removed events for any QObject, whether

+ ;; it was constructed by Smoke or not. Only take ownership of objects

-;; Relases ownership

+;; Releases ownership

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

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

- during the evaulation of BODY.

+ during the evaluation of BODY.

-Makes sure the painter ends after BODY; thus prevening problems with [_$_]

+Makes sure the painter ends after BODY; thus preventing problems with [_$_]

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

+;;; make sure, that you have configured slime correctly.

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

+ (values ;; Discharge second return value (length of string)

- ;; this no not critical beause the slot object

+ ;; this no not critical because the slot object

-(declaim (optimize (debug 3)))

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

+ (declare (ignore id))

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

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

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

+ (declare (ignore event))

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

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

-(defvar *exec-p* t

+(defvar qt:*exec-p* t

- (when *exec-p*

+ (when qt:*exec-p*

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

+ (smoke::make-smoke-type *smoke-module* ,type-name)))))))

- (not (null-pointer-p (smoke::pointer-call (smoke::make-smoke-method (find-class 'qt:object)

+ (not (null-pointer-p (smoke::pointer-call (smoke::make-smoke-method-from-name (find-class 'qt:object)

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

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

+ (declare (optimize (speed 3)))

+ (declare (optimize (speed 3)))

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

- *qt-smoke*

- "QObject")

- "parent"))

+ (smoke::make-smoke-method-from-name (find-class 'qt:object) "parent"))

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

- *qt-smoke*

- "QObject")

- "deleteLater")))

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

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

- (print-object object stream)))

+ (smoke::make-smoke-method-from-name (find-class 'qt:object) "deleteLater")))

- "Delete the qt:object OBJECT,

+ "Delete the qt:object OBJECT,

- (let ((pointer (pointer object))

- (class (class-of object))

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

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

- #'(lambda ()

- (handler-case [_$_]

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

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

- (error (make-condition 'wrapper-gc

- :class-name (name class)

- :pointer pointer)))

- (error (condition)

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

- (name class) pointer))))

- #'(lambda ()

- (handler-case [_$_]

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

+ (let ((pointer (pointer object))

+ (class (class-of object))

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

+ (declare (function next))

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

+ #'(lambda ()

+ (declare (optimize (speed 3)))

+ (handler-case [_$_]

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

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

+ (error (make-condition 'wrapper-gc

+ :class-name (name class)

+ :pointer pointer)))

+ (error (condition)

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

+ (name class) pointer))))

+ #'(lambda ()

+ (declare (optimize (speed 3)))

+ (handler-case [_$_]

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

- (error (condition)

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

- (name class) pointer)))))))

+ (error (condition)

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

+ (name class) pointer)))))))

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

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

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

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

+ :argument-types (argument-types (signal-object sender))

- (types (arguments sender)))

+ (types (argument-types (signal-object sender))))

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

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

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

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

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

* The CLISP null pointer is NIL

- &key pointer &allow-other-keys)

+ &key (pointer nil pointer-p) &allow-other-keys)

- (when (and (null pointer)

+ (when (and (not pointer-p)

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

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

- ())

+ ((package :initarg :package)))

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

+ ("libqt-smoke-extra" sysdef.cmake:cmake-library (:package :cl-smoke.qt-impl))

-(in-package :qt)

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

-(defun app ()

+(defun qt:app ()

- (assert (app-p)

+ (assert (qt:app-p)

-(defun app-p ()

+(defun qt:app-p ()

- (application 'application)

+ (application 'qt:application)

- (if (app-p)

+ (if (qt:app-p)

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

+ (assert (typep (qt:app) (find-class application))

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

- (values (app) nil))

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

+ (values (qt:app) nil))

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

- ()

- "Active QCoreApplication not created by QT:WITH-APP.")

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

- (when (typep (app) 'application)

- (application.close-all-windows)

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

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

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

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

- (cxx:quit (app))

+ (cxx:quit (qt:app))

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

- (setf (slot-value (app) 'pointer) (null-pointer))

+ (smoke::delete-pointer (smoke::pointer (qt:app)) (class-of (qt:app)))

+ (setf (slot-value (qt:app) 'pointer) (null-pointer))

-(defmacro with-app (&body body)

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

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

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

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

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

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

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

-(defun exec (&rest widgets)

+(defun qt:exec (&rest widgets)

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

- (cxx:quit (app))

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

+ (cxx:quit (qt:app))

- (and (app-p)

+ (and (qt:app-p)

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

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

-(in-package :qt)

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

-(defun tr (message &optional context)

+(defun qt:tr (message &optional context)

-(defmacro with-translator ((base-name &rest paths) &body body)

+(defmacro qt:with-translator ((base-name &rest paths) &body body)

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

+ `(let ((,translator (make-instance 'qt:translator)))

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

+(defmacro qt:with-libqt-translator (&body body)

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

+ `(let ((,translator (make-instance 'qt:translator)))

-(defun search-file (name &rest paths)

+(defun qt:search-file (name &rest paths)

-(in-package :qt)

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

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

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

-(in-package :qt)

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

-(in-package :qt)

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

-(in-package :qt)

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

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

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

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

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

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

- (doc-type t))

- (if (and (subtypep class (find-class 'object))

+(defmethod documentation :around ((class smoke::smoke-standard-class)

+ (doc-type (eql 't)))

+ (if (and (subtypep class (find-class 'qt:object))

- (call-next-method) (sort (class-properties class) #'string<=)

+ (call-next-method) (sort (qt:class-direct-properties class) #'string<=)

-(defmethod print-object ((object object) stream)

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

-(defun meta-object-signals (meta-object)

+(defun meta-object-signals (meta-object &key all)

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

+ (meta-object-methods meta-object (not all)))))

-(defun class-signals (class)

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

+(defun class-signals (class &key all)

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

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

+(defun meta-object-slots (meta-object &key all)

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

+ (meta-object-methods meta-object (not all)))))

-(defun class-slots (class)

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

+(defun class-slots (class &key all)

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

+(defun parent-p (object)

+ (not (null-pointer-p (smoke::pointer-call (smoke::make-smoke-method (find-class 'qt:object)

+ "parent")

+ (smoke::pointer object)))))

-(defmethod initialize-instance :after ((object 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.

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

+

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

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

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

- (smoke::transfer-ownership-to object (cxx:parent object))))

+ (parent-p object))

+ (smoke::transfer-ownership-to object

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

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

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

+

- (event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1))))

+ (event (make-instance 'qt:event

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

- (event.+child-added+

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

+ (qt:event.+child-added+

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

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

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

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

- (assert receiver)

+ (unless receiver

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

- (event.+child-removed+

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

+ (qt:event.+child-removed+

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

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

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

-(in-package :qt)

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

-(in-package :qt)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-(defpackage :qt

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

+(defpackage :cl-smoke.qt-impl

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

+

+(defpackage :cl-smoke.qt

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

+ (:nicknames :qt)

+ #:make-char

+ #:from-char

+ [_$_]

+ #:disconnect

+ #:disconnect-all

-(in-package :qt)

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

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

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

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

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

-(in-package :qt)

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

-(defun property (object name)

+(defun qt:property (object name)

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

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

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

+(defun (setf qt:property) (new-value object name)

-(defun remove-property (object name)

+(defun qt:remove-property (object name)

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

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

-(defun property-p (object name)

+(defun qt:property-p (object name)

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

+ (qt:variant-boundp (cxx:property object (property-name name))))

-(defgeneric class-properties (class)

+(defgeneric qt:class-properties (class)

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

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

-(defgeneric class-direct-properties (class)

+(defgeneric qt:class-direct-properties (class)

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

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

-(defun properties (object)

+(defun qt:properties (object)

-(in-package :qt)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-(in-package :qt)

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

-(define-smoke-module libsmokeqt

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

-(in-package :qt)

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

-(defgeneric connect (qsignal slot &optional type)

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

-(defgeneric disconnect (qsignal slot)

+(defgeneric qt:disconnect (qsignal slot)

-(defgeneric disconnect-all (qsignal)

+(defgeneric qt:disconnect-all (qsignal)

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

+(defmethod qt:connect ((qsignal qsignal) (qslot qslot) &optional type)

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

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

-(defgeneric get-slot (receiver name)

+(defgeneric qt:get-slot (receiver name)

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

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

- args)))))

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

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

+ args)))))

-(define-compiler-macro get-slot (&whole form receiver name)

+(define-compiler-macro qt:get-slot (&whole form receiver name)

- (let ((normalized-name (cxx:data (meta-object.normalized-signature name))))

+ (let ((normalized-name (cxx:data

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

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

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

-(defun get-signal (sender name)

+(defun qt:get-signal (sender name)

-(define-compiler-macro get-signal (&whole form sender name)

+(define-compiler-macro qt:get-signal (&whole form sender name)

- (let ((normalized-name (cxx:data (meta-object.normalized-signature name))))

+ (let ((normalized-name (cxx:data [_$_]

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

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

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

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

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

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

- (or type +auto-connection+))

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

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

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

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

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

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

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

+(defmethod qt:disconnect-all ((sender qt:object))

+ (unless (qt:object.disconnect sender 0 0 0)

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

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

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

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

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

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

- (meta-object.connect sender signal-id

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

- (value +auto-connection+)

+ (value qt:+auto-connection+)

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

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

-(in-package :qt)

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

-(defun qmethod (name)

+(defun qt:qmethod (name)

-(defun qslot (name)

+(defun qt:qslot (name)

-(defun qsignal (name)

+(defun qt:qsignal (name)

-(in-package :qt)

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

-(defclass signal-object (object)

+(defclass signal-object (qt:object)

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

+(defun qt:make-signal (&rest argument-types)

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

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

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

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

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

+(defmethod qt:disconnect-all ((qsignal qsignal))

-(in-package :qt)

-(declaim (optimize (debug 3)))

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

-(defclass qslot (object)

+(defclass qslot (qt:object)

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

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

-(defmacro sender ()

+(defmacro qt:sender ()

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

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

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

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

-(in-package :qt)

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

-(in-package :qt)

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

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

+ (translate-to-foreign list (make-instance 'string-list))

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

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

-(in-package :qt)

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

-(defmacro do-delayed-initialize (&body body)

+(defmacro qt:do-delayed-initialize (&body body)

-(in-package :qt)

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

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

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

- (handler-case (from-variant variant)

+ (handler-case (qt:from-variant variant)

-(defun make-variant (&optional (value nil value-p))

+(defun qt:make-variant (&optional (value nil value-p))

- (make-instance 'variant :args (list value))

- (make-instance 'variant)))

+ (make-instance 'qt:variant :args (list value))

+ (make-instance 'qt:variant)))

-(defun make-char (character)

+(defun qt:make-char (character)

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

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

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

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

-(defun from-char (char)

+(defun qt:from-char (char)

-(defmethod print-object ((char char) stream)

+(defmethod print-object ((char qt:char) stream)

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

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

-(defun make-lisp-variant (value)

+(defun qt:make-lisp-variant (value)

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

- object))

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

+ object))

-(defun variant-boundp (variant)

+(defun qt:variant-boundp (variant)

- `(,(value (symbol-value (alexandria:symbolicate 'variant.+ type '+)))

+ `(,(value (symbol-value [_$_]

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

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

-(defun from-variant (variant)

+(defun qt:from-variant (variant)

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

+ (#.(value qt:variant.+invalid+)

-(defmethod value ((variant variant))

+(defmethod qt:value ((variant qt:variant))

- (from-variant variant))

+ (qt:from-variant variant))

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

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

+(defmethod (setf qt:value) (new-value (variant qt:variant))

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

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

* Transfer ownerhip only for smoke classes.

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

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

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

+ (smoke::transfer-ownership-to object (cxx:parent object))))

-

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

+ (error (make-condition 'wrapper-gc

+ :class-name (name class)

- (cerror 'continue "Finalizer for object with a parent called."))

+ (cerror "Ignore" "Finalizer for object with a parent called."))

- (let ((event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1))))

+ (let ((receiver (smoke::get-object (cffi:mem-aref data :pointer 0)))

+ (event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1))))

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

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

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

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

+ (assert receiver)

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

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

+ (assert receiver)

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

+;; undo-stack

+

+

+#|

+;; 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 grid-layout) (item layout-item)

+ row column)

+ item)

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

+ row column row-span)

+ item)

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

+ row column row-span colum-span)

+ item)

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

+ row column row-span colum-span aligment)

+ item)

+

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

+ item)

+

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

+

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

+ type creator)

+ creator)

+

+

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

+ item)

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

+ item)

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

+ column item)

+ item)

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

+ row item)

+ item)

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

+ row column item)

+ item)

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

+ row item)

+ item)

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

+ item)

+ item)

+

+

+;; Allocates return value

+;; QLineEdit::createStandardContextMenu()

+

+;; parent

+;; QListwidgetitem

+

+

+;; Relases ownership

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

+;; etc

-

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

* more qt:variant conversions

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

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

+ [_$_]

+ ,@(loop for type in types collect

+ (if (symbolp type)

+ `(,(value (symbol-value (alexandria:symbolicate 'variant.+ type '+)))

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

+ type))))

+

- (ecase (cxx:user-type variant)

+ (variant-conversions (variant)

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

- (cxx:to-string variant))

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

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

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

- (cxx:to-uint variant))

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

- (cxx:to-int variant))

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

- (cxx:to-double variant))

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

- (cxx:to-char variant))

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

- (cxx:to-bool variant))

+ 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

-

+ [_$_]

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

* get-slot for function with this argument

- #:connect-signal

- #:connect-function

-(defun get-slot (receiver name)

- "Returns the slot of RECEIVER with NAME."

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

+(defgeneric get-slot (receiver name)

+ (:documentation "Returns the slot of RECEIVER with NAME.")

+ (:method (receiver name)

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

+ (:method (receiver (function function))

+ "Returns a slot for RECEIVER that calls function

+with RECEIVER as the first argument."

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

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

+ args)))))

+ (cxx:set-parent slot receiver)

+ slot)))

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

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

- [_$_]

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

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

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

- (setf (argument-types qsignal)

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

- slot-id)))

- (assert (>= slot-id 0)

- ()

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

- slot (class-name receiver))

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

- receiver slot-id

- type

- ;; QMetaObject::connect is responsible [_$_]

- ;; for freeing the types array.

- (types (method-arguments-type

- (cxx:meta-object receiver)

- slot-id)))

- (cerror "Ignore"

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

- qsignal slot receiver))))

-

-(defun disconnect-signal (qsignal receiver slot)

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

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

- (cxx:data

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

- (assert (>= slot-id 0)

- ()

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

- slot (class-name receiver))

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

- receiver slot-id)

- (cerror "Ignore" [_$_]

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

- qsignal slot receiver))))

-(defparameter *sender* nil)

+(defparameter *sender* nil "The sender of the signal.")

+(defparameter *this* nil "The slot that is invoked.")

- (0 (let ((*sender* (cxx:sender slot)))

+ (0 (let ((*sender* (cxx:sender slot))

+ (*this* slot))

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

- "Connects FUNCTION to the SIGNAL of SENDER.

-The return value of FUNCTION is ignored."

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

- (slot (make-instance 'qslot

- :args (list sender)

- :slot-function function

- :argument-types (method-arguments-type

- (cxx:meta-object sender)

- signal-id))))

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

- slot (id slot)

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

- (if ret

- (cxx:connect-notify sender signal)

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

- signal sender function)))))

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

* Normalize signal and slot names at compile time.

- :reader name)))

+ :reader name)))

+(define-compiler-macro get-slot (&whole form receiver name)

+ "Normalize the slot name."

+ (if (stringp name)

+ (let ((normalized-name (cxx:data (meta-object.normalized-signature name))))

+ (if (string= name normalized-name) ;; Avoid loop

+ form

+ `(get-slot ,receiver ,normalized-name)))

+ form))

+

- [_$_]

+

+(define-compiler-macro get-signal (&whole form sender name)

+ "Normalize the signal name."

+ (if (stringp name)

+ (let ((normalized-name (cxx:data (meta-object.normalized-signature name))))

+ (if (string= name normalized-name) ;; Avoid loop

+ form

+ `(get-signal ,sender ,normalized-name)))

+ form))

+ [_$_]

+ ;; For efficency assume that SLOT is normalized and fallback

+ ;; to normalzing when not. (Just like Qt does.)

- (cxx:data (meta-object.normalized-signature slot)))))

+ slot)))

+ (when (< id 0)

+ (setf id (cxx:index-of-slot (cxx:meta-object receiver)

+ (cxx:data (meta-object.normalized-signature slot)))))

+ ;; For efficency assume that SIGNAL is normalized and fallback

+ ;; to normalzing when not. (Just like Qt does.)

- (cxx:data (meta-object.normalized-signature signal)))))

+ signal)))

+ (when (< id 0)

+ (setf id (cxx:index-of-signal (cxx:meta-object sender)

+ (cxx:data (meta-object.normalized-signature signal)))))

Thu Jun 4 00:02:12 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix QT:APPLICATION cleanup in QT:WITH-APP and add restart to slot invocation.

- ;(assert (null-pointer-p (smoke::pointer (core-application.instance))))

+ (assert (null-pointer-p (smoke::pointer (core-application.instance)))

+ ()

+ "Active QCoreApplication not created by QT:WITH-APP.")

- (values (make-instance 'qt:application :args (list argc argv)) t))))

+ (let ((app (make-instance 'qt:application :args (list argc argv))))

+ (tg:cancel-finalization app)

+ (values app t)))))

+ (when (typep (app) 'application)

+ (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 (application.all-widgets) do

+ (trivial-garbage:cancel-finalization widget)))

- (when (typep (app) (find-class 'qt:application))

- (application.close-all-windows))

- (trivial-garbage:cancel-finalization (app))

- (smoke::remove-object (smoke::pointer (app)))

- ;; FIXME leak memory or memory fault!

- ;(smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))

- (cxx:delete-later (app))

+ ;; Call the destructer; -> destructed callback is called,

+ ;; (~QApplication() is virtual) which takes care of cleanup

+ ;; on the Lisp side.

+ (smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))

- (application.close-all-windows)

- (find-restart 'continue))))

+ (and (app-p)

+ (find-restart 'continue)))))

- ;;FIXME smoke does not support casting operators => can not

- ;; return a useful value with operator[]."

- ;;(cxx:operator[] object index))

+ ;; 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;

+ ;; [_$_]

- (case id

+ (ccase id

- (apply (slot-function slot)

- (arguments-to-lisp arguments (arguments slot))))))

+ (with-simple-restart

+ (continue "Skip the function ~A of slot ~A."

+ (slot-function slot) slot)

+ (apply (slot-function slot)

+ (arguments-to-lisp arguments (arguments slot)))))))

Mon Jun 1 00:39:13 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<QWidget*>

- (smoke::add-type ,(format nil "const QList<~A>&" type-name)

- ',list-type)

- (smoke::add-type ,(format nil "QList<~A>" type-name) ',list-type))

- (defmethod translate-from-foreign (list (type ,list-type))

+ ,@(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))

- (smoke::make-smoke-type *qt-smoke* ,type-name))))))

+ (smoke::make-smoke-type *qt-smoke* ,type-name)))))))

- (define-from-lisp-translation (,(format nil "const QList<~A>&" type-name)

+ ,@(loop for type-name in (ensure-list type-name) collect

+ `(define-from-lisp-translation (,(format nil "const QList<~A>&" type-name)

- ,(symbolicate 'coerce- list-type)))))

+ ,(symbolicate 'coerce- list-type))))))

-(define-qlist-wrapper "QObject*" "void")

+(define-qlist-wrapper ("QObject*" "QWidget*") "void")

Mon Jun 1 00:22:22 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<QObject*>

-(defmacro define-qlist-wrapper (type-name)

- (let* ((type (string-upcase type-name))

- (list-type (symbolicate 'qlist- type)))

+(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)))

- (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_size") :int

+ (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_size") :int

- (defcfun ,(concatenate 'string "qt_smoke_free_list_" type-name) :void

+ (defcfun ,(concatenate 'string "qt_smoke_free_list_" c-name) :void

- (defcfun ,(concatenate 'string "qt_smoke_make_list_" type-name) :pointer

+ (defcfun ,(concatenate 'string "qt_smoke_make_list_" c-name) :pointer

- (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_at") :pointer

+ (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_at") :pointer

- (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_append") :pointer

+ (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_append") :pointer

- list ;; FIXME allow seqence and define element type

+ list ;; FIXME allow seqence and define element type

-;(define-qlist-wrapper "void")

+(define-qlist-wrapper "QObject*" "void")

Sun May 31 23:59:55 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* cxx:push undo-stack takes ownership

+ ("ownership" (:needs "qt"))

+(in-package :qt)

+

+(define-takes-ownership cxx:push ((undo-stack undo-stack) undo-command)

+ undo-command)

Sun May 31 19:33:32 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Rework QObject parent ownership transfer

- (format stream "Return from the application event loop."))))

+ (format stream "Return from the application event loop."))

+ :test-function

+ #'(lambda (condition)

+ (declare (ignore condition))

+ (find-restart 'continue))))

-(declaim (optimize (debug 3)))

-(defvar *cxx-lisp-objects* (make-hash-table)

+(defvar *cxx-lisp-objects* (smoke::make-synchronized-hash-table)

-(defvar *cxx-lisp-object-metatype*)

+(defvar *cxx-lisp-object-metatype* "Metatype ID of the C++ lisp_object.")

-(declaim (optimize (debug 3)))

- (defmethod cxx:static-meta-object ((class smoke::smoke-wrapper-class))

+ (defmethod cxx:static-meta-object ((class cxx:class))

-(defmethod documentation :around ((class smoke::smoke-standard-class)

+(defmethod documentation :around ((class cxx:class)

- (not (subtypep class (find-class 'smoke::smoke-wrapper-class))))

+ (not (subtypep class (find-class 'cxx:class))))

-(defvar *children* (make-hash-table)

- "A list of custom subclasses of QObject which have a parent

-and therefor must not be garbage collected.")

-

-; (typep (class-of object) 'smoke::smoke-wrapper-class)

+; (typep (class-of object) 'cxx:class)

- (setf (gethash (smoke::pointer object) *children*) object)))

+ (smoke::disown-object object)))

- (format stream "The object ~A ~A of type smoke-wrapper-class

+ (format stream "The object ~A ~A of type cxx:class

- (defmethod smoke::make-finalize ((object object))

+(defun print-object-to-string (object)

+ (with-output-to-string (stream)

+ (print-object object stream)))

+

+(defmethod smoke::make-finalize ((object object))

- (name (class-name (class-of object)))

+ (class (class-of object))

- (if (typep (class-of object) 'smoke::smoke-wrapper-class)

+ (if (typep (class-of object) 'cxx:class)

- (condition (condition)

- (format *debug-io* "error: wrap finalize ~A ~A~%" name

- condition))))

+ (error (condition)

+ (smoke::report-finalize-error condition "qt:object wrap"

+ (name class) pointer))))

- (progn

- (when (null-pointer-p (smoke::pointer-call *get-parent* pointer))

- (funcall next)))

- (condition (condition)

- (format *debug-io* "error: qfinalize ~A ~A ~A~%" name

- pointer

- condition))))))

- ;(smoke::pointer-call delete-later pointer)))))))

- )

+ (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))

+ (funcall next)

+ (cerror 'continue "Finalizer for object with a parent called."))

+ (error (condition)

+ (smoke::report-finalize-error condition "qt:object"

+ (name class) pointer)))))))

- (let ((event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1)

- :owned-p nil)))

+ (let ((event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1))))

- (smoke::upcast event (find-class 'child-event))

- :owned-p nil))

- (child (smoke::get-object

- (smoke::pointer (cxx:child child-event)))))

-; (when (and child

-; (typep (class-of child)

-; 'smoke::smoke-wrapper-class))

- (when child

- (setf (gethash (smoke::pointer child) *children*) child))))

+ (smoke::upcast event (find-class 'child-event)))))

+ (smoke::disown-object (cxx:child child-event))))

- (find-class 'child-event))

- :owned-p nil)))

- (remhash (smoke::pointer (cxx:child child-event)) *children*)))))

+ (find-class 'child-event)))))

+ ;; We receive child removed events for any QObject, wherter

+ ;; it was construted by Smoke or not. Only take ownership of objects

+ ;; that have been constructed by Smoke.

+ (when (smoke::has-pointer-p (smoke::pointer (cxx:child child-event)))

+ (smoke::take-ownership (cxx:child child-event)))))))

+ #:remove-property

+

+(defun remove-property (object name)

+ "Removes the property NAME from OBJECT."

+ (setf (property object name) (qt:make-variant)))

+

- smoke::smoke-wrapper-class)

+ cxx:class)

- (:metaclass smoke::smoke-wrapper-class)

+ (:metaclass cxx:class)

Sat May 30 14:16:53 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* soversion for wrapper

+set_target_properties(qt-smoke-extra [_$_]

+ PROPERTIES

+ SOVERSION "0.0"

+ VERSION "0.0.1")

Thu May 28 16:13:57 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* ASDF

+

+ #-mudballs

+ (define-foreign-library libqt-smoke-extra

+ (:unix "libqt-smoke-extra.so")

+ (t (:default "libqt-smoke-extra")))

+

Wed May 27 19:18:41 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<QByteArray> and QList<QVariant> conversion & use cxx:operator== and qt:operator== in cxx:=

+ ("list" (:needs "qt"))

- (:needs :smoke :sysdef.cmake :cffi))

+ (:needs :smoke :sysdef.cmake :cffi :alexandria))

+

-qt_smoke_list_ ## NAME ## size(const void* list) \

+qt_smoke_list_ ## NAME ## _size(const void* list) \

-qt_smoke_list_ ## NAME ## _append(void* list, void* data, int length) \

+qt_smoke_list_ ## NAME ## _append(void* list, void* data) \

- return &qlist->at(index); \

+ return new TYPE(qlist->at(index)); \

-qt_smoke_list_ ## NAME ## _append(void* list, void* data, int length) \

+qt_smoke_list_ ## NAME ## _append(void* list, void* data) \

+(in-package :qt)

+

+(defmacro define-qlist-wrapper (type-name)

+ (let* ((type (string-upcase type-name))

+ (list-type (symbolicate 'qlist- type)))

+ `(progn

+ (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_size") :int

+ "Returns the size of LIST."

+ (list :pointer))

+ (defcfun ,(concatenate 'string "qt_smoke_free_list_" type-name) :void

+ "Frees LIST."

+ (list :pointer))

+ (defcfun ,(concatenate 'string "qt_smoke_make_list_" type-name) :pointer

+ "Makes a list.")

+ (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_at") :pointer

+ "Returns the a newly constructed copy of the element at position AT of LIST."

+ (list :pointer)

+ (index :int))

+ (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_append") :pointer

+ "Appends NEW-ELEMENT to LIST."

+ (list :pointer)

+ (new-element :pointer))

+ (define-foreign-type ,list-type ()

+ ()

+ (:actual-type :pointer))

+ (define-parse-method ,list-type ()

+ (make-instance ',list-type))

+ (eval-when (:load-toplevel :execute)

+ (smoke::add-type ,(format nil "const QList<~A>&" type-name)

+ ',list-type)

+ (smoke::add-type ,(format nil "QList<~A>" type-name) ',list-type))

+ (defmethod translate-from-foreign (list (type ,list-type))

+ (let ((vector (make-array (,(symbolicate 'qt-smoke-list-

+ type '-size)

+ list))))

+ (dotimes (index (length vector) vector)

+ (setf (aref vector index)

+ ;; FIXME the retuned object is not wrapped by Smoke

+ ;; -> change this? [_$_]

+ (smoke::object-to-lisp

+ (,(symbolicate 'qt-smoke-list-

+ type '-at)

+ list index)

+ (smoke::make-smoke-type *qt-smoke* ,type-name))))))

+ (defmethod free-translated-object (pointer (type ,list-type) param)

+ (declare (ignore param))

+ (,(symbolicate 'qt-smoke-free-list- type)

+ pointer))

+ (defun ,(symbolicate 'coerce- list-type) (list)

+ (let ((qlist (,(symbolicate 'qt-smoke-make-list- type))))

+ (loop for element in list do

+ (,(symbolicate 'qt-smoke-list- type '-append)

+ qlist (pointer (make-instance ',type :args (list element)))))

+ (smoke::make-cleanup-pointer

+ qlist

+ (function ,(symbolicate 'qt-smoke-free-list- type)))))

+ (define-from-lisp-translation (,(format nil "const QList<~A>&" type-name)

+ ,(format nil "QLIst<~A>" type-name))

+ list ;; FIXME allow seqence and define element type

+ ,(symbolicate 'coerce- list-type)))))

+

+(define-qlist-wrapper "QVariant")

+;(define-qlist-wrapper "void")

+(define-qlist-wrapper "QByteArray")

- (qt:operator== object 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))))

- (:use :cl :smoke :cffi :bordeaux-threads :cxx-support)

+ (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria)

+(defun dynamic-properties (object)

+ (map 'list (compose #'smoke::lispify #'cxx:data)

+ (cxx:dynamic-property-names object)))

+

- (warn "FIXME: dynamicPropertyNames not implemented")

- (meta-object-properties (cxx:meta-object object)))

+ (nconc (dynamic-properties object)

+ (meta-object-properties (cxx:meta-object object))))

-(defmethod translate-to-foreign (string (type qstring))

- (with-foreign-string ((data length) string :null-terminated-p nil)

- (qt-smoke-string-to-qstring data length)))

-

- (translate-to-foreign string (make-instance 'qt::qstring))

+ (with-foreign-string ((data length) string :null-terminated-p nil)

+ (qt-smoke-string-to-qstring data length))

- (if (null-pointer-p (pointer variant))

+ (if (or (not (slot-boundp variant 'pointer))

+ (null-pointer-p (pointer variant)))

Wed May 27 14:26:25 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* cleanup

-(defmethod smoke::push-lisp-object (stack object class)

- (let ((cxx-object (make-cxx-lisp-object object)))

- (smoke::push-cleanup stack

-

- #'(lambda ()

- (qt-smoke-free-lisp-object cxx-object)))

- (smoke::push-stack2 stack

- cxx-object

- 0)))

-

-(defun method-argument-count (metaobject index)

- "Returns the number of arguments for the method INDEX of METAOBJECT."

- (let ((signature (cxx:signature (cxx:method metaobject index))))

- (setf signature (subseq signature (1+ (position #\( signature))

- (position #\) signature :from-end t)))

- (if (= 0 (length signature))

- 0

- (1+ (count #\, signature)))))

-

-(defun method-argument-count (metaobject index)

- "Returns the number of arguments the method INDEX of METAOBJECT."

- (let ((signature (cxx:signature (cxx:method metaobject index))))

- (setf signature (subseq signature (1+ (position #\( signature))

- (position #\) signature :from-end t)))

- (if (= 0 (length signature))

- 0

- (1+ (count #\, signature)))))

-

Tue May 26 11:57:44 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Use argument conversion/promotion when emiting signals

-(define-from-lisp-translation "const QString&" string

+(define-from-lisp-translation ("const QString&" "QString") string

+

+(defun make-lisp-object (object)

+ (smoke::make-cleanup-pointer (make-cxx-lisp-object object)

+ #'qt-smoke-free-lisp-object))

+(defun convert-arguments (arguments types)

+ "Returns a list of ARGUMENTS converted to TYPES."

+ (mapcar #'(lambda (argument type)

+ (if (typep type 'smoke::smoke-type)

+ (smoke::convert-argument argument type)

+ (progn (assert (typep argument type)

+ ()

+ "The argument ~S is not of type ~S.")

+ (make-lisp-object argument))))

+ arguments types))

+ [_$_]

- (smoke::with-stack (stack arguments

- (argument-types qsignal))

- (cffi:with-foreign-object (args :pointer (1+ (length arguments)))

- (loop for i from 1 to (smoke::size stack)

- for type in (argument-types qsignal)

- do

- (setf (mem-aref args :pointer i)

- (if (or (not (typep type (find-class 'smoke::smoke-type)))

- (= 0 (smoke::type-id type))

- (= 13 (smoke::type-id type)))

- (foreign-slot-value

- (mem-aref (pointer stack)

- 'smoke::smoke-stack-item

- i)

- 'smoke::smoke-stack-item 'smoke::voidp)

- (foreign-slot-pointer

- (mem-aref (pointer stack)

- 'smoke::smoke-stack-item

- i)

- 'smoke::smoke-stack-item 'smoke::voidp))))

- (setf (mem-aref args :pointer 0)

- (null-pointer))

- (meta-object.activate qsignal (cxx:meta-object qsignal)

- (id qsignal)

- args))))

+ (let ((types (argument-types qsignal)))

+ (smoke::with-stack (stack (convert-arguments arguments types)

+ types)

+ (cffi:with-foreign-object (args :pointer (1+ (length arguments)))

+ (loop for i from 1 to (smoke::size stack)

+ for type in (argument-types qsignal)

+ do

+ (setf (mem-aref args :pointer i)

+ (if (or (not (typep type (find-class 'smoke::smoke-type)))

+ (= 0 (smoke::type-id type))

+ (= 13 (smoke::type-id type)))

+ (foreign-slot-value

+ (mem-aref (pointer stack)

+ 'smoke::smoke-stack-item

+ i)

+ 'smoke::smoke-stack-item 'smoke::voidp)

+ (foreign-slot-pointer

+ (mem-aref (pointer stack)

+ 'smoke::smoke-stack-item

+ i)

+ 'smoke::smoke-stack-item 'smoke::voidp))))

+ (setf (mem-aref args :pointer 0)

+ (null-pointer))

+ (meta-object.activate qsignal (cxx:meta-object qsignal)

+ (id qsignal)

+ args)))))

Sun May 24 17:02:00 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* *exec-p* allows disabling qt:exec

+(defvar *exec-p* t

+ "Run exec if true and not otherwise.")

- (restart-bind ((abort-app #'(lambda ()

- (application.close-all-windows)

- (cxx:quit (app))

- (invoke-restart (find-restart 'continue)))

- :report-function

- #'(lambda (stream)

- (format stream "Return from the application event loop."))))

- (cxx:exec (app))))

+ (when *exec-p*

+ (restart-bind ((abort-app #'(lambda ()

+ (application.close-all-windows)

+ (cxx:quit (app))

+ (invoke-restart (find-restart 'continue)))

+ :report-function

+ #'(lambda (stream)

+ (format stream "Return from the application event loop."))))

+ (cxx:exec (app)))))

+ #:*exec-p*

Sun May 24 16:42:40 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Clozure CL Cmd line args for with-app

- #-sbcl (list (lisp-implementation-type))))

+ #+ccl ccl:*command-line-argument-list*

+ #-(or sbcl ccl) (list (lisp-implementation-type))))

Sun May 24 16:40:11 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Use overload resolution instead of static-call

-; (when (typep (app) (find-class 'qt:application))

-; (application.close-all-windows))

+ (when (typep (app) (find-class 'qt:application))

+ (application.close-all-windows))

+ (cxx:delete-later (app))

- (:export #:call

-

- #:app

+ (:export #:app

-(defun static-call (class-name method-name &rest args)

- (apply #'smoke::static-call *qt-smoke* class-name method-name args))

-

- (static-call "QMetaObject" "connect#$#$$$"

- sender

- signal-id

- receiver

- slot-id

- (if (null type)

- (value +auto-connection+)

- (value type))

- types))

+ (meta-object.connect sender signal-id

+ receiver slot-id

+ (if (null type)

+ (value +auto-connection+)

+ (value type))

+ types))

- (static-call "QMetaObject" "disconnect#$#$"

- sender

- signal-id

- receiver

- slot-id))

+ (meta-object.disconnect sender signal-id receiver slot-id))

- (assert (static-call "QMetaObject" "connect#$#$$$"

- qsignal

- (id qsignal)

- receiver

- slot-id

- type

- ;; QMetaObject::connect is responsible for freeing

- ;; the types array.

- (types (method-arguments-type

- (cxx:meta-object receiver)

- slot-id)))

- ()

- "Failed to connect ~S to the slot ~S of ~S."

- qsignal slot receiver)))

+ (or (meta-object.connect qsignal (id qsignal)

+ receiver slot-id

+ type

+ ;; QMetaObject::connect is responsible [_$_]

+ ;; for freeing the types array.

+ (types (method-arguments-type

+ (cxx:meta-object receiver)

+ slot-id)))

+ (cerror "Ignore"

+ "Failed to connect ~S to the slot ~S of ~S."

+ qsignal slot receiver))))

- (cxx:data

- (meta-object.normalized-signature slot)))))

+ (cxx:data

+ (meta-object.normalized-signature slot)))))

- (assert (static-call "QMetaObject" "disconnect#$#$"

- qsignal

- (id qsignal)

- receiver

- slot-id)

- ()

- "Failed to disconnect ~S to the slot ~S of ~S."

- qsignal slot receiver)))

+ (or (meta-object.disconnect qsignal (id qsignal)

+ receiver slot-id)

+ (cerror "Ignore" [_$_]

+ "Failed to disconnect ~S to the slot ~S of ~S."

+ qsignal slot receiver))))

- (smoke::static-call *qt-smoke* "QMetaObject" "activate##$?"

- qsignal

- (cxx:meta-object qsignal)

+ (meta-object.activate qsignal (cxx:meta-object qsignal)

- (let ((ret (static-call "QMetaObject" "connect#$#$$$"

- sender

- signal-id

- slot

- (id slot)

- type

- (types (arguments slot)))))

+ (let ((ret (meta-object.connect sender signal-id

+ slot (id slot)

+ type (types (arguments slot)))))

- (cxx:connect-notify sender signal)

- (cerror "Failed to connect the signal ~S of ~S to the function ~S."

- signal sender function)))))

+ (cxx:connect-notify sender signal)

+ (cerror "Failed to connect the signal ~S of ~S to the function ~S."

+ signal sender function)))))

Sun May 24 16:30:31 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Cleanup app in with-app

- (*app*))

+ (*app*)

+ "No application.")

-; (assert (null-pointer-p (smoke::pointer (core-application.instance))))

- (foreign-free argv)

- (foreign-free argc)

+ ;(assert (null-pointer-p (smoke::pointer (core-application.instance))))

+ (foreign-free argv)

+ (foreign-free argc)

- (values (qt:new "QApplication" "QApplication$?" argc argv) t))))

+ (values (make-instance 'qt:application :args (list argc argv)) t))))

- (when (typep (app) (find-class 'qt:application))

- (application.close-all-windows))

+; (when (typep (app) (find-class 'qt:application))

+; (application.close-all-windows))

- ;(smoke::remove-object (smoke::pointer (app)))

- (smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))

+ (smoke::remove-object (smoke::pointer (app)))

+ ;; FIXME leak memory or memory fault!

+ ;(smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))

-; (foreign-free argc)

- (setf argc (null-pointer))

-; (foreign-free argv)

- (setf argv (null-pointer))

- `(progn (setf *app* ,ensure-app)

- (unwind-protect

- (progn

- ,@body))))

+ (let ((cleanup-p (gensym)))

+ `(multiple-value-bind (*app* ,cleanup-p) ,ensure-app

+ (unwind-protect

+ (progn ,@body)

+ (when ,cleanup-p

+ ,remove-app)))))

- (:export #:new

- #:call

+ (:export #:call

-(defun new (class-name method-name &rest args)

- (apply #'new-object (smoke::binding *qt-smoke*) class-name method-name args))

-

Sun May 24 13:42:39 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Signal slot finalization fix

+(defun disown-object (object)

+ (tg:cancel-finalization object)

+ (unless (smoke::virtual-destructor-p (class-of object))

+ (smoke::remove-object (pointer object)))

+ object)

+

+ "Returns the lisp value or object at POINTER of type TYPE."

- (smoke::object-to-lisp 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)))

+ "Returns ARGUMENTS for a slot invocation as lisp objects."

+ "Returns the QMetaType ID for SMOKE-TYPE."

+ "Returns a newly allocated array of QMetaType IDs of SMOKE-TYPES."

- (print-unreadable-object (variant stream :type t)

+ (print-unreadable-object (variant stream :type t :identity t)

Tue May 19 17:16:49 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Search paths in with-translator

- (cxx:name (qt:locale.system)))))

+ (cxx:name (qt:locale.system)))

+ (namestring path)))

Tue May 19 16:32:42 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Clozure CL save-application fixes

+install(TARGETS qt-smoke-extra

+ LIBRARY DESTINATION lib)

+

-(cffi:defcfun qt-smoke-register-event-notify :boolean

- (event-notify :pointer))

+(eval-when (:compile-toplevel :load-toplevel :execute)

+ (cffi:defcfun qt-smoke-register-event-notify :boolean

+ (event-notify :pointer)))

-(smoke:eval-startup (:compile-toplevel :execute)

+(eval-when (:load-toplevel :compile-toplevel :execute)

Thu May 14 14:11:11 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Lisp image loading

-(defmacro with-translator (base-name &body body)

- "Loads the translations in the BASE-NAME_LANGCODE.qm file.

+(defmacro with-translator ((base-name &rest paths) &body body)

+ "Loads the translations in the BASE-NAME_LANGCODE.qm file;

+searching PATHS.

- (unless (cxx:load ,translator (format nil "~A_~A"

- ,base-name

- (cxx:name (qt:locale.system))))

+ (unless [_$_]

+ (find-if #'(lambda (path)

+ (cxx:load ,translator

+ (format nil "~A_~A" ,base-name

+ (cxx:name (qt:locale.system)))))

+ (list ,@paths))

+

+(defun search-file (name &rest paths)

+ "Searches the file NAME in PATHS and returns its path."

+ (let ((file-path (find-if #'(lambda (path)

+ (probe-file (merge-pathnames name path)))

+ paths)))

+ (unless file-path

+ (error "The file ~S not found in the paths ~S" name paths))

+ (merge-pathnames name file-path)))

+

-(eval-when (:load-toplevel)

+(eval-startup ()

- (if (null-pointer-p (pointer object))

+ (if (or (not (slot-boundp object 'pointer))

+ (null-pointer-p (pointer object)))

-(let ((get-parent (smoke::make-smoke-method (smoke::make-smoke-class

+(smoke:eval-startup (:compile-toplevel :execute)

+(defparameter *get-parent*

+ (smoke::make-smoke-method (smoke::make-smoke-class

- (delete-later (smoke::make-smoke-method (smoke::make-smoke-class

+(defparameter *delete-later*

+ (smoke::make-smoke-method (smoke::make-smoke-class

+

- (if (null-pointer-p (smoke::pointer-call get-parent pointer))

- (smoke::pointer-call delete-later pointer)

+ (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))

+ (smoke::pointer-call *delete-later* pointer)

- (when (null-pointer-p (smoke::pointer-call get-parent pointer))

+ (when (null-pointer-p (smoke::pointer-call *get-parent* pointer))

- condition)))))))

+ condition))))))

-(eval-when (:load-toplevel)

+(smoke:eval-startup ()

+ #:search-file

+

-(eval-when (:compile-toplevel :load-toplevel :execute)

+(smoke:eval-startup (:compile-toplevel :execute)

+(smoke:eval-startup (:compile-toplevel :execute)

- :count (cxx:size array)))))

+ :count (cxx:size array))))))

-(eval-when (:load-toplevel :compile-toplevel :execute)

- (define-foreign-library libsmokeqt

- (:unix "libsmokeqt.so.2")

- (t (:default "libsmokeqt")))

-

- (use-foreign-library libsmokeqt)

-

- (use-foreign-library libqt-smoke-extra)

- [_$_]

- (defcvar ("qt_Smoke" :read-only t) :pointer

- "The Smoke Qt binding")

-

- (defcfun (init-qt-smoke "_Z13init_qt_Smokev") :void)

-

- (defvar *qt-binding* (null-pointer))

-

- (init-qt-smoke))

-

-(eval-when (:load-toplevel :compile-toplevel)

- (when (null-pointer-p *qt-binding*)

- (setf *qt-binding* (init *qt-smoke*))))

-

-(define-methods *qt-smoke*)

+(define-smoke-module libsmokeqt

+ (*qt-smoke* "qt_Smoke")

+ (init-qt-smoke "init_qt_Smoke"))

+(smoke:eval-startup (:compile-toplevel :execute)

+ (use-foreign-library libqt-smoke-extra))

- (apply #'new-object *qt-binding* class-name method-name args))

+ (apply #'new-object (smoke::binding *qt-smoke*) class-name method-name args))

- "Returns a new VARIANT that wraps VALUE."

+ "Returns a new VARIANT that wraps VALUE.

+

+The variant contains the actual Lisp object

+and not its C++ value like in MAKE-VARIANT."

Tue May 12 17:42:35 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Make *qt-smoke* read only

- (defcvar "qt_Smoke" :pointer

+ (defcvar ("qt_Smoke" :read-only t) :pointer

Mon May 11 21:50:13 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* print-object qt:object object-name

+(defmethod print-object ((object object) stream)

+ (if (null-pointer-p (pointer object))

+ (call-next-method)

+ (print-unreadable-object (object stream :type t :identity t)

+ (princ (cxx:object-name object) stream))))

+

Mon May 11 16:15:30 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Cleanup remove unnecessary smoke:: in translation code.

- (smoke::make-cleanup-pointer

+ (make-cleanup-pointer

-(smoke::define-from-lisp-translation "const QString&" string

+(define-from-lisp-translation "const QString&" string

- (smoke::make-cleanup-pointer

+ (make-cleanup-pointer

-(smoke::define-from-lisp-translation "const QStringList&"

+(define-from-lisp-translation "const QStringList&"

Mon May 11 16:14:14 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix setf value and export variant-boundp.

+ #:value

+ #:variant-boundp

- (valid-p (cxx:property object (property-name name))))

+ (variant-boundp (cxx:property object (property-name name))))

+ "Returns a char for a lisp CHARACTER."

-(defun valid-p (variant)

+(defun variant-boundp (variant)

- (cxx:operator= variant (make-variant new-value)))

+ (cxx:operator= variant (make-variant new-value))

+ new-value)

Mon May 11 14:07:17 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* GCC visibility support for C wrapper symbols

+include(CheckCXXCompilerFlag)

+check_cxx_compiler_flag("-fvisibility=hidden" CXX_VISIBILITY)

+if(CXX_VISIBILITY)

+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden")

+endif(CXX_VISIBILITY)

+

+#ifndef CL_SMOKE_QT_H

+#define CL_SMOKE_QT_H

+

+#if defined _WIN32 || defined __CYGWIN__

+ #define CL_SMOKE_QT_EXPORT __declspec(dllexport)

+#else

+ #if __GNUC__ >= 4

+ #define CL_SMOKE_QT_EXPORT __attribute__((visibility("default")))

+ #else

+ #define CL_SMOKE_QT_EXPORT

+ #endif

+#endif

+

+#endif // CL_SMOKE_QT_H

+#include "cl_smoke_qt.h"

- int

+ CL_SMOKE_QT_EXPORT int

- int

+ CL_SMOKE_QT_EXPORT int

- int

+ CL_SMOKE_QT_EXPORT int

- void*

+ CL_SMOKE_QT_EXPORT void*

- void*

+ CL_SMOKE_QT_EXPORT void*

- void*

+ CL_SMOKE_QT_EXPORT void*

+#include "cl_smoke_qt.h"

-int \

+CL_SMOKE_QT_EXPORT int \

-void \

+CL_SMOKE_QT_EXPORT void \

-void* \

+CL_SMOKE_QT_EXPORT void* \

-const void* \

+CL_SMOKE_QT_EXPORT const void* \

-void \

+CL_SMOKE_QT_EXPORT void \

-const void* \

+CL_SMOKE_QT_EXPORT const void* \

-void \

+CL_SMOKE_QT_EXPORT void \

+#include "cl_smoke_qt.h"

+

-void*

+CL_SMOKE_QT_EXPORT void*

-void

+CL_SMOKE_QT_EXPORT void

-void*

+CL_SMOKE_QT_EXPORT void*

+#include "cl_smoke_qt.h"

+

-int

+CL_SMOKE_QT_EXPORT int

-void*

+CL_SMOKE_QT_EXPORT void*

-void

+CL_SMOKE_QT_EXPORT void

-void*

+CL_SMOKE_QT_EXPORT void*

-void

+CL_SMOKE_QT_EXPORT void

+#include "cl_smoke_qt.h"

+

-int

+CL_SMOKE_QT_EXPORT int

Mon May 11 13:21:14 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList translations C wrapper

-set(QT_SMOKE_SOURCES qt-smoke.cpp qstring.cpp qstringlist.cpp lisp-object.cpp)

+set(QT_SMOKE_SOURCES qt-smoke.cpp qstring.cpp qstringlist.cpp lisp-object.cpp qlist.cpp)

+#include "qlist.h"

+

+/** @file

+ * @brief QList conversions. */

+

+#include <QVariant>

+#include <QByteArray>

+

+extern "C" {

+

+DEFINE_QLIST_WRAPPER(QVariant)

+DEFINE_QLIST_WRAPPER_PTR(void)

+DEFINE_QLIST_WRAPPER(QByteArray)

+

+} // extern "C"

+#ifndef CL_SMOKE_QT_QLIST_H

+#define CL_SMOKE_QT_QLIST_H

+

+#include <QList>

+

+/** @file

+ */

+

+/** Defines a C wrapper for the QList<@a TYPE>.

+ * @param TYPE the type of the elements of the QList

+ */

+#define DEFINE_QLIST_WRAPPER(TYPE) \

+ DEFINE_QLIST_WRAPPER_3(TYPE, TYPE, VALUE)

+

+/** Defines a C wrapper for the QList<@a TYPE*>,

+ * where @a TYPE is the of the pointer.

+ *

+ * @param NAME the name used for the wrapper functions.

+ * @param TYPE the type of the elements

+ */

+#define DEFINE_QLIST_WRAPPER_PTR(TYPE) \

+ DEFINE_QLIST_WRAPPER_3(TYPE, TYPE*, PTR)

+

+/** @internal */

+#define DEFINE_QLIST_WRAPPER_3(NAME, TYPE, PTR_VALUE) \

+ DEFINE_QLIST_WRAPPER_ALL_PART(NAME, TYPE) \

+ DEFINE_QLIST_WRAPPER_ ## PTR_VALUE ## _PART(NAME, TYPE) \

+[_^I_][_$_]

+

+/** @internal

+ * size, free and make_list. */

+#define DEFINE_QLIST_WRAPPER_ALL_PART(NAME, TYPE) \

+int \

+qt_smoke_list_ ## NAME ## size(const void* list) \

+{ \

+ return static_cast<const QList< TYPE >*>(list)->size(); \

+} \

+\

+void \

+qt_smoke_free_list_ ## NAME (void* list) \

+{ \

+ delete static_cast<QList< TYPE >*>(list); \

+} \

+ \

+void* \

+qt_smoke_make_list_ ## NAME () \

+{ \

+ return new QList< TYPE >(); \

+} \

+ \

+

+/** @internal

+ * At and append for pointer types

+ */

+#define DEFINE_QLIST_WRAPPER_PTR_PART(NAME, TYPE) \

+const void* \

+qt_smoke_list_ ## NAME ## _at(const void* list, int index) \

+{ \

+ const QList< TYPE >* qlist = static_cast<const QList< TYPE > *>(list); \

+ return qlist->at(index); \

+} \

+\

+void \

+qt_smoke_list_ ## NAME ## _append(void* list, void* data, int length) \

+{ \

+ static_cast<QList< TYPE >*>(list) \

+ ->append(static_cast<TYPE>(data)); \

+} \

+

+/** @internal

+ * At and append for value types.

+ */

+#define DEFINE_QLIST_WRAPPER_VALUE_PART(NAME, TYPE) \

+const void* \

+qt_smoke_list_ ## NAME ## _at(const void* list, int index) \

+{ \

+ const QList< TYPE >* qlist = static_cast<const QList< TYPE > *>(list); \

+ return &qlist->at(index); \

+} \

+\

+void \

+qt_smoke_list_ ## NAME ## _append(void* list, void* data, int length) \

+{ \

+ static_cast<QList< TYPE >*>(list) \

+ ->append(*static_cast<TYPE*>(data)); \

+} \

+

+#endif // CL_SMOKE_QT_QLIST_H

Mon May 11 13:18:36 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* update marshalling for overload resolution

+ (:uses-macros-from :smoke)

+(defun coerce-qstring (string)

+ (smoke::make-cleanup-pointer

+ (translate-to-foreign string (make-instance 'qt::qstring))

+ #'(lambda (pointer)

+ (free-translated-object pointer (make-instance 'qt::qstring)

+ nil))))

+

+(smoke::define-from-lisp-translation "const QString&" string

+ coerce-qstring)

+

- ;(make-smoke-classes *qt-smoke*))

+(defun coerce-string-list (list)

+ (smoke::make-cleanup-pointer

+ (translate-to-foreign list (make-instance 'qt::string-list))

+ #'(lambda (pointer)

+ (free-translated-object pointer (make-instance 'qt::string-list)

+ nil))))

+

+(smoke::define-from-lisp-translation "const QStringList&"

+ (vector string) coerce-string-list)

+

Mon May 11 13:09:54 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* cleanup variant

-(defgeneric make-variant (value)

- (:documentation "Returns a variant for VALUE."))

-

-(defmethod make-variant (value)

- "Returns a new VARIANT containing a C++ version of VALUE."

- (make-instance 'variant :args (list value)))

+(defun make-variant (&optional (value nil value-p))

+ "Returns a new VARIANT containing a C++ version of VALUE

+or an empty variant when VALUE is not specified."

+ (if value-p

+ (make-instance 'variant :args (list value))

+ (make-instance 'variant)))

+

+(defun make-char (character)

+ (let ((octets (babel:string-to-octets (string character))))

+ (case (length octets)

+ (1 (make-instance 'char :args (list (aref octets 0))))

+ (2 (make-instance 'char :args (list (aref octets 0)

+ (aref octets 1))))

+ (t (error "qt:char requires the character ~A to be encoded

+in one or two octets, but it is using ~A."

+ character (length octets))))))

+

+(defun surrogate-p (char)

+ (or (cxx:is-high-surrogate char)

+ (cxx:is-low-surrogate char)))

+

+(defun from-char (char)

+ "Returns the lisp character represented by CHAR."

+ (assert (not (surrogate-p char))

+ (char)

+ "The char ~A is part of a surrogate.")

+ (char

+ (babel:octets-to-string (make-array 2 :element-type '(unsigned-byte 8)

+ :initial-contents

+ (list

+ (char-code (cxx:cell char))

+ (char-code (cxx:row char)))))

+ 0))

+

+(defmethod print-object ((char char) stream)

+ (if (or (null-pointer-p (pointer char))

+ (surrogate-p char))

+ (call-next-method)

+ (print-unreadable-object (char stream :type t)

+ (princ (from-char char) stream))))

+

- "Returns a new VARIANT that wrapps VALUE."

+ "Returns a new VARIANT that wraps VALUE."

-;;FIXME define setf-able value function

-

- (cerror "Return NIL" "Type of variant ~A is invalid." variant)

- nil)

+ (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant)

+ (values))

+ (#.(value variant.+char+)

+ (cxx:to-char variant))

+ (#.(value variant.+bool+)

+ (cxx:to-bool variant))

+

+(defmethod value ((variant variant))

+ "Returns the value of VARIANT."

+ (from-variant variant))

+

+(defmethod (setf value) (new-value (variant variant))

+ (cxx:operator= variant (make-variant new-value)))

Wed Apr 15 10:20:41 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* It is cxx:>= not cxx:=>.

-(define-cxx-relations < <= => >)

+(define-cxx-relations < <= >= >)

Tue Apr 14 16:25:46 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* License

+

+ GNU GENERAL PUBLIC LICENSE

+ Version 3, 29 June 2007

+

+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>

+ Everyone is permitted to copy and distribute verbatim copies

+ of this license document, but changing it is not allowed.

+

+ Preamble

+

+ The GNU General Public License is a free, copyleft license for

+software and other kinds of works.

+

+ The licenses for most software and other practical works are designed

+to take away your freedom to share and change the works. By contrast,

+the GNU General Public License is intended to guarantee your freedom to

+share and change all versions of a program--to make sure it remains free

+software for all its users. We, the Free Software Foundation, use the

+GNU General Public License for most of our software; it applies also to

+any other work released this way by its authors. You can apply it to

+your programs, too.

+

+ When we speak of free software, we are referring to freedom, not

+price. Our General Public Licenses are designed to make sure that you

+have the freedom to distribute copies of free software (and charge for

+them if you wish), that you receive source code or can get it if you

+want it, that you can change the software or use pieces of it in new

+free programs, and that you know you can do these things.

+

+ To protect your rights, we need to prevent others from denying you

+these rights or asking you to surrender the rights. Therefore, you have

+certain responsibilities if you distribute copies of the software, or if

+you modify it: responsibilities to respect the freedom of others.

+

+ For example, if you distribute copies of such a program, whether

+gratis or for a fee, you must pass on to the recipients the same

+freedoms that you received. You must make sure that they, too, receive

+or can get the source code. And you must show them these terms so they

+know their rights.

+

+ Developers that use the GNU GPL protect your rights with two steps:

+(1) assert copyright on the software, and (2) offer you this License

+giving you legal permission to copy, distribute and/or modify it.

+

+ For the developers' and authors' protection, the GPL clearly explains

+that there is no warranty for this free software. For both users' and

+authors' sake, the GPL requires that modified versions be marked as

+changed, so that their problems will not be attributed erroneously to

+authors of previous versions.

+

+ Some devices are designed to deny users access to install or run

+modified versions of the software inside them, although the manufacturer

+can do so. This is fundamentally incompatible with the aim of

+protecting users' freedom to change the software. The systematic

+pattern of such abuse occurs in the area of products for individuals to

+use, which is precisely where it is most unacceptable. Therefore, we

+have designed this version of the GPL to prohibit the practice for those

+products. If such problems arise substantially in other domains, we

+stand ready to extend this provision to those domains in future versions

+of the GPL, as needed to protect the freedom of users.

+

+ Finally, every program is threatened constantly by software patents.

+States should not allow patents to restrict development and use of

+software on general-purpose computers, but in those that do, we wish to

+avoid the special danger that patents applied to a free program could

+make it effectively proprietary. To prevent this, the GPL assures that

+patents cannot be used to render the program non-free.

+

+ The precise terms and conditions for copying, distribution and

+modification follow.

+

+ TERMS AND CONDITIONS

+

+ 0. Definitions.

+

+ "This License" refers to version 3 of the GNU General Public License.

+

+ "Copyright" also means copyright-like laws that apply to other kinds of

+works, such as semiconductor masks.

+ [_$_]

+ "The Program" refers to any copyrightable work licensed under this

+License. Each licensee is addressed as "you". "Licensees" and

+"recipients" may be individuals or organizations.

+

+ To "modify" a work means to copy from or adapt all or part of the work

+in a fashion requiring copyright permission, other than the making of an

+exact copy. The resulting work is called a "modified version" of the

+earlier work or a work "based on" the earlier work.

+

+ A "covered work" means either the unmodified Program or a work based

+on the Program.

+

+ To "propagate" a work means to do anything with it that, without

+permission, would make you directly or secondarily liable for

+infringement under applicable copyright law, except executing it on a

+computer or modifying a private copy. Propagation includes copying,

+distribution (with or without modification), making available to the

+public, and in some countries other activities as well.

+

+ To "convey" a work means any kind of propagation that enables other

+parties to make or receive copies. Mere interaction with a user through

+a computer network, with no transfer of a copy, is not conveying.

+

+ An interactive user interface displays "Appropriate Legal Notices"

+to the extent that it includes a convenient and prominently visible

+feature that (1) displays an appropriate copyright notice, and (2)

+tells the user that there is no warranty for the work (except to the

+extent that warranties are provided), that licensees may convey the

+work under this License, and how to view a copy of this License. If

+the interface presents a list of user commands or options, such as a

+menu, a prominent item in the list meets this criterion.

+

+ 1. Source Code.

+

+ The "source code" for a work means the preferred form of the work

+for making modifications to it. "Object code" means any non-source

+form of a work.

+

+ A "Standard Interface" means an interface that either is an official

+standard defined by a recognized standards body, or, in the case of

+interfaces specified for a particular programming language, one that

+is widely used among developers working in that language.

+

+ The "System Libraries" of an executable work include anything, other

+than the work as a whole, that (a) is included in the normal form of

+packaging a Major Component, but which is not part of that Major

+Component, and (b) serves only to enable use of the work with that

+Major Component, or to implement a Standard Interface for which an

+implementation is available to the public in source code form. A

+"Major Component", in this context, means a major essential component

+(kernel, window system, and so on) of the specific operating system

+(if any) on which the executable work runs, or a compiler used to

+produce the work, or an object code interpreter used to run it.

+

+ The "Corresponding Source" for a work in object code form means all

+the source code needed to generate, install, and (for an executable

+work) run the object code and to modify the work, including scripts to

+control those activities. However, it does not include the work's

+System Libraries, or general-purpose tools or generally available free

+programs which are used unmodified in performing those activities but

+which are not part of the work. For example, Corresponding Source

+includes interface definition files associated with source files for

+the work, and the source code for shared libraries and dynamically

+linked subprograms that the work is specifically designed to require,

+such as by intimate data communication or control flow between those

+subprograms and other parts of the work.

+

+ The Corresponding Source need not include anything that users

+can regenerate automatically from other parts of the Corresponding

+Source.

+

+ The Corresponding Source for a work in source code form is that

+same work.

+

+ 2. Basic Permissions.

+

+ All rights granted under this License are granted for the term of

+copyright on the Program, and are irrevocable provided the stated

+conditions are met. This License explicitly affirms your unlimited

+permission to run the unmodified Program. The output from running a

+covered work is covered by this License only if the output, given its

+content, constitutes a covered work. This License acknowledges your

+rights of fair use or other equivalent, as provided by copyright law.

+

+ You may make, run and propagate covered works that you do not

+convey, without conditions so long as your license otherwise remains

+in force. You may convey covered works to others for the sole purpose

+of having them make modifications exclusively for you, or provide you

+with facilities for running those works, provided that you comply with

+the terms of this License in conveying all material for which you do

+not control copyright. Those thus making or running the covered works

+for you must do so exclusively on your behalf, under your direction

+and control, on terms that prohibit them from making any copies of

+your copyrighted material outside their relationship with you.

+

+ Conveying under any other circumstances is permitted solely under

+the conditions stated below. Sublicensing is not allowed; section 10

+makes it unnecessary.

+

+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.

+

+ No covered work shall be deemed part of an effective technological

+measure under any applicable law fulfilling obligations under article

+11 of the WIPO copyright treaty adopted on 20 December 1996, or

+similar laws prohibiting or restricting circumvention of such

+measures.

+

+ When you convey a covered work, you waive any legal power to forbid

+circumvention of technological measures to the extent such circumvention

+is effected by exercising rights under this License with respect to

+the covered work, and you disclaim any intention to limit operation or

+modification of the work as a means of enforcing, against the work's

+users, your or third parties' legal rights to forbid circumvention of

+technological measures.

+

+ 4. Conveying Verbatim Copies.

+

+ You may convey verbatim copies of the Program's source code as you

+receive it, in any medium, provided that you conspicuously and

+appropriately publish on each copy an appropriate copyright notice;

+keep intact all notices stating that this License and any

+non-permissive terms added in accord with section 7 apply to the code;

+keep intact all notices of the absence of any warranty; and give all

+recipients a copy of this License along with the Program.

+

+ You may charge any price or no price for each copy that you convey,

+and you may offer support or warranty protection for a fee.

+

+ 5. Conveying Modified Source Versions.

+

+ You may convey a work based on the Program, or the modifications to

+produce it from the Program, in the form of source code under the

+terms of section 4, provided that you also meet all of these conditions:

+

+ a) The work must carry prominent notices stating that you modified

+ it, and giving a relevant date.

+

+ b) The work must carry prominent notices stating that it is

+ released under this License and any conditions added under section

+ 7. This requirement modifies the requirement in section 4 to

+ "keep intact all notices".

+

+ c) You must license the entire work, as a whole, under this

+ License to anyone who comes into possession of a copy. This

+ License will therefore apply, along with any applicable section 7

+ additional terms, to the whole of the work, and all its parts,

+ regardless of how they are packaged. This License gives no

+ permission to license the work in any other way, but it does not

+ invalidate such permission if you have separately received it.

+

+ d) If the work has interactive user interfaces, each must display

+ Appropriate Legal Notices; however, if the Program has interactive

+ interfaces that do not display Appropriate Legal Notices, your

+ work need not make them do so.

+

+ A compilation of a covered work with other separate and independent

+works, which are not by their nature extensions of the covered work,

+and which are not combined with it such as to form a larger program,

+in or on a volume of a storage or distribution medium, is called an

+"aggregate" if the compilation and its resulting copyright are not

+used to limit the access or legal rights of the compilation's users

+beyond what the individual works permit. Inclusion of a covered work

+in an aggregate does not cause this License to apply to the other

+parts of the aggregate.

+

+ 6. Conveying Non-Source Forms.

+

+ You may convey a covered work in object code form under the terms

+of sections 4 and 5, provided that you also convey the

+machine-readable Corresponding Source under the terms of this License,

+in one of these ways:

+

+ a) Convey the object code in, or embodied in, a physical product

+ (including a physical distribution medium), accompanied by the

+ Corresponding Source fixed on a durable physical medium

+ customarily used for software interchange.

+

+ b) Convey the object code in, or embodied in, a physical product

+ (including a physical distribution medium), accompanied by a

+ written offer, valid for at least three years and valid for as

+ long as you offer spare parts or customer support for that product

+ model, to give anyone who possesses the object code either (1) a

+ copy of the Corresponding Source for all the software in the

+ product that is covered by this License, on a durable physical

+ medium customarily used for software interchange, for a price no

+ more than your reasonable cost of physically performing this

+ conveying of source, or (2) access to copy the

+ Corresponding Source from a network server at no charge.

+

+ c) Convey individual copies of the object code with a copy of the

+ written offer to provide the Corresponding Source. This

+ alternative is allowed only occasionally and noncommercially, and

+ only if you received the object code with such an offer, in accord

+ with subsection 6b.

+

+ d) Convey the object code by offering access from a designated

+ place (gratis or for a charge), and offer equivalent access to the

+ Corresponding Source in the same way through the same place at no

+ further charge. You need not require recipients to copy the

+ Corresponding Source along with the object code. If the place to

+ copy the object code is a network server, the Corresponding Source

+ may be on a different server (operated by you or a third party)

+ that supports equivalent copying facilities, provided you maintain

+ clear directions next to the object code saying where to find the

+ Corresponding Source. Regardless of what server hosts the

+ Corresponding Source, you remain obligated to ensure that it is

+ available for as long as needed to satisfy these requirements.

+

+ e) Convey the object code using peer-to-peer transmission, provided

+ you inform other peers where the object code and Corresponding

+ Source of the work are being offered to the general public at no

+ charge under subsection 6d.

+

+ A separable portion of the object code, whose source code is excluded

+from the Corresponding Source as a System Library, need not be

+included in conveying the object code work.

+

+ A "User Product" is either (1) a "consumer product", which means any

+tangible personal property which is normally used for personal, family,

+or household purposes, or (2) anything designed or sold for incorporation

+into a dwelling. In determining whether a product is a consumer product,

+doubtful cases shall be resolved in favor of coverage. For a particular

+product received by a particular user, "normally used" refers to a

+typical or common use of that class of product, regardless of the status

+of the particular user or of the way in which the particular user

+actually uses, or expects or is expected to use, the product. A product

+is a consumer product regardless of whether the product has substantial

+commercial, industrial or non-consumer uses, unless such uses represent

+the only significant mode of use of the product.

+

+ "Installation Information" for a User Product means any methods,

+procedures, authorization keys, or other information required to install

+and execute modified versions of a covered work in that User Product from

+a modified version of its Corresponding Source. The information must

+suffice to ensure that the continued functioning of the modified object

+code is in no case prevented or interfered with solely because

+modification has been made.

+

+ If you convey an object code work under this section in, or with, or

+specifically for use in, a User Product, and the conveying occurs as

+part of a transaction in which the right of possession and use of the

+User Product is transferred to the recipient in perpetuity or for a

+fixed term (regardless of how the transaction is characterized), the

+Corresponding Source conveyed under this section must be accompanied

+by the Installation Information. But this requirement does not apply

+if neither you nor any third party retains the ability to install

+modified object code on the User Product (for example, the work has

+been installed in ROM).

+

+ The requirement to provide Installation Information does not include a

+requirement to continue to provide support service, warranty, or updates

+for a work that has been modified or installed by the recipient, or for

+the User Product in which it has been modified or installed. Access to a

+network may be denied when the modification itself materially and

+adversely affects the operation of the network or violates the rules and

+protocols for communication across the network.

+

+ Corresponding Source conveyed, and Installation Information provided,

+in accord with this section must be in a format that is publicly

+documented (and with an implementation available to the public in

+source code form), and must require no special password or key for

+unpacking, reading or copying.

+

+ 7. Additional Terms.

+

+ "Additional permissions" are terms that supplement the terms of this

+License by making exceptions from one or more of its conditions.

+Additional permissions that are applicable to the entire Program shall

+be treated as though they were included in this License, to the extent

+that they are valid under applicable law. If additional permissions

+apply only to part of the Program, that part may be used separately

+under those permissions, but the entire Program remains governed by

+this License without regard to the additional permissions.

+

+ When you convey a copy of a covered work, you may at your option

+remove any additional permissions from that copy, or from any part of

+it. (Additional permissions may be written to require their own

+removal in certain cases when you modify the work.) You may place

+additional permissions on material, added by you to a covered work,

+for which you have or can give appropriate copyright permission.

+

+ Notwithstanding any other provision of this License, for material you

+add to a covered work, you may (if authorized by the copyright holders of

+that material) supplement the terms of this License with terms:

+

+ a) Disclaiming warranty or limiting liability differently from the

+ terms of sections 15 and 16 of this License; or

+

+ b) Requiring preservation of specified reasonable legal notices or

+ author attributions in that material or in the Appropriate Legal

+ Notices displayed by works containing it; or

+

+ c) Prohibiting misrepresentation of the origin of that material, or

+ requiring that modified versions of such material be marked in

+ reasonable ways as different from the original version; or

+

+ d) Limiting the use for publicity purposes of names of licensors or

+ authors of the material; or

+

+ e) Declining to grant rights under trademark law for use of some

+ trade names, trademarks, or service marks; or

+

+ f) Requiring indemnification of licensors and authors of that

+ material by anyone who conveys the material (or modified versions of

+ it) with contractual assumptions of liability to the recipient, for

+ any liability that these contractual assumptions directly impose on

+ those licensors and authors.

+

+ All other non-permissive additional terms are considered "further

+restrictions" within the meaning of section 10. If the Program as you

+received it, or any part of it, contains a notice stating that it is

+governed by this License along with a term that is a further

+restriction, you may remove that term. If a license document contains

+a further restriction but permits relicensing or conveying under this

+License, you may add to a covered work material governed by the terms

+of that license document, provided that the further restriction does

+not survive such relicensing or conveying.

+

+ If you add terms to a covered work in accord with this section, you

+must place, in the relevant source files, a statement of the

+additional terms that apply to those files, or a notice indicating

+where to find the applicable terms.

+

+ Additional terms, permissive or non-permissive, may be stated in the

+form of a separately written license, or stated as exceptions;

+the above requirements apply either way.

+

+ 8. Termination.

+

+ You may not propagate or modify a covered work except as expressly

+provided under this License. Any attempt otherwise to propagate or

+modify it is void, and will automatically terminate your rights under

+this License (including any patent licenses granted under the third

+paragraph of section 11).

+

+ However, if you cease all violation of this License, then your

+license from a particular copyright holder is reinstated (a)

+provisionally, unless and until the copyright holder explicitly and

+finally terminates your license, and (b) permanently, if the copyright

+holder fails to notify you of the violation by some reasonable means

+prior to 60 days after the cessation.

+

+ Moreover, your license from a particular copyright holder is

+reinstated permanently if the copyright holder notifies you of the

+violation by some reasonable means, this is the first time you have

+received notice of violation of this License (for any work) from that

+copyright holder, and you cure the violation prior to 30 days after

+your receipt of the notice.

+

+ Termination of your rights under this section does not terminate the

+licenses of parties who have received copies or rights from you under

+this License. If your rights have been terminated and not permanently

+reinstated, you do not qualify to receive new licenses for the same

+material under section 10.

+

+ 9. Acceptance Not Required for Having Copies.

+

+ You are not required to accept this License in order to receive or

+run a copy of the Program. Ancillary propagation of a covered work

+occurring solely as a consequence of using peer-to-peer transmission

+to receive a copy likewise does not require acceptance. However,

+nothing other than this License grants you permission to propagate or

+modify any covered work. These actions infringe copyright if you do

+not accept this License. Therefore, by modifying or propagating a

+covered work, you indicate your acceptance of this License to do so.

+

+ 10. Automatic Licensing of Downstream Recipients.

+

+ Each time you convey a covered work, the recipient automatically

+receives a license from the original licensors, to run, modify and

+propagate that work, subject to this License. You are not responsible

+for enforcing compliance by third parties with this License.

+

+ An "entity transaction" is a transaction transferring control of an

+organization, or substantially all assets of one, or subdividing an

+organization, or merging organizations. If propagation of a covered

+work results from an entity transaction, each party to that

+transaction who receives a copy of the work also receives whatever

+licenses to the work the party's predecessor in interest had or could

+give under the previous paragraph, plus a right to possession of the

+Corresponding Source of the work from the predecessor in interest, if

+the predecessor has it or can get it with reasonable efforts.

+

+ You may not impose any further restrictions on the exercise of the

+rights granted or affirmed under this License. For example, you may

+not impose a license fee, royalty, or other charge for exercise of

+rights granted under this License, and you may not initiate litigation

+(including a cross-claim or counterclaim in a lawsuit) alleging that

+any patent claim is infringed by making, using, selling, offering for

+sale, or importing the Program or any portion of it.

+

+ 11. Patents.

+

+ A "contributor" is a copyright holder who authorizes use under this

+License of the Program or a work on which the Program is based. The

+work thus licensed is called the contributor's "contributor version".

+

+ A contributor's "essential patent claims" are all patent claims

+owned or controlled by the contributor, whether already acquired or

+hereafter acquired, that would be infringed by some manner, permitted

+by this License, of making, using, or selling its contributor version,

+but do not include claims that would be infringed only as a

+consequence of further modification of the contributor version. For

+purposes of this definition, "control" includes the right to grant

+patent sublicenses in a manner consistent with the requirements of

+this License.

+

+ Each contributor grants you a non-exclusive, worldwide, royalty-free

+patent license under the contributor's essential patent claims, to

+make, use, sell, offer for sale, import and otherwise run, modify and

+propagate the contents of its contributor version.

+

+ In the following three paragraphs, a "patent license" is any express

+agreement or commitment, however denominated, not to enforce a patent

+(such as an express permission to practice a patent or covenant not to

+sue for patent infringement). To "grant" such a patent license to a

+party means to make such an agreement or commitment not to enforce a

+patent against the party.

+

+ If you convey a covered work, knowingly relying on a patent license,

+and the Corresponding Source of the work is not available for anyone

+to copy, free of charge and under the terms of this License, through a

+publicly available network server or other readily accessible means,

+then you must either (1) cause the Corresponding Source to be so

+available, or (2) arrange to deprive yourself of the benefit of the

+patent license for this particular work, or (3) arrange, in a manner

+consistent with the requirements of this License, to extend the patent

+license to downstream recipients. "Knowingly relying" means you have

+actual knowledge that, but for the patent license, your conveying the

+covered work in a country, or your recipient's use of the covered work

+in a country, would infringe one or more identifiable patents in that

+country that you have reason to believe are valid.

+ [_$_]

+ If, pursuant to or in connection with a single transaction or

+arrangement, you convey, or propagate by procuring conveyance of, a

+covered work, and grant a patent license to some of the parties

+receiving the covered work authorizing them to use, propagate, modify

+or convey a specific copy of the covered work, then the patent license

+you grant is automatically extended to all recipients of the covered

+work and works based on it.

+

+ A patent license is "discriminatory" if it does not include within

+the scope of its coverage, prohibits the exercise of, or is

+conditioned on the non-exercise of one or more of the rights that are

+specifically granted under this License. You may not convey a covered

+work if you are a party to an arrangement with a third party that is

+in the business of distributing software, under which you make payment

+to the third party based on the extent of your activity of conveying

+the work, and under which the third party grants, to any of the

+parties who would receive the covered work from you, a discriminatory

+patent license (a) in connection with copies of the covered work

+conveyed by you (or copies made from those copies), or (b) primarily

+for and in connection with specific products or compilations that

+contain the covered work, unless you entered into that arrangement,

+or that patent license was granted, prior to 28 March 2007.

+

+ Nothing in this License shall be construed as excluding or limiting

+any implied license or other defenses to infringement that may

+otherwise be available to you under applicable patent law.

+

+ 12. No Surrender of Others' Freedom.

+

+ If conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License. If you cannot convey a

+covered work so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you may

+not convey it at all. For example, if you agree to terms that obligate you

+to collect a royalty for further conveying from those to whom you convey

+the Program, the only way you could satisfy both those terms and this

+License would be to refrain entirely from conveying the Program.

+

+ 13. Use with the GNU Affero General Public License.

+

+ Notwithstanding any other provision of this License, you have

+permission to link or combine any covered work with a work licensed

+under version 3 of the GNU Affero General Public License into a single

+combined work, and to convey the resulting work. The terms of this

+License will continue to apply to the part which is the covered work,

+but the special requirements of the GNU Affero General Public License,

+section 13, concerning interaction through a network will apply to the

+combination as such.

+

+ 14. Revised Versions of this License.

+

+ The Free Software Foundation may publish revised and/or new versions of

+the GNU General Public License from time to time. Such new versions will

+be similar in spirit to the present version, but may differ in detail to

+address new problems or concerns.

+

+ Each version is given a distinguishing version number. If the

+Program specifies that a certain numbered version of the GNU General

+Public License "or any later version" applies to it, you have the

+option of following the terms and conditions either of that numbered

+version or of any later version published by the Free Software

+Foundation. If the Program does not specify a version number of the

+GNU General Public License, you may choose any version ever published

+by the Free Software Foundation.

+

+ If the Program specifies that a proxy can decide which future

+versions of the GNU General Public License can be used, that proxy's

+public statement of acceptance of a version permanently authorizes you

+to choose that version for the Program.

+

+ Later license versions may give you additional or different

+permissions. However, no additional obligations are imposed on any

+author or copyright holder as a result of your choosing to follow a

+later version.

+

+ 15. Disclaimer of Warranty.

+

+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY

+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT

+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY

+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,

+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM

+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF

+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

+

+ 16. Limitation of Liability.

+

+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS

+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY

+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE

+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF

+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD

+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),

+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF

+SUCH DAMAGES.

+

+ 17. Interpretation of Sections 15 and 16.

+

+ If the disclaimer of warranty and limitation of liability provided

+above cannot be given local legal effect according to their terms,

+reviewing courts shall apply local law that most closely approximates

+an absolute waiver of all civil liability in connection with the

+Program, unless a warranty or assumption of liability accompanies a

+copy of the Program in return for a fee.

+

+ END OF TERMS AND CONDITIONS

+

+ How to Apply These Terms to Your New Programs

+

+ If you develop a new program, and you want it to be of the greatest

+possible use to the public, the best way to achieve this is to make it

+free software which everyone can redistribute and change under these terms.

+

+ To do so, attach the following notices to the program. It is safest

+to attach them to the start of each source file to most effectively

+state the exclusion of warranty; and each file should have at least

+the "copyright" line and a pointer to where the full notice is found.

+

+ <one line to give the program's name and a brief idea of what it does.>

+ Copyright (C) <year> <name of author>

+

+ This program is free software: you can redistribute it and/or modify

+ it under the terms of the GNU General Public License as published by

+ the Free Software Foundation, either version 3 of the License, or

+ (at your option) any later version.

+

+ This program is distributed in the hope that it will be useful,

+ but WITHOUT ANY WARRANTY; without even the implied warranty of

+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ GNU General Public License for more details.

+

+ You should have received a copy of the GNU General Public License

+ along with this program. If not, see <http://www.gnu.org/licenses/>.

+

+Also add information on how to contact you by electronic and paper mail.

+

+ If the program does terminal interaction, make it output a short

+notice like this when it starts in an interactive mode:

+

+ <program> Copyright (C) <year> <name of author>

+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

+ This is free software, and you are welcome to redistribute it

+ under certain conditions; type `show c' for details.

+

+The hypothetical commands `show w' and `show c' should show the appropriate

+parts of the General Public License. Of course, your program's commands

+might be different; for a GUI interface, you would use an "about box".

+

+ You should also get your employer (if you work as a programmer) or school,

+if any, to sign a "copyright disclaimer" for the program, if necessary.

+For more information on this, and how to apply and follow the GNU GPL, see

+<http://www.gnu.org/licenses/>.

+

+ The GNU General Public License does not permit incorporating your program

+into proprietary programs. If your program is a subroutine library, you

+may consider it more useful to permit linking proprietary applications with

+the library. If this is what you want to do, use the GNU Lesser General

+Public License instead of this License. But first, please read

+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

+

+The software in this package is distributed under the GNU General Public

+License (with a special exception described below).

+

+A copy of GNU General Public License (GPL) is included in this distribution,

+in the file COPYING. [_$_]

+

+ Linking this library statically or dynamically with other modules is

+ making a combined work based on this library. Thus, the terms and

+ conditions of the GNU General Public License cover the whole

+ combination.

+ [_$_]

+ As a special exception, the copyright holders of this library give you

+ permission to link this library with independent modules to produce an

+ executable, regardless of the license terms of these independent

+ modules, and to copy and distribute the resulting executable under

+ terms of your choice, provided that you also meet, for each linked

+ independent module, the terms and conditions of the license of that

+ module. An independent module is a module which is not derived from

+ or based on this library. If you modify this library, you may extend

+ this exception to your version of the library, but you are not

+ obligated to do so. If you do not wish to do so, delete this

+ exception statement from your version.

+ (:license "GPL with linking exception")

+;;; Copyright (C) 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

+;;;

+;;; This program is free software: you can redistribute it and/or modify

+;;; it under the terms of the GNU General Public License as published by

+;;; the Free Software Foundation, either version 3 of the License, or

+;;; (at your option) any later version.

+;;;

+;;; This program is distributed in the hope that it will be useful,

+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of

+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+;;; GNU General Public License for more details.

+;;;

+;;; You should have received a copy of the GNU General Public License

+;;; along with this program. If not, see <http://www.gnu.org/licenses/>.

+;;;

+;;; As a special exception, the copyright holders of this library give you

+;;; permission to link this library with independent modules to produce an

+;;; executable, regardless of the license terms of these independent

+;;; modules, and to copy and distribute the resulting executable under

+;;; terms of your choice, provided that you also meet, for each linked

+;;; independent module, the terms and conditions of the license of that

+;;; module. An independent module is a module which is not derived from or

+;;; based on this library. If you modify this library, you may extend this

+;;; exception to your version of the library, but you are not obligated to

+;;; do so. If you do not wish to do so, delete this exception statement

+;;; from your version.

+