Sun Mar 13 20:40:35 CET 2011 Tobias Rautenkranz <tobias@rautenkranz.ch>
* Fix loading on OSX.
Thanks to Elliott Slaughter
hunk ./src/qt.core.lisp 36
- (: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.
hunk ./src/variant.lisp 79
-(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
hunk ./src/list.lisp 75
- list-pointer))))
+ list-pointer))))
hunk ./src/list.lisp 80
- (smoke:object-to-lisp
+ (object-to-lisp
hunk ./src/list.lisp 83
- (smoke:make-smoke-type ,(symbolicate '*smoke-module*)
- ,type-name)))))))
+ (make-smoke-type ,(symbolicate '*smoke-module*)
+ ,type-name)))))))
hunk ./src/vector.lisp 96
-(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
hunk ./src/application.lisp 60
- (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.
hunk ./src/variant.lisp 76
-(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)))
hunk ./src/variant.lisp 79
-(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.
hunk ./src/lib/CMakeLists.txt 14
-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
hunk ./test.lisp 2
+cmake ./ || exit 1
+make || exit 1
Thu Feb 4 10:22:53 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>
* Add qvector.cpp
addfile ./src/lib/qvector.cpp
hunk ./src/lib/qvector.cpp 1
+#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.
hunk ./src/lib/qlist.h 35
-CL_SMOKE_QT_EXPORT int \
-cl_smoke_list_ ## NAME ## _size(const void* list) \
-{ \
- return static_cast<const QList< TYPE >*>(list)->size(); \
-} \
-\
hunk ./src/list.lisp 3
+(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))))
+
hunk ./src/list.lisp 44
- (fun-names-let ((list-size "cl-smoke-list-" "-size")
- (list-free "cl-smoke-free-list-")
+ (fun-names-let ((list-free "cl-smoke-free-list-")
hunk ./src/list.lisp 56
- (defcfun ,(c-name (list-size type)) :int
- "Returns the size of LIST."
- (list :pointer))
hunk ./src/list.lisp 73
- (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)
hunk ./src/list.lisp 3
-(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.
hunk ./src/package.lisp 5
+ #: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.
hunk ./src/vector.lisp 36
-(defun qvector-aref (qvector index element-type)
+(defun qvector-elt (qvector index element-type)
hunk ./src/vector.lisp 47
- (setf (aref result i)
- (qvector-aref qvector i element-type)))))
+ (setf (elt result i)
+ (qvector-elt qvector i element-type)))))
hunk ./src/vector.lisp 67
- (pointer (aref elements i))
+ (pointer (elt elements i))
hunk ./src/vector.lisp 71
- (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.
hunk ./src/list.lisp 3
-(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)))))))))
hunk ./src/list.lisp 97
-;; FIXME it would be nice to have QList<QVariant> as fallback for any
-;; list we can not convert otherwise. e.g.: '("a" 1)
hunk ./src/list.lisp 99
-(define-qlist-wrapper ("QObject*" "QWidget*") qt:object "void")
hunk ./src/list.lisp 100
+
+(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.
hunk ./src/signal-slot/connect.lisp 118
- (cerror "Failed to connect ~A ~A to ~A ~A."
+ (cerror "Ignore"
+ "Failed to connect ~A ~A to ~A ~A."
hunk ./src/signal-slot/connect.lisp 125
- (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."
hunk ./src/signal-slot/connect.lisp 133
- (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
hunk ./cl-smoke.qt.core.asd 22
+ (:file "vector" :depends-on ("qt.core" "signal-slot"))
hunk ./src/event.lisp 7
- (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)))
hunk ./src/lib/CMakeLists.txt 11
-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)
+
hunk ./src/lib/qlist.cpp 15
-
hunk ./src/operator.lisp 9
- (if (typep object 'smoke::smoke-standard-object)
+ (if (typep object 'smoke-standard-object)
hunk ./src/operator.lisp 11
- (smoke::no-applicable-cxx-method ()
+ (no-applicable-cxx-method ()
hunk ./src/package.lisp 2
- (: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))
hunk ./src/signal-slot/connect.lisp 16
- (if (typep signal-arg 'smoke::smoke-type)
+ (if (typep signal-arg 'smoke-type)
hunk ./src/signal-slot/signal.lisp 71
- (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))
hunk ./src/signal-slot/signal.lisp 78
- (if (typep type 'smoke::smoke-type)
- (smoke::convert-argument argument type)
+ (if (typep type 'smoke-type)
+ (smoke:convert-argument argument type)
hunk ./src/signal-slot/signal.lisp 98
- (loop for i from 1 to (smoke::size stack)
+ (loop for i from 1 to (smoke:size stack)
hunk ./src/signal-slot/signal.lisp 102
- (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)))
hunk ./src/signal-slot/translate.lisp 4
- (let ((type (smoke::make-smoke-type smoke-module (subseq name start end))))
+ (let ((type (make-smoke-type smoke-module (subseq name start end))))
hunk ./src/signal-slot/translate.lisp 19
- (smoke-module (smoke::smoke (class-of object))))
+ (smoke-module (smoke (class-of object))))
hunk ./src/signal-slot/translate.lisp 37
- (smoke::smoke-type
+ (smoke-type
hunk ./src/signal-slot/translate.lisp 47
- (unless (smoke::virtual-destructor-p (class-of object))
- (smoke::remove-object (pointer object)))
+ (unless (virtual-destructor-p (class-of object))
+ (remove-object (pointer object)))
hunk ./src/signal-slot/translate.lisp 53
- (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)
hunk ./src/signal-slot/translate.lisp 60
- (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*)))
hunk ./src/signal-slot/translate.lisp 94
- (smoke::smoke-standard-object
- (if (smoke::pointer-p smoke-type)
+ (smoke-standard-object
+ (if (pointer-p smoke-type)
hunk ./src/signal-slot/translate.lisp 97
- (let ((type (qt:meta-type.type (smoke::name smoke-type))))
+ (let ((type (qt:meta-type.type (name smoke-type))))
hunk ./src/signal-slot/translate.lisp 101
- (smoke::name smoke-type))
+ (name smoke-type))
hunk ./src/variant.lisp 106
- (let* ((lisp-object (cl-smoke-lisp-object-value (smoke::pointer variant)))
+ (let* ((lisp-object (cl-smoke-lisp-object-value (pointer variant)))
addfile ./src/vector.lisp
hunk ./src/vector.lisp 1
+;; 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
move ./qt.asd ./cl-smoke.qt.core.asd
move ./src/lib/lisp-object.cpp ./src/lib/lisp_object.cpp
move ./src/lib/lisp-object.h ./src/lib/lisp_object.h
move ./src/lib/qt-smoke.cpp ./src/lib/qt_smoke.cpp
move ./src/qt.lisp ./src/qt.core.lisp
hunk ./cl-smoke.qt.core.asd 1
-(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
hunk ./cl-smoke.qt.core.asd 6
- :description "Smoke Qt bindings."
- :depends-on (:smoke :smoke :cffi :alexandria)
+ :description "Smoke Qt core bindings."
+ :depends-on (:cl-smoke.smoke :cffi :alexandria)
hunk ./cl-smoke.qt.core.asd 14
- (: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"))
hunk ./cl-smoke.qt.core.asd 35
- (: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"))
hunk ./cl-smoke.qt.core.asd 39
-(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))
hunk ./examples/hello-world.lisp 1
-(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)))))
rmfile ./examples/hello-world.lisp
hunk ./examples/package.lisp 1
-(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))
rmfile ./examples/package.lisp
rmdir ./examples
hunk ./cl-smoke.qt.core.asd 39
-(defmethod operation-done-p ((o test-op) (c (eql (find-system :cl-smoke.qt.core))))
- nil)
-
hunk ./src/application.lisp 4
-(defvar *widgets* nil)
hunk ./src/application.lisp 20
- (application 'qt:application)
+ (application 'qt:core-application)
hunk ./src/application.lisp 51
- (app (make-instance 'qt:application :args (list argc argv))))
+ (app (make-instance application :args (list argc argv))))
hunk ./src/application.lisp 58
+(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*)))
+
hunk ./src/application.lisp 69
- (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)))
hunk ./src/application.lisp 79
-(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))
-
hunk ./src/application.lisp 90
- (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))))))
replace ./src/application.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/event.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/i18n.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/lib/CMakeLists.txt 11
-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
hunk ./src/lib/CMakeLists.txt 19
-install(TARGETS qt-smoke-extra
- LIBRARY DESTINATION lib)
+install(TARGETS clsmokeqtcore LIBRARY DESTINATION lib)
hunk ./src/lib/lisp_object.cpp 1
-#include "lisp-object.h"
+#include "lisp_object.h"
+
+#include "cl_smoke_qt.h"
hunk ./src/lib/lisp_object.cpp 7
+#include <QVariant>
hunk ./src/lib/lisp_object.cpp 112
-int
-qt_smoke_setup_lisp_object(void* destruct)
+CL_SMOKE_QT_EXPORT int
+cl_smoke_setup_lisp_object(void* destruct)
hunk ./src/lib/lisp_object.cpp 127
-unsigned int
-qt_smoke_lisp_object_id(const void* object)
+CL_SMOKE_QT_EXPORT unsigned int
+cl_smoke_lisp_object_id(const void* object)
hunk ./src/lib/lisp_object.cpp 140
-int
-qt_smoke_lisp_object_is_set(const void* object)
+CL_SMOKE_QT_EXPORT int
+cl_smoke_lisp_object_is_set(const void* object)
hunk ./src/lib/lisp_object.cpp 152
-void*
-qt_smoke_make_lisp_object(unsigned int id)
+CL_SMOKE_QT_EXPORT void*
+cl_smoke_make_lisp_object(unsigned int id)
hunk ./src/lib/lisp_object.cpp 162
-void*
-qt_smoke_free_lisp_object(void* object)
+CL_SMOKE_QT_EXPORT void*
+cl_smoke_free_lisp_object(void* object)
hunk ./src/lib/lisp_object.cpp 168
-#include <QVariant>
hunk ./src/lib/lisp_object.cpp 174
-void*
-qt_smoke_lisp_object_value(const void* variant)
+CL_SMOKE_QT_EXPORT void*
+cl_smoke_lisp_object_value(const void* variant)
hunk ./src/lib/lisp_object.h 4
+#include "cl_smoke_qt.h"
+
hunk ./src/lib/lisp_object.h 11
-#include "cl_smoke_qt.h"
-
hunk ./src/lib/lisp_object.h 14
- qt_smoke_setup_lisp_object(void* destruct);
+ cl_smoke_setup_lisp_object(void* destruct);
hunk ./src/lib/lisp_object.h 17
- qt_smoke_lisp_object_id(const void* object);
+ cl_smoke_lisp_object_id(const void* object);
hunk ./src/lib/lisp_object.h 20
- qt_smoke_lisp_object_is_set(const void* object);
+ cl_smoke_lisp_object_is_set(const void* object);
hunk ./src/lib/lisp_object.h 23
- qt_smoke_make_lisp_object(unsigned int id);
+ cl_smoke_make_lisp_object(unsigned int id);
hunk ./src/lib/lisp_object.h 26
- qt_smoke_free_lisp_object(void* object);
+ cl_smoke_free_lisp_object(void* object);
hunk ./src/lib/lisp_object.h 29
- qt_smoke_lisp_object_value(const void* variant);
+ cl_smoke_lisp_object_value(const void* variant);
hunk ./src/lib/lisp_object.h 58
- ::qt_smoke_setup_lisp_object(void* destruct);
+ ::cl_smoke_setup_lisp_object(void* destruct);
hunk ./src/lib/qlist.h 4
-#include <QList>
hunk ./src/lib/qlist.h 6
+#include <QList>
+
hunk ./src/lib/qlist.h 36
-qt_smoke_list_ ## NAME ## _size(const void* list) \
+cl_smoke_list_ ## NAME ## _size(const void* list) \
hunk ./src/lib/qlist.h 42
-qt_smoke_free_list_ ## NAME (void* list) \
+cl_smoke_free_list_ ## NAME (void* list) \
hunk ./src/lib/qlist.h 48
-qt_smoke_make_list_ ## NAME () \
+cl_smoke_make_list_ ## NAME () \
hunk ./src/lib/qlist.h 59
-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \
+cl_smoke_list_ ## NAME ## _at(const void* list, int index) \
hunk ./src/lib/qlist.h 66
-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \
+cl_smoke_list_ ## NAME ## _append(void* list, void* data) \
hunk ./src/lib/qlist.h 77
-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \
+cl_smoke_list_ ## NAME ## _at(const void* list, int index) \
hunk ./src/lib/qlist.h 84
-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \
+cl_smoke_list_ ## NAME ## _append(void* list, void* data) \
hunk ./src/lib/qstring.cpp 2
-#include <QtDebug>
hunk ./src/lib/qstring.cpp 16
-qt_smoke_qstring_to_byte_array(const void* qstring)
+cl_smoke_qstring_to_byte_array(const void* qstring)
hunk ./src/lib/qstring.cpp 18
- Q_ASSERT(qstring);
hunk ./src/lib/qstring.cpp 27
-qt_smoke_free_qstring(void* qstring)
+cl_smoke_free_qstring(void* qstring)
hunk ./src/lib/qstring.cpp 39
-qt_smoke_string_to_qstring(const char* data, int length)
+cl_smoke_string_to_qstring(const char* data, int length)
hunk ./src/lib/qstringlist.cpp 1
+#include "cl_smoke_qt.h"
+
hunk ./src/lib/qstringlist.cpp 5
-#include <cstring>
-
-#include "cl_smoke_qt.h"
hunk ./src/lib/qstringlist.cpp 17
-qt_smoke_string_list_size(const void* string_list)
+cl_smoke_string_list_size(const void* string_list)
hunk ./src/lib/qstringlist.cpp 30
-qt_smoke_string_list_at(const void* string_list, int index)
+cl_smoke_string_list_at(const void* string_list, int index)
hunk ./src/lib/qstringlist.cpp 44
-qt_smoke_free_string_list(void* string_list)
+cl_smoke_free_string_list(void* string_list)
hunk ./src/lib/qstringlist.cpp 54
-qt_smoke_make_string_list()
+cl_smoke_make_string_list()
hunk ./src/lib/qstringlist.cpp 65
-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)
hunk ./src/lib/qt_smoke.cpp 1
+#include "cl_smoke_qt.h"
+
hunk ./src/lib/qt_smoke.cpp 7
-#include "cl_smoke_qt.h"
-
hunk ./src/lib/qt_smoke.cpp 28
-qt_smoke_register_event_notify(void* callback)
+cl_smoke_register_event_notify(void* callback)
hunk ./src/lib/qt_smoke.cpp 46
-qt_smoke_meta_object(void* object)
+cl_smoke_meta_object(void* object)
hunk ./src/lisp-object.lisp 17
-(defcfun qt-smoke-setup-lisp-object :int
+(defcfun cl-smoke-setup-lisp-object :int
hunk ./src/lisp-object.lisp 20
-(defcfun qt-smoke-lisp-object-id :unsigned-int
+(defcfun cl-smoke-lisp-object-id :unsigned-int
hunk ./src/lisp-object.lisp 23
-(defcfun qt-smoke-lisp-object-is-set :int
+(defcfun cl-smoke-lisp-object-is-set :int
hunk ./src/lisp-object.lisp 26
-(defcfun qt-smoke-make-lisp-object :pointer
+(defcfun cl-smoke-make-lisp-object :pointer
hunk ./src/lisp-object.lisp 29
-(defcfun qt-smoke-free-lisp-object :void
+(defcfun cl-smoke-free-lisp-object :void
hunk ./src/lisp-object.lisp 40
- (qt-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))
+ (cl-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))
hunk ./src/lisp-object.lisp 50
- (qt-smoke-make-lisp-object id)))
+ (cl-smoke-make-lisp-object id)))
hunk ./src/lisp-object.lisp 54
- (qt-smoke-free-lisp-object pointer))
+ (cl-smoke-free-lisp-object pointer))
hunk ./src/lisp-object.lisp 63
- (gethash (qt-smoke-lisp-object-id pointer)
+ (gethash (cl-smoke-lisp-object-id pointer)
replace ./src/lisp-object.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/list.lisp 8
- (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_size") :int
+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_size") :int
hunk ./src/list.lisp 11
- (defcfun ,(concatenate 'string "qt_smoke_free_list_" c-name) :void
+ (defcfun ,(concatenate 'string "cl_smoke_free_list_" c-name) :void
hunk ./src/list.lisp 14
- (defcfun ,(concatenate 'string "qt_smoke_make_list_" c-name) :pointer
+ (defcfun ,(concatenate 'string "cl_smoke_make_list_" c-name) :pointer
hunk ./src/list.lisp 16
- (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_at") :pointer
+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_at") :pointer
hunk ./src/list.lisp 20
- (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_append") :pointer
+ (defcfun ,(concatenate 'string "cl_smoke_list_" c-name "_append") :pointer
hunk ./src/list.lisp 27
- (let ((vector (make-array (,(symbolicate 'qt-smoke-list-
+ (let ((vector (make-array (,(symbolicate 'cl-smoke-list-
hunk ./src/list.lisp 35
- (,(symbolicate 'qt-smoke-list-
+ (,(symbolicate 'cl-smoke-list-
hunk ./src/list.lisp 45
- ,(symbolicate 'qt-smoke-free-list- type)))
+ ,(symbolicate 'cl-smoke-free-list- type)))
hunk ./src/list.lisp 48
- (let ((qlist (,(symbolicate 'qt-smoke-make-list- type))))
+ (let ((qlist (,(symbolicate 'cl-smoke-make-list- type))))
hunk ./src/list.lisp 50
- (,(symbolicate 'qt-smoke-list- type '-append)
+ (,(symbolicate 'cl-smoke-list- type '-append)
hunk ./src/list.lisp 54
- (function ,(symbolicate 'qt-smoke-free-list- type)))))
+ (function ,(symbolicate 'cl-smoke-free-list- type)))))
replace ./src/list.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/msg-handler.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/object.lisp 9
-(defcfun qt-smoke-meta-object :pointer (object :pointer))
+(defcfun cl-smoke-meta-object :pointer (object :pointer))
hunk ./src/object.lisp 12
- :pointer (qt-smoke-meta-object (pointer object))))
+ :pointer (cl-smoke-meta-object (pointer object))))
hunk ./src/object.lisp 229
- (cffi:defcfun qt-smoke-register-event-notify :boolean
+ (cffi:defcfun cl-smoke-register-event-notify :boolean
hunk ./src/object.lisp 233
- (let ((ret (qt-smoke-register-event-notify (cffi:callback event-notify))))
+ (let ((ret (cl-smoke-register-event-notify (cffi:callback event-notify))))
replace ./src/object.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/operator.lisp 2
-(declaim (optimize (debug 3)))
replace ./src/operator.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/ownership.lisp 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
-
replace ./src/ownership.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/package.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/painter.lisp 1
-(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))))
rmfile ./src/painter.lisp
replace ./src/properties.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/qstring.lisp 3
-(defcfun qt-smoke-string-to-qstring :pointer
+(defcfun cl-smoke-string-to-qstring :pointer
hunk ./src/qstring.lisp 7
-(defcfun qt-smoke-free-qstring :void
+(defcfun cl-smoke-free-qstring :void
hunk ./src/qstring.lisp 10
-(defcfun qt-smoke-qstring-to-byte-array :pointer
+(defcfun cl-smoke-qstring-to-byte-array :pointer
hunk ./src/qstring.lisp 37
- :pointer (qt-smoke-qstring-to-byte-array qstring))))
+ :pointer (cl-smoke-qstring-to-byte-array qstring))))
hunk ./src/qstring.lisp 40
- from-qstring qt-smoke-free-qstring)
+ from-qstring cl-smoke-free-qstring)
hunk ./src/qstring.lisp 45
- (qt-smoke-string-to-qstring data length))
- #'qt-smoke-free-qstring))
+ (cl-smoke-string-to-qstring data length))
+ #'cl-smoke-free-qstring))
replace ./src/qstring.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/qt.core.lisp 1
-;;; Copyright (C) 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>
+;;; Copyright (C) 2009, 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>
hunk ./src/qt.core.lisp 30
-(define-smoke-module :cl-smoke.qt libsmokeqt
- (*qt-smoke* "qt_Smoke")
- (init-qt-smoke "init_qt_Smoke"))
-
hunk ./src/qt.core.lisp 31
- (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))
replace ./src/qt.core.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/signal-slot/connect.lisp 141
- (method-arguments-type
- (cxx:meta-object (qsender qt-signal))
- signal-id))))
+ (method-arguments-type (qsender qt-signal)
+ signal-id))))
hunk ./src/signal-slot/connect.lisp 162
- (check-argument-types (method-arguments-type (cxx:meta-object
- (qsender qt-signal))
+ (check-argument-types (method-arguments-type (qsender qt-signal)
hunk ./src/signal-slot/connect.lisp 166
- (method-arguments-type (cxx:meta-object (qsender qt-signal))
- signal-id)))
+ (method-arguments-type (qsender qt-signal) signal-id)))
hunk ./src/signal-slot/connect.lisp 179
- (method-arguments-type (cxx:meta-object
- (receiver slot))
+ (method-arguments-type (receiver slot)
hunk ./src/signal-slot/connect.lisp 182
- (method-arguments-type (cxx:meta-object (receiver slot))
- slot-id)))
+ (method-arguments-type (receiver slot) slot-id)))
replace ./src/signal-slot/connect.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/signal-slot/signal-slot.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/signal-slot/signal.lisp 72
- #'qt-smoke-free-lisp-object))
+ #'cl-smoke-free-lisp-object))
hunk ./src/signal-slot/signal.lisp 82
- "The argument ~S is not of type ~S.")
+ "The argument ~S is not of type ~S."
+ argument type)
replace ./src/signal-slot/signal.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/signal-slot/slot.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/signal-slot/translate.lisp 3
-(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))
hunk ./src/signal-slot/translate.lisp 11
-(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)))
hunk ./src/signal-slot/translate.lisp 18
- (last-pos (length arguments)))
+ (last-pos (length arguments))
+ (smoke-module (smoke::smoke (class-of object))))
hunk ./src/signal-slot/translate.lisp 23
- (push (find-type arguments (1+ pos) last-pos) argument-types)
+ (push (find-type smoke-module arguments (1+ pos) last-pos) argument-types)
hunk ./src/signal-slot/translate.lisp 26
- (push (find-type arguments 0 last-pos) argument-types))))
+ (push (find-type smoke-module arguments 0 last-pos) argument-types))))
replace ./src/signal-slot/translate.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/string-list.lisp 3
-(defcfun qt-smoke-string-list-size :int
+(defcfun cl-smoke-string-list-size :int
hunk ./src/string-list.lisp 6
-(defcfun qt-smoke-string-list-at :pointer
+(defcfun cl-smoke-string-list-at :pointer
hunk ./src/string-list.lisp 10
-(defcfun qt-smoke-free-string-list :void
+(defcfun cl-smoke-free-string-list :void
hunk ./src/string-list.lisp 13
-(defcfun qt-smoke-make-string-list :pointer)
+(defcfun cl-smoke-make-string-list :pointer)
hunk ./src/string-list.lisp 15
-(defcfun qt-smoke-string-list-append :void
+(defcfun cl-smoke-string-list-append :void
hunk ./src/string-list.lisp 21
- (let ((vector (make-array (qt-smoke-string-list-size string-list)
+ (let ((vector (make-array (cl-smoke-string-list-size string-list)
hunk ./src/string-list.lisp 27
- :pointer (qt-smoke-string-list-at
+ :pointer (cl-smoke-string-list-at
hunk ./src/string-list.lisp 31
- from-string-list qt-smoke-free-string-list)
+ from-string-list cl-smoke-free-string-list)
hunk ./src/string-list.lisp 34
- (let ((string-list (qt-smoke-make-string-list)))
+ (let ((string-list (cl-smoke-make-string-list)))
hunk ./src/string-list.lisp 38
- (qt-smoke-string-list-append string-list data length)))
+ (cl-smoke-string-list-append string-list data length)))
hunk ./src/string-list.lisp 41
- string-list #'qt-smoke-free-string-list)))
+ string-list #'cl-smoke-free-string-list)))
replace ./src/string-list.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
replace ./src/timer.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./src/variant.lisp 69
-(defcfun qt-smoke-lisp-object-value :pointer
+(defcfun cl-smoke-lisp-object-value :pointer
hunk ./src/variant.lisp 106
- (let* ((lisp-object (qt-smoke-lisp-object-value (smoke::pointer variant)))
+ (let* ((lisp-object (cl-smoke-lisp-object-value (smoke::pointer variant)))
replace ./src/variant.lisp [A-Za-z_0-9\-\.] cl-smoke.qt-impl cl-smoke.qt.core
hunk ./test.lisp 6
-(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)
changepref test
sh test.lisp