Sun Mar 13 20:40:35 CET 2011 Tobias Rautenkranz * Fix loading on OSX. Thanks to Elliott Slaughter Sat Apr 3 14:34:21 CEST 2010 Tobias Rautenkranz * Account for possible lisp-object metatype id change when loading an image. Sat Feb 20 22:04:46 CET 2010 Tobias Rautenkranz * cleanup Sat Feb 20 22:02:38 CET 2010 Tobias Rautenkranz * Make qt:application cleanup more stable Sat Feb 20 22:00:30 CET 2010 Tobias Rautenkranz * support all from qt:variant conversions. Mon Feb 15 16:33:05 CET 2010 Tobias Rautenkranz * Build a shared library not a module. Fixes a build error on OS X. Thu Feb 4 16:06:38 CET 2010 Tobias Rautenkranz * Test building libclsmokeqtcore Thu Feb 4 10:22:53 CET 2010 Tobias Rautenkranz * Add qvector.cpp Sat Jan 30 16:40:15 CET 2010 Tobias Rautenkranz * Get the QList size using Lisp instead of an external C function. Tue Jan 26 17:19:51 CET 2010 Tobias Rautenkranz * Fix define-qlist-wrapper usage for other modules. (i.e. qt.gui) Mon Jan 25 20:07:22 CET 2010 Tobias Rautenkranz * Export delete-app since other modules (qt.gui) might like to add methods to it. Mon Jan 25 19:53:36 CET 2010 Tobias Rautenkranz * Use ELT instead of AREF for sequences in vector translations. Mon Jan 25 19:45:04 CET 2010 Tobias Rautenkranz * Allow other modules to define QList conversions. Mon Jan 25 19:43:56 CET 2010 Tobias Rautenkranz * Fix error reporting on signal-slot connection failure. Sat Jan 23 23:17:35 CET 2010 Tobias Rautenkranz * QVector translation Sun Jan 10 09:52:09 CET 2010 Tobias Rautenkranz * Split up in qt.core. - Fix qt:with-core-app - cleanup name prefixes Sun Dec 13 13:44:37 CET 2009 Tobias Rautenkranz * Support ASDF instead of Mudballs. Sun Dec 13 11:50:24 CET 2009 Tobias Rautenkranz * Install msg-handler also when starting from an image Sun Dec 13 11:49:35 CET 2009 Tobias Rautenkranz * Convert C++ exceptions to a qFatal Wed Sep 9 15:18:08 CEST 2009 Tobias Rautenkranz * Cleanup msg-handler Wed Sep 2 14:00:35 CEST 2009 Tobias Rautenkranz * Better Lisp vector to QList<*> conversion. Thu Aug 27 10:37:36 CEST 2009 Tobias Rautenkranz * Update to the new smokegenerator. Sun Aug 2 13:29:13 CEST 2009 Tobias Rautenkranz * Fix double space when printing a qt:object. Sun Aug 2 13:29:02 CEST 2009 Tobias Rautenkranz * qt:event upcasting cleanup Sun Aug 2 13:15:21 CEST 2009 Tobias Rautenkranz * Support ownership transfer to non smoke wrapped QObjects & cleanup C++ to Lisp translation. Mon Jul 27 21:39:43 CEST 2009 Tobias Rautenkranz * Fix ownership transfer for lambda slot to no Smoke object. Fri Jul 24 15:40:52 CEST 2009 Tobias Rautenkranz * Remove unnecessary #'cxx:data calls. Thu Jul 23 00:21:01 CEST 2009 Tobias Rautenkranz * support packages for symbols as property names. Wed Jul 8 22:55:24 CEST 2009 Tobias Rautenkranz * The smoke call stack is now a struct -> adapt. Fri Jul 3 12:14:09 CEST 2009 Tobias Rautenkranz * Fix nested #'qt:exec Thu Jul 2 21:37:42 CEST 2009 Tobias Rautenkranz * Fix potential lisp-object ID generation overflow for excessive lisp-object creation. Thu Jul 2 21:12:45 CEST 2009 Tobias Rautenkranz * move emit slot code to new function ACTIVATE & image startup fix for STATIC-META-OBJECT Wed Jul 1 12:58:06 CEST 2009 Tobias Rautenkranz * Break API compatibility for qt:with-app and qt:exec & spellcheck diff -rN -u old-qt.core/TODO new-qt.core/TODO --- old-qt.core/TODO 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/TODO 1970-01-01 01:00:00.000000000 +0100 @@ -1 +0,0 @@ -* QApplication and KCmdLineArgs.init call exit() on e.g. "--help" diff -rN -u old-qt.core/cl-smoke.qt.core.asd new-qt.core/cl-smoke.qt.core.asd --- old-qt.core/cl-smoke.qt.core.asd 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/cl-smoke.qt.core.asd 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,42 @@ +(defsystem :cl-smoke.qt.core + :name :cl-smoke.qt.core + :version (0 0 1) + :author "Tobias Rautenkranz" + :license "GPL with linking exception" + :description "Smoke Qt core bindings." + :depends-on (:cl-smoke.smoke :cffi :alexandria) + + :components + ((:module "src" + :components + ((:file "package") + (:module "lib" :depends-on ("package")) + (:file "qt.core" :depends-on ("package" "lib")) + (:file "ownership" :depends-on ("qt.core")) + (:file "event" :depends-on ("qt.core")) + (:file "object" :depends-on ("qt.core" "signal-slot" "qstring" "event")) + (:file "operator" :depends-on ("qt.core" "object")) + (:file "application" :depends-on ("qt.core" "properties")) + (:file "qstring" :depends-on ("qt.core")) + (:file "list" :depends-on ("qt.core")) + (:file "vector" :depends-on ("qt.core" "signal-slot")) + (:file "msg-handler" :depends-on ("lib" "qt.core")) + (:file "timer" :depends-on ("qt.core")) + (:file "i18n" :depends-on ("qt.core")) + (:file "lisp-object" :depends-on ("qt.core" "lib")) + (:module "signal-slot" + :serial t + :depends-on ("lisp-object") + :components + ((:file "signal-slot") + (:file "translate" :depends-on ("signal-slot")) + (:file "signal" :depends-on ("translate")) + (:file "slot" :depends-on ("signal")) + (:file "connect" :depends-on ("slot")))) + (:file "string-list" :depends-on ("qt.core" "lib" "qstring")) + (:file "variant" :depends-on ("qt.core" "qstring" "lisp-object")) + (:file "properties" :depends-on ("variant")))))) + +(defmethod perform ((operation test-op) (c (eql (find-system :cl-smoke.qt.core)))) + (operate 'asdf:load-op :cl-smoke.qt.tests) + (operate 'asdf:test-op :cl-smoke.qt.tests)) diff -rN -u old-qt.core/examples/hello-world.lisp new-qt.core/examples/hello-world.lisp --- old-qt.core/examples/hello-world.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/examples/hello-world.lisp 1970-01-01 01:00:00.000000000 +0100 @@ -1,63 +0,0 @@ -(in-package :qt-examples) -(declaim (optimize (debug 3))) - -(defun hello-world () - "Hello world" - (qt:with-app - (let ((widget (make-instance 'qt:push-button :args '("Hello world")))) - (cxx:show widget) - (qt:exec)))) - - -(defun hello-world-quit () - "Quit on push-button click" - (qt:with-app - (let ((quit (make-instance 'qt:push-button :args '("Quit")))) - (cxx:resize quit 75 30) - (cxx:set-font quit (make-instance 'qt:font :args (list "Times" - 18 - qt:font.+bold+))) - - (qt:object.connect quit (qt:qsignal "clicked()") - (qt:app) (qt:qslot "quit()")) - (cxx:show quit) - (qt:exec)))) - -(defun hello-world-gc () - "GC on push-button click" - (qt:with-app - (let ((gc (make-instance 'qt:widget))) - (let ((layout (make-instance 'qt:vbox-layout)) - (button (make-instance 'qt:push-button :args '("GC")))) - (trivial-garbage:gc :full t) - (cxx:add-widget layout button) - (trivial-garbage:gc :full t) - (cxx:set-layout gc layout) - (trivial-garbage:gc :full t) - (qt:connect-function button "clicked()" - #'(lambda () - (format t "GC-ing~%") - (trivial-garbage:gc :full t)))) - (trivial-garbage:gc :full t) - (cxx:show gc) - (trivial-garbage:gc :full t) - (qt:exec)))) - -;; You need to run cmake & make to generate the .po and .qm files -(defun i18n-hello-world () - "i18n hello world" - (qt:with-app - (qt:with-translator "hello-world" - (let ((widget (make-instance 'qt:label))) - (setf (qt:property widget 'window-title) - (qt:tr "Lisp Qt Example" "hello-world")) - (cxx:set-text widget - (format nil (qt:tr "

Hello world

- -You are running ~A version ~A on a ~A ~A") - (lisp-implementation-type) - (lisp-implementation-version) - (software-type) - (software-version))) - (cxx:show widget) - (qt:exec))))) diff -rN -u old-qt.core/examples/package.lisp new-qt.core/examples/package.lisp --- old-qt.core/examples/package.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/examples/package.lisp 1970-01-01 01:00:00.000000000 +0100 @@ -1,15 +0,0 @@ -(defpackage #:qt-examples - (:use #:cl) - (:export #:hello-world - #:i18n-hello-world - #:hello-world-quit - #:hello-world-gc - - #:class-browser - - #:tick-tack-toe - #:repl - - #:launcher - - #:load-ui-file)) diff -rN -u old-qt.core/qt.mbd new-qt.core/qt.mbd --- old-qt.core/qt.mbd 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/qt.mbd 1970-01-01 01:00:00.000000000 +0100 @@ -1,71 +0,0 @@ -;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- - -;;; SYSDEF.CMAKE -(defpackage :sysdef.cmake - (:use :cl :sysdef) - (:export :cmake-file :cmake-library)) - -(in-package :sysdef.cmake) -(defclass sysdef.cmake:cmake-file (source-file) - () - (:default-initargs :type "txt")) - -(defclass sysdef.cmake:cmake-library (component) - ((package :initarg :package))) -;;; end SYSDEF.CMAKE - -(in-package :sysdef-user) -(eval-when (:compile-toplevel :load-toplevel :execute) - (use-package :sysdef.cmake)) - -(define-system :qt () - (:version 0 0 1) - (:documentation "Smoke Qt bindings.") - (:keywords "GUI" "Qt") - (:author "Tobias Rautenkranz") - (:license "GPL with linking exception") - (:components - ("CMakeLists" sysdef.cmake:cmake-file) - ("src" module - (:needs "CMakeLists") - (:components - ("CMakeLists.txt" static-file) - "package" - ("lib" module - (:needs "package") - (:components - ("libqt-smoke-extra" sysdef.cmake:cmake-library (:package :cl-smoke.qt-impl)) - - ("CMakeLists.txt" static-file) - ("qt-smoke.cpp" static-file) - ("lisp-object.h" static-file) - ("lisp-object.cpp" static-file) - ("qstring.cpp" static-file) - ("qstringlist.cpp" static-file))) - - ("qt" (:needs "package" "lib")) - ("ownership" (:needs "qt")) - ("object" (:needs "qt")) - ("operator" (:needs "qt" "object")) - ("application" (:needs "qt")) - ("qstring" (:needs "qt")) - ("list" (:needs "qt")) - ("msg-handler" (:needs "lib")) - ("painter" (:needs "qt")) - ("timer" (:needs "qt")) - ("i18n" (:needs "qt")) - ("lisp-object" (:needs "qt" "lib")) - ("signal-slot" module - (:needs "lisp-object") - (:serial t) - (:components - "signal-slot" - "translate" - "signal" - "slot" - "connect")) - ("string-list" (:needs "qt" "lib" "qstring")) - ("variant" (:needs "qt" "qstring" "lisp-object")) - ("properties" (:needs "variant"))))) - (:uses-macros-from :smoke) - (:needs :smoke :sysdef.cmake :cffi :alexandria)) diff -rN -u old-qt.core/src/application.lisp new-qt.core/src/application.lisp --- old-qt.core/src/application.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/application.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,9 +1,6 @@ -(in-package :cl-smoke.qt-impl) - -(declaim (optimize (debug 3))) +(in-package :cl-smoke.qt.core) (defvar *app*) -(defvar *widgets* nil) (defvar qt:*exec-p* t "Run exec if true and not otherwise.") @@ -19,63 +16,58 @@ "Returns t when the APPLICATION object exists and nil otherwise." (boundp '*app*)) - -(let ((argv (null-pointer)) - (argc (null-pointer))) - (declare (cffi:foreign-pointer argv argc)) - (defun ensure-app (&optional - (application 'qt:application) - (args #+sbcl sb-ext:*posix-argv* - #+ccl ccl:*command-line-argument-list* - #-(or sbcl ccl) (list (lisp-implementation-type)))) - "Constructs the global application object, when there is none, +(defun ensure-app (&optional + (application 'qt:core-application) + (args #+sbcl sb-ext:*posix-argv* + #+ccl ccl:*command-line-argument-list* + #-(or sbcl ccl) (list (lisp-implementation-type)))) + "Constructs the global application object, when there is none, with the command line arguments ARGS. Returns the application object a first value and true when a new application was created and false otherwise." - (assert (not (null args)) - (args) - "No program name supplied.") - (if (qt:app-p) - (progn - (assert (typep (qt:app) (find-class application)) - (application) - "The existing application object ~A is + (assert (not (null args)) + (args) + "No program name supplied.") + (if (qt:app-p) + (progn + (assert (typep (qt:app) (find-class application)) + (application) + "The existing application object ~A is not of type ~A." (qt:app) (find-class application)) - (values (qt:app) nil)) - (progn - (when (not (null-pointer-p (smoke::pointer - (qt:core-application.instance)))) - (cerror "Delete the active application." "Active application not created by QT:WITH-APP.") - (smoke::delete-pointer (smoke::pointer (qt:core-application.instance)) - (find-class 'qt:core-application))) - (foreign-free argv) - (foreign-free argc) - - (setf argc (foreign-alloc :int :initial-element (length args))) - (setf argv (foreign-alloc :string :initial-contents args)) - (let ((app (make-instance 'qt:application :args (list argc argv)))) - (tg:cancel-finalization app) - (values app t))))) - (defun kill-app () - (when (typep (qt:app) 'qt:application) - (qt:application.close-all-windows) - ;; widgets are only valid as long, as an application object exists. - ;; QApplication::~QApplication() deletes all widgets in - ;; QApplication::allWidgets(). - ;; - ;; see: qt4/src/gui/kernel/qapplication.cpp - (loop for widget across (qt:application.all-widgets) do - (trivial-garbage:cancel-finalization widget))) - (cxx:quit (qt:app)) - (setf *widgets* nil) - ;; Call the destructer; -> destructed callback is called, - ;; (~QApplication() is virtual) which takes care of cleanup - ;; on the Lisp side. - (smoke::delete-pointer (smoke::pointer (qt:app)) (class-of (qt:app))) - (setf (slot-value (qt:app) 'pointer) (null-pointer)) + (values (qt:app) nil)) + (progn + (when (not (null-pointer-p (smoke::pointer + (qt:core-application.instance)))) + (cerror (format nil "Delete the active application ~A." + (qt:core-application.instance)) + "Active application not created by QT:WITH-APP.") + (smoke::delete-pointer (smoke::pointer (qt:core-application.instance)) + (find-class 'qt:core-application))) + (let* ((argc (smoke:make-auto-pointer + (foreign-alloc :int :initial-element (length args)))) + (argv (smoke:make-auto-pointer + (foreign-alloc :string :initial-contents args))) + (app (make-instance application :args (list argc argv)))) + ;; argc and argv must remain valid during the lifetime of APP. + (setf (qt:property app 'cmdline-args) + (qt:make-lisp-variant (list argc argv))) + (tg:cancel-finalization app) + (values app t))))) + +(defgeneric delete-app (application) + (:method (application) + (unless (null-pointer-p (smoke:pointer application)) + (cxx:quit application) + ;; Call the destructor; -> destructed callback is called, + ;; (~QApplication() is virtual) which takes care of cleanup on the + ;; Lisp side. + (smoke::delete-pointer (smoke:pointer application) (class-of application))) (makunbound '*app*))) +(defun kill-app () + (delete-app (qt:app))) + (defmacro with-application ((ensure-app remove-app) &body body) (let ((cleanup-p (gensym))) `(multiple-value-bind (*app* ,cleanup-p) ,ensure-app @@ -84,31 +76,21 @@ (when ,cleanup-p ,remove-app))))) -(defmacro qt:with-app (&body body) - "Ensures that a APPLICATION instance exists, -evaluates BODY and executes the APPLICATION instance after BODY. -The instance can be accessed with: -APP. - -Can be nested. - -When a APPLICATION was created, it will be deleted when returning -from BODY." - `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:application) (kill-app)) - ,@body)) - -(defmacro qt:with-core-app (&body body) - `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:core-application) (kill-app)) - ,@body)) +(defmacro qt:with-core-app (options &body body) + (assert (null options) + (options) + "Currently no options can be passed to QT:WITH-CORE-APP.") + `(with-application ((cl-smoke.qt.core::ensure-app 'qt:core-application) (kill-app)) + ,@body)) - -(defun qt:exec (&rest widgets) - "Executes APP." - (setf *widgets* (append widgets *widgets*)) +(defun qt:exec () + "Executes APP. When QT:*EXEC-P* is false it returns immediately +and transfers the ownership of the top-level widgets to the qt:application +instance." (when qt:*exec-p* (restart-bind ((qt::abort-app #'(lambda () - (cxx:quit (qt:app)) - (invoke-restart (find-restart 'continue))) + (cxx:quit (qt:app)) + (invoke-restart (find-restart 'continue))) :report-function #'(lambda (stream) (format stream "Return from the application event loop.")) @@ -117,4 +99,5 @@ (declare (ignore condition)) (and (qt:app-p) (find-restart 'continue))))) - (cxx:exec (qt:app))))) + (let ((qt:*exec-p* nil)) + (cxx:exec (qt:app)))))) diff -rN -u old-qt.core/src/event.lisp new-qt.core/src/event.lisp --- old-qt.core/src/event.lisp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/event.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,10 @@ +(in-package :cl-smoke.qt.core) + +(defun cast-event (event) + (enum-case (cxx:type event) + ((qt:event.+child-added+ qt:event.+child-removed+ + qt:event.+child-polished+) + (setf (slot-value event 'pointer) + (upcast event (find-class 'qt:child-event))) + (change-class event 'qt:child-event))) + event) diff -rN -u old-qt.core/src/i18n.lisp new-qt.core/src/i18n.lisp --- old-qt.core/src/i18n.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/i18n.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defun qt:tr (message &optional context) "Returns the translated MESSAGE for CONTEXT or diff -rN -u old-qt.core/src/lib/CMakeLists.txt new-qt.core/src/lib/CMakeLists.txt --- old-qt.core/src/lib/CMakeLists.txt 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/CMakeLists.txt 2014-11-25 14:24:52.000000000 +0100 @@ -8,13 +8,14 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden") endif(CXX_VISIBILITY) -set(QT_SMOKE_SOURCES qt-smoke.cpp qstring.cpp qstringlist.cpp lisp-object.cpp qlist.cpp) -add_library(qt-smoke-extra MODULE ${QT_SMOKE_SOURCES}) -target_link_libraries(qt-smoke-extra ${QT_LIBRARIES}) -set_target_properties(qt-smoke-extra +set(QT_SMOKE_SOURCES qt_smoke.cpp + qstring.cpp qstringlist.cpp lisp_object.cpp qlist.cpp qvector.cpp) + +add_library(clsmokeqtcore SHARED ${QT_SMOKE_SOURCES}) +target_link_libraries(clsmokeqtcore ${QT_LIBRARIES}) +set_target_properties(clsmokeqtcore PROPERTIES SOVERSION "0.0" VERSION "0.0.1") -install(TARGETS qt-smoke-extra - LIBRARY DESTINATION lib) +install(TARGETS clsmokeqtcore LIBRARY DESTINATION lib) diff -rN -u old-qt.core/src/lib/lisp-object.cpp new-qt.core/src/lib/lisp-object.cpp --- old-qt.core/src/lib/lisp-object.cpp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/lisp-object.cpp 1970-01-01 01:00:00.000000000 +0100 @@ -1,179 +0,0 @@ -#include "lisp-object.h" - -#include -#include - -namespace cl_smoke { -namespace qt { - -/** @struct lisp_object::data - * @internal - * Holds a reference ID for a lisp object and calls - * the destructor callback when it is deleted. - */ - -/** @typedef lisp_object::destructor - * Destructor. - * @param id The ID - */ - -lisp_object::destructor lisp_object::destruct = NULL; - - -/** Constructor. */ -lisp_object::data::data() -: id(id), - is_set(false) -{ } - -/** Constructor. - * @param id The ID. - */ -lisp_object::data::data(int id) -: id(id), - is_set(true) -{ } - -/** Destructor. */ -lisp_object::data::~data() -{ - Q_ASSERT_X(lisp_object::destruct, __func__, - "call setup_lisp_object() first."); - - if (this->is_set) - (*lisp_object::destruct)(this->id); -} - -/** @class lisp_object - * @brief Holds a reference ID to a lisp object. - * - * The registered destructor callback is called when - * the last instance for a specific lisp object is deleted. - * - * Used for lisp objects in QVariants and signal/slots. - */ - -/** Constructor. */ -lisp_object::lisp_object() - : d(new data()) -{ } - -/** Constructor. - * @param id the ID - */ -lisp_object::lisp_object(int id) - : d(new data(id)) -{ } - -/** Constructor. - * @param other the lisp_object to copy - */ -lisp_object::lisp_object(const lisp_object& other) - : d(other.d) -{ } - -/** @fn lisp_object::id() const - * Gets the ID. - * - * @return the ID - */ - -/** @fn lisp_object::set() const - * Determines werter the ID is set. - * - * @return @c true when the id is set and @c false otherwise. - */ - -/** Sets a new ID. - * @param id the ID - */ -void -lisp_object::set_id(int id) -{ - Q_ASSERT(this->set() ? id != this->id() : true); - - d = new data(id); -} - -} // namespace qt -} // namespace cl_smoke - -using namespace cl_smoke::qt; - -/** Initialize the lisp_object. - * @relates cl_smoke::qt::lisp_object - * @param destruct destructor callback - * - * @return the QMetaType ID of lisp_object - */ -int -qt_smoke_setup_lisp_object(void* destruct) -{ - Q_ASSERT(destruct != NULL); - lisp_object::destruct = reinterpret_cast(destruct); - - return qRegisterMetaType(); -} - -/** Gets the ID of @a object. - * @relates cl_smoke::qt::lisp_object - * @param object the lisp_object. - * - * @return the ID - */ -int -qt_smoke_lisp_object_id(const void* object) -{ - return static_cast(object)->id(); -} - - -/** Determines werter the ID of @a object is set. - * @relates cl_smoke::qt::lisp_object - * @param object the object - * - * @return @c true when the ID is set and @c false otherwise. - */ -int -qt_smoke_lisp_object_set(const void* object) -{ - return static_cast(object)->set(); -} - -/** Makes a new lisp_object. - * @relates cl_smoke::qt::lisp_object - * @param id the ID - * - * @return A new lisp_object instance. - */ -void* -qt_smoke_make_lisp_object(int id) -{ - return new lisp_object(id); -} - -/** Deletes a lisp_object. - * @relates cl_smoke::qt::lisp_object - * @param object the lisp_object - */ -void* -qt_smoke_free_lisp_object(void* object) -{ - delete static_cast(object); -} - -#include -/** Gets the lisp_object of a QVariant. - * @relates cl_smoke::qt::lisp_object - * @param variant the QVariant - * - * @return a new lisp_object. - */ -void* -qt_smoke_lisp_object_value(const void* variant) -{ - const QVariant* qvariant = static_cast(variant); - Q_ASSERT(QVariant::UserType == qvariant->type()); - - new lisp_object(qvariant->value()); -} diff -rN -u old-qt.core/src/lib/lisp-object.h new-qt.core/src/lib/lisp-object.h --- old-qt.core/src/lib/lisp-object.h 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/lisp-object.h 1970-01-01 01:00:00.000000000 +0100 @@ -1,83 +0,0 @@ -#ifndef LISP_OBJECT_H -#define LISP_OBJECT_H - -#include -#include -#include -#include - -#include "cl_smoke_qt.h" - -extern "C" -{ - CL_SMOKE_QT_EXPORT int - qt_smoke_setup_lisp_object(void* destruct); - - CL_SMOKE_QT_EXPORT int - qt_smoke_lisp_object_id(const void* object); - - CL_SMOKE_QT_EXPORT int - qt_smoke_lisp_object_set(const void* object); - - CL_SMOKE_QT_EXPORT void* - qt_smoke_make_lisp_object(int id); - - CL_SMOKE_QT_EXPORT void* - qt_smoke_free_lisp_object(void* object); - - CL_SMOKE_QT_EXPORT void* - qt_smoke_lisp_object_value(const void* variant); -} - -namespace cl_smoke { -namespace qt { - -class lisp_object -{ - public: - typedef void (*destructor)(int id); - - lisp_object(); - - lisp_object(int id); - - lisp_object(const lisp_object& other); - - inline int - id() const - { Q_ASSERT(this->set()); return d->id; } - - void - set_id(int id); - - inline bool - set() const - { return d->is_set; } - - friend int - ::qt_smoke_setup_lisp_object(void* destruct); - - private: - struct data : public QSharedData - { - data(); - data(int id); - ~data(); - int id; - bool is_set; - - private: - Q_DISABLE_COPY(data) - }; - - QExplicitlySharedDataPointer d; - - static destructor destruct; -}; - -} // namespace qt -} // namespace cl_smoke - -Q_DECLARE_METATYPE(cl_smoke::qt::lisp_object); - -#endif // LISP_OBJECT_H diff -rN -u old-qt.core/src/lib/lisp_object.cpp new-qt.core/src/lib/lisp_object.cpp --- old-qt.core/src/lib/lisp_object.cpp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/lib/lisp_object.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,181 @@ +#include "lisp_object.h" + +#include "cl_smoke_qt.h" + +#include +#include +#include + +namespace cl_smoke { +namespace qt { + +/** @struct lisp_object::data + * @internal + * Holds a reference ID for a lisp object and calls + * the destructor callback when it is deleted. + */ + +/** @typedef lisp_object::destructor + * Destructor. + * @param id The ID + */ + +lisp_object::destructor lisp_object::destruct = NULL; + + +/** Constructor. */ +lisp_object::data::data() +: id(id), + is_set(false) +{ } + +/** Constructor. + * @param id The ID. + */ +lisp_object::data::data(unsigned int id) +: id(id), + is_set(true) +{ } + +/** Destructor. */ +lisp_object::data::~data() +{ + Q_ASSERT_X(lisp_object::destruct, __func__, + "call setup_lisp_object() first."); + + if (this->is_set) + (*lisp_object::destruct)(this->id); +} + +/** @class lisp_object + * @brief Holds a reference ID to a lisp object. + * + * The registered destructor callback is called when + * the last instance for a specific lisp object is deleted. + * + * Used for lisp objects in QVariants and signal/slots. + */ + +/** Constructor. */ +lisp_object::lisp_object() + : d(new data()) +{ } + +/** Constructor. + * @param id the ID + */ +lisp_object::lisp_object(unsigned int id) + : d(new data(id)) +{ } + +/** Constructor. + * @param other the lisp_object to copy + */ +lisp_object::lisp_object(const lisp_object& other) + : d(other.d) +{ } + +/** @fn lisp_object::id() const + * Gets the ID. + * + * @return the ID + */ + +/** @fn lisp_object::set() const + * Determines werter the ID is set. + * + * @return @c true when the id is set and @c false otherwise. + */ + +/** Sets a new ID. + * @param id the ID + */ +void +lisp_object::set_id(unsigned int id) +{ + Q_ASSERT(this->set() ? id != this->id() : true); + + d = new data(id); +} + +} // namespace qt +} // namespace cl_smoke + +using namespace cl_smoke::qt; + +/** Initialize the lisp_object. + * @relates cl_smoke::qt::lisp_object + * @param destruct destructor callback + * + * @return the QMetaType ID of lisp_object + */ +CL_SMOKE_QT_EXPORT int +cl_smoke_setup_lisp_object(void* destruct) +{ + Q_ASSERT(destruct != NULL); + lisp_object::destruct = reinterpret_cast(destruct); + + return qRegisterMetaType(); +} + +/** Gets the ID of @a object. + * @relates cl_smoke::qt::lisp_object + * @param object the lisp_object. + * + * @return the ID + */ +CL_SMOKE_QT_EXPORT unsigned int +cl_smoke_lisp_object_id(const void* object) +{ + return static_cast(object)->id(); +} + + +/** Determines werter the ID of @a object is set. + * @relates cl_smoke::qt::lisp_object + * @param object the object + * + * @return @c true when the ID is set and @c false otherwise. + */ +CL_SMOKE_QT_EXPORT int +cl_smoke_lisp_object_is_set(const void* object) +{ + return static_cast(object)->set(); +} + +/** Makes a new lisp_object. + * @relates cl_smoke::qt::lisp_object + * @param id the ID + * + * @return A new lisp_object instance. + */ +CL_SMOKE_QT_EXPORT void* +cl_smoke_make_lisp_object(unsigned int id) +{ + return new lisp_object(id); +} + +/** Deletes a lisp_object. + * @relates cl_smoke::qt::lisp_object + * @param object the lisp_object + */ +CL_SMOKE_QT_EXPORT void* +cl_smoke_free_lisp_object(void* object) +{ + delete static_cast(object); +} + +/** Gets the lisp_object of a QVariant. + * @relates cl_smoke::qt::lisp_object + * @param variant the QVariant + * + * @return a new lisp_object. + */ +CL_SMOKE_QT_EXPORT void* +cl_smoke_lisp_object_value(const void* variant) +{ + const QVariant* qvariant = static_cast(variant); + Q_ASSERT(QVariant::UserType == qvariant->type()); + + new lisp_object(qvariant->value()); +} diff -rN -u old-qt.core/src/lib/lisp_object.h new-qt.core/src/lib/lisp_object.h --- old-qt.core/src/lib/lisp_object.h 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/lib/lisp_object.h 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,83 @@ +#ifndef LISP_OBJECT_H +#define LISP_OBJECT_H + +#include "cl_smoke_qt.h" + +#include +#include +#include +#include + +extern "C" +{ + CL_SMOKE_QT_EXPORT int + cl_smoke_setup_lisp_object(void* destruct); + + CL_SMOKE_QT_EXPORT unsigned int + cl_smoke_lisp_object_id(const void* object); + + CL_SMOKE_QT_EXPORT int + cl_smoke_lisp_object_is_set(const void* object); + + CL_SMOKE_QT_EXPORT void* + cl_smoke_make_lisp_object(unsigned int id); + + CL_SMOKE_QT_EXPORT void* + cl_smoke_free_lisp_object(void* object); + + CL_SMOKE_QT_EXPORT void* + cl_smoke_lisp_object_value(const void* variant); +} + +namespace cl_smoke { +namespace qt { + +class lisp_object +{ + public: + typedef void (*destructor)(unsigned int id); + + lisp_object(); + + lisp_object(unsigned int id); + + lisp_object(const lisp_object& other); + + inline unsigned int + id() const + { Q_ASSERT(this->set()); return d->id; } + + void + set_id(unsigned int id); + + inline bool + set() const + { return d->is_set; } + + friend int + ::cl_smoke_setup_lisp_object(void* destruct); + + private: + struct data : public QSharedData + { + data(); + data(unsigned int id); + ~data(); + unsigned int id; + bool is_set; + + private: + Q_DISABLE_COPY(data) + }; + + QExplicitlySharedDataPointer d; + + static destructor destruct; +}; + +} // namespace qt +} // namespace cl_smoke + +Q_DECLARE_METATYPE(cl_smoke::qt::lisp_object); + +#endif // LISP_OBJECT_H diff -rN -u old-qt.core/src/lib/qlist.cpp new-qt.core/src/lib/qlist.cpp --- old-qt.core/src/lib/qlist.cpp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/qlist.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -12,5 +12,4 @@ DEFINE_QLIST_WRAPPER_PTR(void) DEFINE_QLIST_WRAPPER(QByteArray) - } // extern "C" diff -rN -u old-qt.core/src/lib/qlist.h new-qt.core/src/lib/qlist.h --- old-qt.core/src/lib/qlist.h 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/qlist.h 2014-11-25 14:24:52.000000000 +0100 @@ -1,9 +1,10 @@ #ifndef CL_SMOKE_QT_QLIST_H #define CL_SMOKE_QT_QLIST_H -#include #include "cl_smoke_qt.h" +#include + /** @file */ @@ -31,20 +32,14 @@ /** @internal * size, free and make_list. */ #define DEFINE_QLIST_WRAPPER_ALL_PART(NAME, TYPE) \ -CL_SMOKE_QT_EXPORT int \ -qt_smoke_list_ ## NAME ## _size(const void* list) \ -{ \ - return static_cast*>(list)->size(); \ -} \ -\ CL_SMOKE_QT_EXPORT void \ -qt_smoke_free_list_ ## NAME (void* list) \ +cl_smoke_free_list_ ## NAME (void* list) \ { \ delete static_cast*>(list); \ } \ \ CL_SMOKE_QT_EXPORT void* \ -qt_smoke_make_list_ ## NAME () \ +cl_smoke_make_list_ ## NAME () \ { \ return new QList< TYPE >(); \ } \ @@ -55,14 +50,14 @@ */ #define DEFINE_QLIST_WRAPPER_PTR_PART(NAME, TYPE) \ CL_SMOKE_QT_EXPORT const void* \ -qt_smoke_list_ ## NAME ## _at(const void* list, int index) \ +cl_smoke_list_ ## NAME ## _at(const void* list, int index) \ { \ const QList< TYPE >* qlist = static_cast *>(list); \ return qlist->at(index); \ } \ \ CL_SMOKE_QT_EXPORT void \ -qt_smoke_list_ ## NAME ## _append(void* list, void* data) \ +cl_smoke_list_ ## NAME ## _append(void* list, void* data) \ { \ static_cast*>(list) \ ->append(static_cast(data)); \ @@ -73,14 +68,14 @@ */ #define DEFINE_QLIST_WRAPPER_VALUE_PART(NAME, TYPE) \ CL_SMOKE_QT_EXPORT const void* \ -qt_smoke_list_ ## NAME ## _at(const void* list, int index) \ +cl_smoke_list_ ## NAME ## _at(const void* list, int index) \ { \ const QList< TYPE >* qlist = static_cast *>(list); \ return new TYPE(qlist->at(index)); \ } \ \ CL_SMOKE_QT_EXPORT void \ -qt_smoke_list_ ## NAME ## _append(void* list, void* data) \ +cl_smoke_list_ ## NAME ## _append(void* list, void* data) \ { \ static_cast*>(list) \ ->append(*static_cast(data)); \ diff -rN -u old-qt.core/src/lib/qstring.cpp new-qt.core/src/lib/qstring.cpp --- old-qt.core/src/lib/qstring.cpp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/qstring.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -1,5 +1,4 @@ #include -#include #include "cl_smoke_qt.h" @@ -14,9 +13,8 @@ * @return a pointer to a newly allocated char array. */ CL_SMOKE_QT_EXPORT void* -qt_smoke_qstring_to_byte_array(const void* qstring) +cl_smoke_qstring_to_byte_array(const void* qstring) { - Q_ASSERT(qstring); const QString* string = static_cast(qstring); return new QByteArray(string->toLocal8Bit()); @@ -26,7 +24,7 @@ * @param qstring the QString to free */ CL_SMOKE_QT_EXPORT void -qt_smoke_free_qstring(void* qstring) +cl_smoke_free_qstring(void* qstring) { delete static_cast(qstring); } @@ -38,7 +36,7 @@ * @return a newly allocated QString */ CL_SMOKE_QT_EXPORT void* -qt_smoke_string_to_qstring(const char* data, int length) +cl_smoke_string_to_qstring(const char* data, int length) { return new QString(QString::fromLocal8Bit(data, length)); } diff -rN -u old-qt.core/src/lib/qstringlist.cpp new-qt.core/src/lib/qstringlist.cpp --- old-qt.core/src/lib/qstringlist.cpp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/qstringlist.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -1,8 +1,7 @@ +#include "cl_smoke_qt.h" + #include #include -#include - -#include "cl_smoke_qt.h" /** @file * @brief QStringList conversion. */ @@ -15,7 +14,7 @@ * @return the number of items */ CL_SMOKE_QT_EXPORT int -qt_smoke_string_list_size(const void* string_list) +cl_smoke_string_list_size(const void* string_list) { Q_ASSERT(string_list); return static_cast(string_list)->size(); @@ -28,7 +27,7 @@ * @return a new allocated byte-array */ CL_SMOKE_QT_EXPORT void* -qt_smoke_string_list_at(const void* string_list, int index) +cl_smoke_string_list_at(const void* string_list, int index) { Q_ASSERT(string_list); const QStringList* list = static_cast(string_list); @@ -42,7 +41,7 @@ * @param string_list the QStringList to free */ CL_SMOKE_QT_EXPORT void -qt_smoke_free_string_list(void* string_list) +cl_smoke_free_string_list(void* string_list) { delete static_cast(string_list); } @@ -52,7 +51,7 @@ * @return a new QStringList */ CL_SMOKE_QT_EXPORT void* -qt_smoke_make_string_list() +cl_smoke_make_string_list() { return new QStringList(); } @@ -63,7 +62,7 @@ * @param length the length of @a data */ CL_SMOKE_QT_EXPORT void -qt_smoke_string_list_append(void* string_list, const char* data, int length) +cl_smoke_string_list_append(void* string_list, const char* data, int length) { static_cast(string_list)->append(QString::fromLocal8Bit(data, length)); } diff -rN -u old-qt.core/src/lib/qt-smoke.cpp new-qt.core/src/lib/qt-smoke.cpp --- old-qt.core/src/lib/qt-smoke.cpp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lib/qt-smoke.cpp 1970-01-01 01:00:00.000000000 +0100 @@ -1,28 +0,0 @@ -#include -#include -#include - -#include "cl_smoke_qt.h" - -/** @file - * @brief Qt support functions */ - -extern "C" { - -/** Registers a callback to be invoked for every QEvent. - * @see QCoreApplication::notifyInternal - * - * @param callback the callback - * - * @return @c true on success and @c false when the callback table is full. - */ -CL_SMOKE_QT_EXPORT int -qt_smoke_register_event_notify(void* callback) -{ - Q_ASSERT(callback); - - return QInternal::registerCallback(QInternal::EventNotifyCallback, - reinterpret_cast(callback)); -} - -} // extern "C" diff -rN -u old-qt.core/src/lib/qt_smoke.cpp new-qt.core/src/lib/qt_smoke.cpp --- old-qt.core/src/lib/qt_smoke.cpp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/lib/qt_smoke.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,53 @@ +#include "cl_smoke_qt.h" + +#include +#include +#include + +/** @file + * @brief Qt support functions */ + +#include + +static void +terminate() +{ + qFatal("caught an exception."); +} + +extern "C" { + +/** Registers a callback to be invoked for every QEvent. + * @see QCoreApplication::notifyInternal + * + * @param callback the callback + * + * @return @c true on success and @c false otherwise + */ +CL_SMOKE_QT_EXPORT int +cl_smoke_register_event_notify(void* callback) +{ + Q_ASSERT(callback); + std::set_terminate(terminate); + + return QInternal::registerCallback(QInternal::EventNotifyCallback, + reinterpret_cast(callback)); +} + +/** Returns the most specific QMetaObject of the QObject instance @a object. + * Used to determine the actual class of an object. Smoke can not be used since it calls the + * metaObject() of the class the method was called for. + * + * @param object A QObject + * + * @return QMetaObject + */ +CL_SMOKE_QT_EXPORT void* +cl_smoke_meta_object(void* object) +{ + Q_ASSERT(object); + static_cast(object)->metaObject(); +} + + +} // extern "C" diff -rN -u old-qt.core/src/lib/qvector.cpp new-qt.core/src/lib/qvector.cpp --- old-qt.core/src/lib/qvector.cpp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/lib/qvector.cpp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,27 @@ +#include "cl_smoke_qt.h" + +#include +#include + +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(); +} + +/** 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); +} + +} // extern "C" diff -rN -u old-qt.core/src/lisp-object.lisp new-qt.core/src/lisp-object.lisp --- old-qt.core/src/lisp-object.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/lisp-object.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,37 +1,43 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defvar *cxx-lisp-objects* (smoke::make-synchronized-hash-table) "Objects that are currently passed in a C++ class.") (let ((id 0)) + (declare (type (smoke::c-integer :unsigned-int) id)) (defun gen-cxx-lisp-object-id () "Returns a new unique ID." - (incf id))) - -(defcfun qt-smoke-setup-lisp-object :int + (loop do + (setf id + (logand (1- (expt 2 (* 8 (foreign-type-size :unsigned-int) ))) + (1+ id))) + while (nth-value 1 (gethash id *cxx-lisp-objects*))) + id)) + +(defcfun cl-smoke-setup-lisp-object :int (destruct :pointer)) -(defcfun qt-smoke-lisp-object-id :int +(defcfun cl-smoke-lisp-object-id :unsigned-int (object :pointer)) -(defcfun qt-smoke-lisp-object-set :int +(defcfun cl-smoke-lisp-object-is-set :int (object :pointer)) -(defcfun qt-smoke-make-lisp-object :pointer - (id :int)) +(defcfun cl-smoke-make-lisp-object :pointer + (id :unsigned-int)) -(defcfun qt-smoke-free-lisp-object :void +(defcfun cl-smoke-free-lisp-object :void (object :pointer)) (defcallback destruct-cxx-lisp-object :void - ((id :int)) + ((id :unsigned-int)) (remhash id *cxx-lisp-objects*)) (defvar *cxx-lisp-object-metatype* "Metatype ID of the C++ lisp_object.") (eval-startup () (setf *cxx-lisp-object-metatype* - (qt-smoke-setup-lisp-object (callback destruct-cxx-lisp-object))) + (cl-smoke-setup-lisp-object (callback destruct-cxx-lisp-object))) (assert (>= *cxx-lisp-object-metatype* (smoke::value qt:meta-type.+user+)) (*cxx-lisp-object-metatype*) @@ -41,20 +47,20 @@ "Constructs a C++ object wrapper for OBJECT." (let ((id (gen-cxx-lisp-object-id))) (setf (gethash id *cxx-lisp-objects*) object) - (qt-smoke-make-lisp-object id))) + (cl-smoke-make-lisp-object id))) (defun free-cxx-lisp-object (pointer) "Deletes the lisp_object at POINTER." - (qt-smoke-free-lisp-object pointer)) + (cl-smoke-free-lisp-object pointer)) ;; (qmetatype.destroy *cxx-lisp-object-metatype* pointer)) ;; FIXME use this? (defun translate-cxx-lisp-object (pointer) "Returns the object of the cxx-lisp-object at POINTER. -When beeing received as an argument by a slot, +When being received as an argument by a slot, the object must not be deallocated." (multiple-value-bind (value present-p) - (gethash (qt-smoke-lisp-object-id pointer) + (gethash (cl-smoke-lisp-object-id pointer) *cxx-lisp-objects*) (assert present-p (value present-p) "No object for ~A in ~A" pointer *cxx-lisp-objects*) diff -rN -u old-qt.core/src/list.lisp new-qt.core/src/list.lisp --- old-qt.core/src/list.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/list.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,69 +1,117 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(defmacro define-qlist-wrapper (type-name &optional c-name) - (let* ((c-name (or c-name type-name)) - (type (string-upcase c-name)) - (list-type (symbolicate 'qlist- type))) - `(progn - (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_size") :int - "Returns the size of LIST." - (list :pointer)) - (defcfun ,(concatenate 'string "qt_smoke_free_list_" c-name) :void - "Frees LIST." - (list :pointer)) - (defcfun ,(concatenate 'string "qt_smoke_make_list_" c-name) :pointer - "Makes a list.") - (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_at") :pointer - "Returns the a newly constructed copy of the element at position AT of LIST." - (list :pointer) - (index :int)) - (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_append") :pointer - "Appends NEW-ELEMENT to LIST." - (list :pointer) - (new-element :pointer)) - (define-foreign-type ,list-type () - () - (:actual-type :pointer)) - (define-parse-method ,list-type () - (make-instance ',list-type)) - (eval-when (:load-toplevel :execute) - ,@(loop for type-name in (ensure-list type-name) collect - `(smoke::add-type ,(format nil "const QList<~A>&" type-name) - ',list-type)) - ,@(loop for type-name in (ensure-list type-name) collect - `(smoke::add-type ,(format nil "QList<~A>" type-name) ',list-type))) - ,@(loop for type-name in (ensure-list type-name) collect - `(defmethod translate-from-foreign (list (type ,list-type)) - (let ((vector (make-array (,(symbolicate 'qt-smoke-list- - type '-size) - list)))) - (dotimes (index (length vector) vector) - (setf (aref vector index) - ;; FIXME the retuned object is not wrapped by Smoke - ;; -> change this? - (smoke::object-to-lisp - (,(symbolicate 'qt-smoke-list- - type '-at) - list index) - (smoke::make-smoke-type *smoke-module* ,type-name))))))) - (defmethod free-translated-object (pointer (type ,list-type) param) - (declare (ignore param)) - (,(symbolicate 'qt-smoke-free-list- type) - pointer)) - (defun ,(symbolicate 'coerce- list-type) (list) - (let ((qlist (,(symbolicate 'qt-smoke-make-list- type)))) - (loop for element in list do - (,(symbolicate 'qt-smoke-list- type '-append) - qlist (pointer (make-instance ',type :args (list element))))) - (smoke::make-cleanup-pointer - qlist - (function ,(symbolicate 'qt-smoke-free-list- type))))) - ,@(loop for type-name in (ensure-list type-name) collect - `(define-from-lisp-translation (,(format nil "const QList<~A>&" type-name) - ,(format nil "QLIst<~A>" type-name)) - list ;; FIXME allow seqence and define element type - ,(symbolicate 'coerce- list-type)))))) - -(define-qlist-wrapper "QVariant") -(define-qlist-wrapper ("QObject*" "QWidget*") "void") -(define-qlist-wrapper "QByteArray") +(defbitfield qlist-data-flags + :sharable) + +(defcstruct qlist-data + (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int))) + (alloc :int) + (begin :int) + (end :int) + (flags qlist-data-flags) + (array :pointer)) + +(defcstruct qlist + (data (:pointer qlist-data))) + +(defun qlist-size (qlist) + (let ((data (foreign-slot-value qlist 'qlist 'data))) + (- (foreign-slot-value data 'qlist-data 'end) + (foreign-slot-value data 'qlist-data 'begin)))) + +(eval-when (:compile-toplevel :load-toplevel :execute) + (macrolet ((c-name (name) + `(nth-value 1 ,name)) + (fun-names-let (name-pre-post-fixes &body body) + `(flet (,@(mapcar + #'(lambda (npp) + `(,(first npp) (type) + (values + (intern (string-upcase + (concatenate 'string + ,(second npp) + type + ,(third npp))) + ,*package*) + (concatenate 'string + (substitute #\_ #\- + ,(second npp)) + type + (substitute #\_ #\- + ,(third npp)))))) + name-pre-post-fixes)) + ,@body))) + (fun-names-let ((list-free "cl-smoke-free-list-") + (list-make "cl-smoke-make-list-") + (list-at "cl-smoke-list-" "-at") + (list-append "cl-smoke-list-" "-append")) + (defmacro define-qlist-wrapper (type-name element-type &optional (c-name nil c-name-p) + &key def-cfuns) + (let* ((c-name (or c-name type-name)) + (type c-name) + (lisp-type (symbolicate 'qlist- element-type))) + `(progn + ,(when (or (not c-name-p) def-cfuns) + `(progn + (defcfun ,(c-name (list-free type)) :void + "Frees LIST." + (list :pointer)) + (defcfun ,(c-name (list-make type)) :pointer + "Makes a list.") + (defcfun ,(c-name (list-at type)) :pointer + "Returns the a newly constructed copy of the element at + position AT of LIST." + (list :pointer) + (index :int)) + (defcfun ,(c-name (list-append type)) :pointer + "Appends NEW-ELEMENT to LIST." + (list :pointer) + (new-element :pointer)))) + ;; To Lisp + ,@(loop for type-name in (ensure-list type-name) collect + `(defun ,(symbolicate 'from-list- type-name) (list-pointer) + (declare (optimize (speed 3))) + (let ((vector (make-array (qlist-size + list-pointer)))) + (dotimes (index (length vector) vector) + (setf (elt vector index) + ;; FIXME the returned object is not wrapped by Smoke + ;; -> change this? + (object-to-lisp + (,(list-at type) + list-pointer index) + (make-smoke-type ,(symbolicate '*smoke-module*) + ,type-name))))))) + ,@(loop for type-name in (ensure-list type-name) collect + `(define-to-lisp-translation + (,(format nil "const QList<~A>&" type-name) + ,(format nil "QList<~A>" type-name)) + ,(symbolicate 'from-list- type-name) + ,(list-free type))) + ;; From Lisp + (defun ,(symbolicate 'coerce- lisp-type) (list) + (let ((qlist (,(list-make type)))) + (loop for element across list do + (,(list-append type) + qlist (pointer (make-instance ',element-type :args (list element))))) + (make-cleanup-pointer + qlist + (function ,(list-free type))))) + (defun ,(symbolicate lisp-type '-p) (list) + (every #'(lambda (element) + ;(typep element ',element-type)) + (typep element (find-class ',element-type))) + list)) + ,@(loop for type-name in (ensure-list type-name) collect + `(define-from-lisp-translation (,(format nil "const QList<~A>&" type-name) + ,(format nil "QList<~A>" type-name)) + ;; FIXME allow sequence + (and (vector );,element-type) + (satisfies ,(symbolicate lisp-type '-p))) + ,(symbolicate 'coerce- lisp-type))))))))) + +(define-qlist-wrapper "QVariant" qt:variant) + +(define-qlist-wrapper "QByteArray" qt:byte-array) + +(define-qlist-wrapper "QObject*" qt:object "void" :def-cfuns t) diff -rN -u old-qt.core/src/msg-handler.lisp new-qt.core/src/msg-handler.lisp --- old-qt.core/src/msg-handler.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/msg-handler.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,26 +1,24 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(cffi:defcenum qt-msg-type - (:debug-message) - (:warning-message) - (:critical-message) - (:fatal-message)) +;; FIXME Determine the actual size of the QtMsgType enum. +(cffi:defctype qt-msg-type :int) + +;; QtMsgHandler is a typedef for a pointer. +(define-pointer-typedef "QtMsgHandler" foreign-pointer) + +(define-pointer-typedef "void(*)(QtMsgType,const char*)" foreign-pointer) +(define-pointer-typedef "unsigned char*" foreign-pointer) (defcallback qt-msg-handler :void ((type qt-msg-type) (message :string)) (ecase type - (:debug-message - (write-string "qDebug: " *debug-io*) - (write-line message *debug-io*)) - (:warning-message (warn message)) - (:critical-message (cerror "Ignore" "~A" message)) - (:fatal-message (error message)))) - -(defun register-msg-handler () - (with-foreign-object (handler :pointer) - (setf (mem-ref handler :pointer) (callback qt-msg-handler)) - (qt:q-install-msg-handler handler))) + (#.(value qt:+qt-debug-msg+) + (write-string "qDebug: " *debug-io*) + (write-line message *debug-io*)) + (#.(value qt:+qt-warning-msg+) (warn message)) + (#.(value qt:+qt-critical-msg+) (cerror "Ignore" "~A" message)) + (#.(value qt:+qt-fatal-msg+) (error message)))) -(eval-when (:load-toplevel) - (register-msg-handler)) +(eval-startup (:load-toplevel) + (qt:q-install-msg-handler (callback qt-msg-handler))) diff -rN -u old-qt.core/src/object.lisp new-qt.core/src/object.lisp --- old-qt.core/src/object.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/object.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,11 +1,18 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(let ((object (make-instance 'qt:object))) - (defmethod cxx:static-meta-object ((class (eql (find-class 'qt:object)))) - "No OBJECT.STATIC-META-OBJECT (r558420)." - (cxx:meta-object object)) - (defmethod cxx:static-meta-object ((class cxx:class)) - (cxx:static-meta-object (smoke::find-smoke-class class)))) +;; Smoke always calls the method of the class the object is assumed to +;; be and not the most specific method like required for virtual +;; methods. Thus we implement a virtual metaObject() method to +;; determine the actual class. This is only needed for objects not +;; constructed by Smoke, since otherwise we would know the most +;; specific class. +(defcfun cl-smoke-meta-object :pointer (object :pointer)) +(defun meta-object (object) + (make-instance 'qt:meta-object + :pointer (cl-smoke-meta-object (pointer object)))) + +(defmethod cxx:static-meta-object ((class cxx:class)) + (cxx:static-meta-object (smoke::find-smoke-class class))) (defmethod documentation :around ((class smoke::smoke-standard-class) (doc-type (eql 't))) @@ -26,8 +33,21 @@ (if (or (not (slot-boundp object 'pointer)) (null-pointer-p (pointer object))) (call-next-method) - (print-unreadable-object (object stream :type t :identity t) - (princ (cxx:object-name object) stream)))) + (if (string= "" (cxx:object-name object)) + (print-unreadable-object (object stream :type t :identity t) + (when (smoke::const-p object) + (princ "CONST " stream))) + (print-unreadable-object (object stream :type t :identity t) + (when (smoke::const-p object) + (princ "CONST " stream)) + (princ (cxx:object-name object) stream))))) + +(defmethod print-object ((object qt:meta-object) stream) + (if (or (not (slot-boundp object 'pointer)) + (null-pointer-p (pointer object))) + (call-next-method) + (print-unreadable-object (object stream :type t :identity t) + (princ (cxx:class-name object) stream)))) (defun meta-object-methods (meta-object &optional (direct-only nil)) (loop for index from (if direct-only (cxx:method-offset meta-object) 0) @@ -55,22 +75,51 @@ (meta-object-slots (cxx:static-meta-object class) :all all)) (defun parent-p (object) - (not (null-pointer-p (smoke::pointer-call (smoke::make-smoke-method-from-name (find-class 'qt:object) - "parent") - (smoke::pointer object))))) - -(defun find-smoke-parent (object) - "Returns the first parent of OBJECT or OBJECT that is a Smoke class. - (the destructed callback is called when the object is freed.)" - ;; FIXME allow usage of non smoke objects by connecting to the - ;; destroyed() signal. + (not (null-pointer-p (smoke::pointer-call + (smoke::make-smoke-method-from-name + (find-class 'qt:object) + "parent") + (smoke::pointer object))))) + + +;; FIXME this might not be that smart. +(eval-startup (:compile-toplevel :execute) + (defparameter *destroyed-slot* (qt:make-slot + #'(lambda (object) + (foreign-funcall-pointer + (get-callback 'smoke::destructed) + () :pointer (smoke:pointer object)))))) + +(defvar *toplevel-objects* nil) + +(defun ensure-smoke-parent (object) (declare (optimize (speed 3))) (let ((parent (cxx:parent object))) - (if (not (null-pointer-p (smoke::pointer parent))) - (if (smoke::has-pointer-p (smoke::pointer parent)) - parent - (find-smoke-parent parent)) - (error "No smoke parent found.")))) + (assert (not (null-pointer-p (smoke:pointer parent))) + () + "The object ~A has not parent." object) + (unless (smoke::has-pointer-p (smoke:pointer parent)) + ;; Before we ADD-OBJECT PARENT it must know its real class to + ;; prevent a clash when the same pointer is returned by a + ;; function with a more specific type. + (change-class parent + ;; Note: there can be classes that are not known + ;; to Smoke, like KDE's OxygenStyle that might + ;; be seen by the event-notify callback. But + ;; it's probably save to assume the user will + ;; never use those. + (let ((class-name (cxx:class-name (meta-object parent)))) + (smoke::lispify class-name (ecase (char class-name 0) + (#\Q :qt) + (#\K :kde))))) + (smoke::add-object parent) + (qt:connect (qt:get-signal parent "destroyed(QObject*)") + *destroyed-slot* qt:+direct-connection+) + (tg:cancel-finalization parent) + (if (null-pointer-p (smoke:pointer (cxx:parent parent))) + (push parent *toplevel-objects*) + (smoke::transfer-ownership-to parent (ensure-smoke-parent parent)))) + parent)) (defmethod initialize-instance :after ((object qt:object) &key (pointer nil pointer-p) &allow-other-keys) @@ -84,25 +133,26 @@ (not (null-pointer-p (smoke::pointer object))) (parent-p object)) (smoke::transfer-ownership-to object - (find-smoke-parent object)))) + (ensure-smoke-parent object)))) (define-condition wrapper-gc (storage-condition) - ((class-name :initarg :class-name - :documentation "The class name of the gc'ed object.") + ((object-class :initarg :object-class + :documentation "The class of the gc'ed object.") (pointer :initarg :pointer)) (:report (lambda (condition stream) - (format stream "The object ~A ~A of type cxx:class -has a parent but got garbage collected." - (slot-value condition 'class-name) - (slot-value condition 'pointer))))) - -(smoke:eval-startup (:compile-toplevel :execute) -(defparameter *get-parent* - (smoke::make-smoke-method-from-name (find-class 'qt:object) "parent")) - ;; FIXME this leaks memory when QCoreApplication::exec is never called, - ;; beause then, deleteLater has no effect. -(defparameter *delete-later* - (smoke::make-smoke-method-from-name (find-class 'qt:object) "deleteLater"))) + (format stream "The object ~A ~A of type cxx:class +has the parent but got garbage collected." + (slot-value condition 'object-class) + (slot-value condition 'pointer))))) + +(eval-startup (:compile-toplevel :execute) + (defparameter *get-parent* + (smoke::make-smoke-method-from-name (find-class 'qt:object) "parent")) + + ;; FIXME this leaks memory when QCoreApplication::exec() is never + ;; called, beause then, deleteLater() has no effect. + (defparameter *delete-later* + (smoke::make-smoke-method-from-name (find-class 'qt:object) "deleteLater"))) (defmethod smoke::make-finalize ((object qt:object)) "Delete the qt:object OBJECT, @@ -118,7 +168,7 @@ (if (null-pointer-p (smoke::pointer-call *get-parent* pointer)) (smoke::pointer-call *delete-later* pointer) (error (make-condition 'wrapper-gc - :class-name (name class) + :object-class class :pointer pointer))) (error (condition) (smoke::report-finalize-error condition "qt:object wrap" @@ -135,10 +185,12 @@ ;;; -;;; The event-notify callback get called by QCoreApplication, -;;; on notification of an event. +;;; The event-notify callback get called by QCoreApplication, on +;;; notification of an event. +;;; +;;; The DATA argument is an array of size three, containing the +;;; pointers: ;;; -;;; The DATA argument is an array of size three, containing the pointers: ;;; void* receiver ;;; void* event ;;; void* result @@ -147,44 +199,49 @@ ;;; Returning true marks the event as handled; false on the other hand ;;; leaves the event processing unchanged. ;;; -;;; See: QCoreApplication::notifyInternal(QObject *receiver, QEvent *event) +;;; See: QCoreApplication::notifyInternal(QObject *receiver, QEvent +;;; *event) (cffi:defcallback event-notify smoke:cxx-bool ((data :pointer)) (declare (optimize (speed 3))) (let ((receiver (smoke::get-object (cffi:mem-aref data :pointer 0))) - (event (make-instance 'qt:event - :pointer (cffi:mem-aref data :pointer 1)))) + (event (cast-event + (make-instance 'qt:event + :pointer (cffi:mem-aref data :pointer 1))))) (enum-case (cxx:type event) (qt:event.+child-added+ - (let ((child-event (make-instance 'qt:child-event - :pointer - (smoke::upcast event (find-class 'qt:child-event))))) - (tg:cancel-finalization (cxx:child child-event)) - (when (smoke::has-pointer-p (smoke::pointer (cxx:child child-event))) - (unless receiver - (setf receiver (find-smoke-parent (cxx:child child-event)))) - (smoke::transfer-ownership-to (cxx:child child-event) receiver)))) + (tg:cancel-finalization (cxx:child event)) + (when (smoke::has-pointer-p (smoke::pointer (cxx:child event))) + (unless receiver + (setf receiver (ensure-smoke-parent (cxx:child event)))) + (smoke::transfer-ownership-to (cxx:child event) receiver))) (qt:event.+child-removed+ - (let* ((child-event (make-instance 'qt:child-event - :pointer (smoke::upcast event - (find-class 'qt:child-event))))) - ;; We receive child removed events for any QObject, wherter - ;; it was construted by Smoke or not. Only take ownership of objects - ;; that have been constructed by Smoke. - (when (smoke::has-pointer-p (smoke::pointer (cxx:child child-event))) - (assert receiver) - (smoke::take-ownership (cxx:child child-event) receiver)))))) + ;; We receive child removed events for any QObject, whether + ;; it was constructed by Smoke or not. Only take ownership of + ;; objects that have been constructed by Smoke. + (when (smoke::has-pointer-p (smoke::pointer (cxx:child event))) + (assert receiver) + (smoke::take-ownership (cxx:child event) receiver))))) nil) (eval-when (:compile-toplevel :load-toplevel :execute) - (cffi:defcfun qt-smoke-register-event-notify :boolean + (cffi:defcfun cl-smoke-register-event-notify :boolean (event-notify :pointer))) (defun register-event-notify () - (let ((ret (qt-smoke-register-event-notify (cffi:callback event-notify)))) + (let ((ret (cl-smoke-register-event-notify (cffi:callback event-notify)))) (unless ret - (error "The Qt event-notify callback table is full.")))) + (error "Registering event-notify callback failed.")))) + +(defun check-child-parent-ownership () + (loop for parent being the hash-values of smoke::*object-map* do + (loop for child in (smoke::owned-objects parent) do + (when (typep child 'qt:object) + (assert (eql (cxx:parent child) parent) + (child parent) + "cl-smoke thinks ~A has the parent ~A, but ~A is its parent." + child parent (cxx:parent child)))))) -(smoke:eval-startup () +(eval-startup () (register-event-notify)) diff -rN -u old-qt.core/src/operator.lisp new-qt.core/src/operator.lisp --- old-qt.core/src/operator.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/operator.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defun cxx:= (object &rest more-objects) (if (null more-objects) @@ -6,9 +6,11 @@ (every #'(lambda (o) ;; Consider Class::operator== and operator== ;; FIXME integrate this in the overload resolution - (handler-case (qt:operator== object o) - (smoke::no-applicable-cxx-method () - (cxx:operator== object o)))) + (if (typep object 'smoke-standard-object) + (handler-case (qt:operator== object o) + (no-applicable-cxx-method () + (cxx:operator== object o))) + (qt:operator== object o))) more-objects))) (defun cxx:/= (object &rest more-objects) @@ -88,13 +90,6 @@ (index) "Index ~A for ~A requested, but the length is ~A" index object (cxx:size object)) - ;; FIXME smoke generates no destructor for QByteRef - ;; kaylptusCxxToSmoke.pm 954: - ;; # Also, if the class has no explicit destructor, generate a default one. - ;; if ( !$hasDestructor && !$hasPrivatePureVirtual && !$isGlobalSpace && $classNode->{NodeType} ne 'namespace' ) { - ;; > $hasPublicDestructor = 1; - ;; > $hasPublicProtectedConstructor = 1; - ;; (cxx:operator= (cxx:operator[] object index) new-value) new-value) diff -rN -u old-qt.core/src/ownership.lisp new-qt.core/src/ownership.lisp --- old-qt.core/src/ownership.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/ownership.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,79 +1 @@ -(in-package :cl-smoke.qt-impl) - -;; undo-stack -(define-takes-ownership cxx:push ((undo-stack qt:undo-stack) undo-command) - undo-command) - - -#| -;; FIXME TODO -;; application -(define-takes-ownership cxx:set-style ((application application) (style style)) - ;; NOT QString style - style) ;; STATIC - - -;; core-application -(define-takes-ownership cxx:post-event ((app core-application) receiver (event event)) - event) ;; STATIC -(define-takes-ownership cxx:post-event ((app core-application) receiver event priority) - event) ;; STATIC -|# - -;; AbstractFileEngine::beginEntryList return value - -;; grid-layout -(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item) - row column) - item) -(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item) - row column row-span) - item) -(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item) - row column row-span colum-span) - item) -(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item) - row column row-span colum-span aligment) - item) - -(define-takes-ownership cxx:add-item ((layout qt:layout) (item qt:layout-item)) - item) - -;; QIcon::QIcon(QIconEngine* engine) - -(define-takes-ownership cxx:register-editor ((factory qt:item-editor-factory) - type creator) - creator) - - -(define-takes-ownership cxx:set-child ((this qt:standard-item) row colum item) - item) -(define-takes-ownership cxx:set-child ((this qt:standard-item) row item) - item) -(define-takes-ownership cxx:set-horizontal-header-item ((this qt:standard-item-model) - column item) - item) -(define-takes-ownership cxx:set-vertical-header-item ((this qt:standard-item-model) - row item) - item) -(define-takes-ownership cxx:set-item ((this qt:standard-item-model) - row column item) - item) -(define-takes-ownership cxx:set-item ((this qt:standard-item-model) - row item) - item) -(define-takes-ownership cxx:set-item-prototype ((this qt:standard-item-model) - item) - item) - - -;; Allocates return value -;; QLineEdit::createStandardContextMenu() - -;; parent -;; QListwidgetitem - - -;; Relases ownership -;;QList QStandardItemModel::takeColumn ( int column ) -;; etc +(in-package :cl-smoke.qt.core) diff -rN -u old-qt.core/src/package.lisp new-qt.core/src/package.lisp --- old-qt.core/src/package.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/package.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,8 +1,13 @@ -(defpackage :cl-smoke.qt-impl - (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria)) +(defpackage :cl-smoke.qt.core + (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria) + (:export #:define-qvector-translations + #:with-application + #:delete-app + #:ensure-app + #:kill-app)) (defpackage :cl-smoke.qt - (:use) ;; do not use :cl to prevent collition with TIME and CHAR + (:use) ;; do not use :cl to prevent collision with TIME and CHAR (:nicknames :qt) (:export #:app #:app-p diff -rN -u old-qt.core/src/painter.lisp new-qt.core/src/painter.lisp --- old-qt.core/src/painter.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/painter.lisp 1970-01-01 01:00:00.000000000 +0100 @@ -1,16 +0,0 @@ -(in-package :cl-smoke.qt-impl) - -(defmacro qt:with-painter ((painter paint-device) &body body) - "Binds a PAINTER instance for PAINT-DEVICE to PAINTER - during the evaulation of BODY. - -Makes sure the painter ends after BODY; thus prevening problems with -still active and not yet garbage collected painters." - `(let ((,painter (make-instance 'qt:painter :args (list ,paint-device)))) - (assert (cxx:is-active ,painter) - (,painter) - "Painter ~A for ~A is not active" - ,painter ,paint-device) - (unwind-protect - (progn ,@body) - (cxx:end ,painter)))) diff -rN -u old-qt.core/src/properties.lisp new-qt.core/src/properties.lisp --- old-qt.core/src/properties.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/properties.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,8 +1,29 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defun reverse-lispify (symbol) "Converts the name of symbol to C++ style." - (smoke::lisp-to-cxx (symbol-name symbol))) + (if (eq (symbol-package symbol) + (find-package :keyword)) + (smoke::lisp-to-cxx (symbol-name symbol)) + (concatenate 'string + (package-name (symbol-package symbol)) + "::" + (symbol-name symbol)))) + +(defun property-package (name) + (let ((package-end (search "::" name))) + (if package-end + (values + (find-package (intern (subseq name 0 package-end) :keyword)) + (+ 2 package-end)) + (values (find-package :keyword) 0)))) + +(defun lispify-property-name (name) + (multiple-value-bind (package name-start) + (property-package name) + (if (= 0 name-start) + (smoke::lispify name package) + (intern (subseq name name-start) package)))) (defun property-name (name) "The property name is a string or a to camelCase converted symbol." @@ -12,33 +33,48 @@ (defun qt:property (object name) "Returns the property NAME of OBJECT." + (declare (type qt:object object) + (type (or string symbol) name)) + (assert (qt:property-p object name) + (object name) + "~A has no property ~A." object name) (qt:from-variant (cxx:property object (property-name name)))) - (defun (setf qt:property) (new-value object name) - (cxx:set-property object (property-name name) - (make-instance 'qt:variant - :args (list new-value))) + (declare (type qt:object object) + (type (or string symbol) name)) + (cxx:set-property object (property-name name) + (make-instance 'qt:variant :arg0 new-value)) new-value) (defun qt:remove-property (object name) "Removes the property NAME from OBJECT." + (declare (type qt:object object) + (type (or string symbol) name)) (setf (qt:property object name) (qt:make-variant))) (defun qt:property-p (object name) "Returns T when NAME is a property of OBJECT and NIL otherwise." + (declare (type qt:object object) + (type (or string symbol) name)) (qt:variant-boundp (cxx:property object (property-name name)))) (defun meta-object-properties (meta-object &optional (all t)) "Returns a list of the properties of META-OBJECT." (loop for index from (if all 0 (cxx:property-offset meta-object)) below (cxx:property-count meta-object) - collect (smoke::lispify (cxx:name (cxx:property meta-object index))))) + collect (lispify-property-name (cxx:name (cxx:property meta-object index))))) + +(defun sort-symbols (symbols) + (sort symbols + #'(lambda (a b) + (string<= (write-to-string a) (write-to-string b))))) (defgeneric qt:class-properties (class) (:documentation "Returns a list of the properties of CLASS.") (:method ((class class)) - (meta-object-properties (cxx:static-meta-object class))) + (sort-symbols + (meta-object-properties (cxx:static-meta-object class)))) (:method ((symbol symbol)) (qt:class-properties (find-class symbol)))) @@ -50,10 +86,12 @@ (qt:class-direct-properties (find-class symbol)))) (defun dynamic-properties (object) - (map 'list (compose #'smoke::lispify #'cxx:data) + (map 'list (compose #'lispify-property-name #'cxx:data) (cxx:dynamic-property-names object))) (defun qt:properties (object) "Returns a list of the properties of OBJECT." - (nconc (dynamic-properties object) - (meta-object-properties (cxx:meta-object object)))) + (declare (type qt:object object)) + (sort-symbols + (nconc (dynamic-properties object) + (meta-object-properties (cxx:meta-object object))))) diff -rN -u old-qt.core/src/qstring.lisp new-qt.core/src/qstring.lisp --- old-qt.core/src/qstring.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/qstring.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,66 +1,57 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(defcfun qt-smoke-string-to-qstring :pointer +(defcfun cl-smoke-string-to-qstring :pointer (data :string) (length :int)) -(defcfun qt-smoke-free-qstring :void +(defcfun cl-smoke-free-qstring :void (string :pointer)) -(defcfun qt-smoke-qstring-to-byte-array :pointer +(defcfun cl-smoke-qstring-to-byte-array :pointer (qstring :pointer)) -(define-foreign-type qstring () - () - (:actual-type :pointer)) - -(defun setup-type-map () - (smoke::add-type "QString" 'qstring) - (smoke::add-type "const QString&" 'qstring)) - -(eval-when (:load-toplevel :execute) - (setup-type-map)) - -;;; make sure, that you have configured slime corretly. -;;; e.g. +;;; make sure, that you have configured slime correctly. +;;; e.g.: ;;; (string #\U9999) crashed slime for me. Adding ;;; (set-language-environment "UTF-8") ;;; (setq slime-net-coding-system 'utf-8-unix) ;;; to .emacs helps. +;;; Use emacs 23 for better unicode support. (smoke:eval-startup (:compile-toplevel :execute) (qt:text-codec.set-codec-for-cstrings (qt:text-codec.codec-for-name (string *default-foreign-encoding*))) (qt:text-codec.set-codec-for-locale (qt:text-codec.codec-for-name (string *default-foreign-encoding*)))) - -(define-parse-method qstring () - (make-instance 'qstring)) - (smoke:eval-startup (:compile-toplevel :execute) - (let ((method (smoke::make-smoke-method-from-name (find-class 'qt:byte-array) - "data"))) - (defmethod cxx:data ((array qt:byte-array)) - (values ;; Discarge second return value (length of string) - (foreign-string-to-lisp (smoke::pointer-call method - (smoke::pointer array)) - :count (cxx:size array)))))) - -(defmethod translate-from-foreign (string (type qstring)) - (cxx:data (make-instance 'qt:byte-array - :pointer (qt-smoke-qstring-to-byte-array string)))) - -(defmethod free-translated-object (pointer (type qstring) param) - (declare (ignore param)) - (qt-smoke-free-qstring pointer)) + (let ((method (smoke::make-smoke-method-from-name (find-class 'qt:byte-array) + "constData"))) + (defmethod cxx:const-data ((array qt:byte-array)) + (values ;; Discharge second return value (length of string) + (foreign-string-to-lisp (smoke::pointer-call method + (smoke::pointer array)) + :count (cxx:size array)))))) + +(defun from-qstring (qstring) + (cxx:const-data (make-instance 'qt:byte-array + :pointer (cl-smoke-qstring-to-byte-array qstring)))) + +(define-to-lisp-translation ("QString" "const QString&") + from-qstring cl-smoke-free-qstring) (defun coerce-qstring (string) (make-cleanup-pointer (with-foreign-string ((data length) string :null-terminated-p nil) - (qt-smoke-string-to-qstring data length)) - #'(lambda (pointer) - (free-translated-object pointer (make-instance 'qstring) - nil)))) + (cl-smoke-string-to-qstring data length)) + #'cl-smoke-free-qstring)) (define-from-lisp-translation ("const QString&" "QString") string coerce-qstring) + +(defmethod print-object ((object qt:byte-array) stream) + (if (null-pointer-p (pointer object)) + (call-next-method) + (print-unreadable-object (object stream :type t :identity t) + (when (smoke::const-p object) + (princ "CONST " stream)) + (prin1 (cxx:const-data object) stream)))) diff -rN -u old-qt.core/src/qt.core.lisp new-qt.core/src/qt.core.lisp --- old-qt.core/src/qt.core.lisp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/qt.core.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,39 @@ +;;; Copyright (C) 2009, 2010 Tobias Rautenkranz +;;; +;;; 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 . +;;; +;;; As a special exception, the copyright holders of this library give you +;;; permission to link this library with independent modules to produce an +;;; executable, regardless of the license terms of these independent +;;; modules, and to copy and distribute the resulting executable under +;;; terms of your choice, provided that you also meet, for each linked +;;; independent module, the terms and conditions of the license of that +;;; module. An independent module is a module which is not derived from or +;;; based on this library. If you modify this library, you may extend this +;;; exception to your version of the library, but you are not obligated to +;;; do so. If you do not wish to do so, delete this exception statement +;;; from your version. + +(in-package :cl-smoke.qt.core) + +(eval-when (:load-toplevel :compile-toplevel :execute) + (define-smoke-module :cl-smoke.qt libsmokeqtcore + (*qt-core-smoke* "qtcore_Smoke") + (init-qt-smoke "init_qtcore_Smoke")) + + (define-foreign-library libclsmokeqtcore + (:darwin "libclsmokeqtcore.dylib") + (:unix "libclsmokeqtcore.so") + (t (:default "libclsmokeqtcore"))) + (use-foreign-library libclsmokeqtcore)) diff -rN -u old-qt.core/src/qt.lisp new-qt.core/src/qt.lisp --- old-qt.core/src/qt.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/qt.lisp 1970-01-01 01:00:00.000000000 +0100 @@ -1,40 +0,0 @@ -;;; Copyright (C) 2009 Tobias Rautenkranz -;;; -;;; 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 . -;;; -;;; As a special exception, the copyright holders of this library give you -;;; permission to link this library with independent modules to produce an -;;; executable, regardless of the license terms of these independent -;;; modules, and to copy and distribute the resulting executable under -;;; terms of your choice, provided that you also meet, for each linked -;;; independent module, the terms and conditions of the license of that -;;; module. An independent module is a module which is not derived from or -;;; based on this library. If you modify this library, you may extend this -;;; exception to your version of the library, but you are not obligated to -;;; do so. If you do not wish to do so, delete this exception statement -;;; from your version. - -(in-package :cl-smoke.qt-impl) - -(define-smoke-module :cl-smoke.qt libsmokeqt - (*qt-smoke* "qt_Smoke") - (init-qt-smoke "init_qt_Smoke")) - - -(eval-when (:load-toplevel :compile-toplevel :execute) - #-mudballs - (define-foreign-library libqt-smoke-extra - (:unix "libqt-smoke-extra.so") - (t (:default "libqt-smoke-extra"))) - (use-foreign-library libqt-smoke-extra)) diff -rN -u old-qt.core/src/signal-slot/connect.lisp new-qt.core/src/signal-slot/connect.lisp --- old-qt.core/src/signal-slot/connect.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/signal-slot/connect.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defgeneric qt:connect (qsignal slot &optional type) (:documentation "Connects a signal to a slot.")) @@ -13,7 +13,9 @@ (assert (= (length signal-arguments) (length slot-arguments))) (loop for signal-arg in signal-arguments for slot-arg in slot-arguments do - (assert (subtypep signal-arg slot-arg)))) + (if (typep signal-arg 'smoke-type) + (assert (smoke-type= signal-arg slot-arg)) + (assert (subtypep signal-arg slot-arg))))) ;;FIXME check argument-types (defmethod qt:connect ((qsignal qsignal) (qslot qslot) &optional type) @@ -39,9 +41,10 @@ (defmethod qt:connect ((sender qsignal) (function function) &optional type) (let ((slot (make-instance 'qslot - :args (list (signal-object sender)) + :arg0 (signal-object sender) :argument-types (argument-types (signal-object sender)) :slot-function function))) + (unless (connect-id (signal-object sender) (id (signal-object sender)) slot (id slot) type @@ -63,6 +66,14 @@ :reader receiver)) (:documentation "Qt C++ slot.")) +(defmethod print-object ((qt-signal qt-signal) stream) + (print-unreadable-object (qt-signal stream :type t :identity t) + (when (slot-boundp qt-signal 'sender) + (princ (qsender qt-signal) stream)) + (princ " " stream) + (when (slot-boundp qt-signal 'name) + (princ (name qt-signal) stream)))) + (defgeneric qt:get-slot (receiver name) (:documentation "Returns the slot of RECEIVER with NAME.") (:method (receiver name) @@ -70,18 +81,18 @@ (:method (receiver (function function)) "Returns a slot for RECEIVER that calls function with RECEIVER as the first argument." - (let ((slot (qt:make-slot #'(lambda (&rest args) - (apply function (cxx:parent *this*) - args))))) - (cxx:set-parent slot receiver) - slot))) + (make-instance 'qslot + :arg0 receiver + :slot-function #'(lambda (&rest args) + (apply function (cxx:parent *this*) + args))))) (define-compiler-macro qt:get-slot (&whole form receiver name) "Normalize the slot name." (if (stringp name) (let ((normalized-name (cxx:data (qt:meta-object.normalized-signature name)))) - (if (string= name normalized-name) ;; Avoid loop + (if (string= name normalized-name) ;; Avoid infinite recursion form `(qt:get-slot ,receiver ,normalized-name))) form)) @@ -95,7 +106,7 @@ (if (stringp name) (let ((normalized-name (cxx:data (qt:meta-object.normalized-signature name)))) - (if (string= name normalized-name) ;; Avoid loop + (if (string= name normalized-name) ;; Avoid infinite recursion form `(qt:get-signal ,sender ,normalized-name))) form)) @@ -103,39 +114,43 @@ (defmethod qt:connect ((qt-signal qt-signal) (qt-slot qt-slot) &optional type) (unless (qt:object.connect (qsender qt-signal) (qt:qsignal (name qt-signal)) (receiver qt-slot) (qt:qslot (name qt-slot)) - (or type qt:+auto-connection+)) - (cerror "Failed to connect ~A ~A to ~A ~A." + (or type qt:+auto-connection+)) + (cerror "Ignore" + "Failed to connect ~A ~A to ~A ~A." (qsender qt-signal) (name qt-signal) (receiver qt-slot) (name qt-slot)))) (defmethod qt:disconnect ((qt-signal qt-signal) (qt-slot qt-slot)) (unless (qt:object.disconnect (qsender qt-signal) (qt:qsignal (name qt-signal)) - (receiver qt-slot) (qt:qslot (name qt-slot))) - (cerror "Failed to disconnect ~A ~A from ~A ~A." + (receiver qt-slot) (qt:qslot (name qt-slot))) + (cerror "Ignore" + "Failed to disconnect ~A ~A from ~A ~A." (receiver qt-slot) (name qt-slot) (qsender qt-signal) (name qt-signal)))) (defmethod qt:disconnect-all ((sender qt:object)) (unless (qt:object.disconnect sender 0 0 0) - (cerror "Failed to disconnect everything connected to ~A." + (cerror "Ignore" + "Failed to disconnect everything connected to ~A." sender))) (defmethod qt:connect ((qt-signal qt-signal) (function function) &optional type) (let* ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal))) (slot (make-instance 'qslot - ;; Set the sender as the slots parent, - ;; to ensure it does not get gc'ed. - ;; FIXME: unset parent on disconnect - ;; this no not critical beause the slot object - ;; is hidden from the user, who thus can not - ;; connect it to other signals. - :args (list (qsender qt-signal)) + :arg0 (qsender qt-signal) :slot-function function :argument-types - (method-arguments-type - (cxx:meta-object (qsender qt-signal)) - signal-id)))) + (method-arguments-type (qsender qt-signal) + signal-id)))) + ;; Ensure that the slot is not gc'ed as long as the QT-SIGNAL + ;; exists. + ;; + ;; FIXME: remove on disconnect. + ;; This no not critical because the slot + ;; object is not accessible to the user, + ;; who thus can not connect it to other + ;; signals. (if (connect-id (qsender qt-signal) signal-id slot (id slot) type (types (arguments slot))) @@ -147,13 +162,11 @@ (defmethod qt:connect ((qt-signal qt-signal) (slot qslot) &optional type) (let ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal)))) (if (slot-boundp slot 'arguments) - (check-argument-types (method-arguments-type (cxx:meta-object - (qsender qt-signal)) + (check-argument-types (method-arguments-type (qsender qt-signal) signal-id) (arguments slot)) (setf (slot-value slot 'arguments) - (method-arguments-type (cxx:meta-object (qsender qt-signal)) - signal-id))) + (method-arguments-type (qsender qt-signal) signal-id))) (if (connect-id (qsender qt-signal) signal-id slot (id slot) type (types (arguments slot))) @@ -166,12 +179,10 @@ (let ((slot-id (find-slot-id (receiver slot) (name slot)))) (if (slot-boundp (signal-object qsignal) 'argument-types) (check-argument-types (argument-types (signal-object slot)) - (method-arguments-type (cxx:meta-object - (receiver slot)) + (method-arguments-type (receiver slot) slot-id)) (setf (argument-types (signal-object qsignal)) - (method-arguments-type (cxx:meta-object (receiver slot)) - slot-id))) + (method-arguments-type (receiver slot) slot-id))) (unless (connect-id (signal-object qsignal) (id (signal-object qsignal)) (receiver slot) slot-id type @@ -183,8 +194,8 @@ (qt:meta-object.connect sender signal-id receiver slot-id (if (null type) - (value qt:+auto-connection+) - (value type)) + qt:+auto-connection+ + type) types)) (defun disconnect-id (sender signal-id receiver slot-id) diff -rN -u old-qt.core/src/signal-slot/signal-slot.lisp new-qt.core/src/signal-slot/signal-slot.lisp --- old-qt.core/src/signal-slot/signal-slot.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/signal-slot/signal-slot.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defclass funcallable-smoke-class (closer-mop:funcallable-standard-class diff -rN -u old-qt.core/src/signal-slot/signal.lisp new-qt.core/src/signal-slot/signal.lisp --- old-qt.core/src/signal-slot/signal.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/signal-slot/signal.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,5 +1,4 @@ -(in-package :cl-smoke.qt-impl) -(declaim (optimize (debug 3))) +(in-package :cl-smoke.qt.core) (defclass qsignal-mixin () ((signal-object :accessor signal-object @@ -49,18 +48,17 @@ argument-types)) (closer-mop:set-funcallable-instance-function object #'(lambda (&rest args) - (apply #'emit (signal-object object) args))) - ) + (apply #'emit (signal-object object) args)))) (defun find-slot-id (receiver slot) "Returns the ID of RECEIVER from SLOT." - ;; For efficency assume that SLOT is normalized and fallback - ;; to normalzing when not. (Just like Qt does.) + ;; For efficiency assume that SLOT is normalized and fallback to + ;; normalizing when not. (Just like Qt does.) (let ((id (cxx:index-of-slot (cxx:meta-object receiver) slot))) (when (< id 0) (setf id (cxx:index-of-slot (cxx:meta-object receiver) - (cxx:data (qt:meta-object.normalized-signature slot))))) + (qt:meta-object.normalized-signature slot)))) (when (< id 0) (error "No slot ~S for class ~S. The valid slots are: ~{~<~%~T~0,75:;~A ~>~}" @@ -70,52 +68,53 @@ (defun make-lisp-object (object) - (smoke::make-cleanup-pointer (make-cxx-lisp-object object) - #'qt-smoke-free-lisp-object)) + (make-cleanup-pointer (make-cxx-lisp-object object) + #'cl-smoke-free-lisp-object)) (defun convert-arguments (arguments types) "Returns a list of ARGUMENTS converted to TYPES." (mapcar #'(lambda (argument type) - (if (typep type 'smoke::smoke-type) - (smoke::convert-argument argument type) + (if (typep type 'smoke-type) + (smoke:convert-argument argument type) (progn (assert (typep argument type) () - "The argument ~S is not of type ~S.") + "The argument ~S is not of type ~S." + argument type) (make-lisp-object argument)))) arguments types)) (defun emit (qsignal &rest arguments) "Emits the signal QSIGNAL." -;;; The first element of args would be used for the return value -;;; by QMetaObject::invokeMethod(), but for signal-slot connection -;;; it is ignored. - (let ((types (argument-types qsignal))) - (smoke::with-stack (stack (convert-arguments arguments types) - types) - (cffi:with-foreign-object (args :pointer (1+ (length arguments))) - (loop for i from 1 to (smoke::size stack) - for type in (argument-types qsignal) - do + (activate qsignal (id qsignal) (argument-types qsignal) arguments)) + +(defun activate (object id types arguments) + ;;; The first element of args would be used for the return value by + ;;; QMetaObject::invokeMethod(), but for signal-slot connection it is + ;;; ignored. + (smoke::with-stack (stack (convert-arguments arguments types) + types) + (with-foreign-object (args :pointer (1+ (length arguments))) + (loop for i from 1 to (smoke:size stack) + for type in types + do (setf (mem-aref args :pointer i) - (if (or (not (typep type (find-class 'smoke::smoke-type))) - (= 0 (smoke::type-id type)) - (= 13 (smoke::type-id type))) + (if (or (not (typep type (find-class 'smoke-type))) + (= 0 (type-id type)) + (= 13 (type-id type))) (foreign-slot-value - (mem-aref (pointer stack) + (mem-aref (smoke::call-stack-pointer stack) 'smoke::smoke-stack-item i) 'smoke::smoke-stack-item 'smoke::voidp) (foreign-slot-pointer - (mem-aref (pointer stack) + (mem-aref (smoke::call-stack-pointer stack) 'smoke::smoke-stack-item i) 'smoke::smoke-stack-item 'smoke::voidp)))) - (setf (mem-aref args :pointer 0) - (null-pointer)) - (qt:meta-object.activate qsignal (cxx:meta-object qsignal) - (id qsignal) - args))))) + (setf (mem-aref args :pointer 0) + (null-pointer)) + (qt:meta-object.activate object id args)))) (defmethod qt:disconnect-all ((qsignal qsignal)) (unless (disconnect-id (signal-object qsignal) diff -rN -u old-qt.core/src/signal-slot/slot.lisp new-qt.core/src/signal-slot/slot.lisp --- old-qt.core/src/signal-slot/slot.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/signal-slot/slot.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,10 +1,10 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defclass qslot (qt:object) ((arguments :reader arguments :initarg :argument-types :documentation "List of the argument types for the slot.") (function :reader slot-function :initarg :slot-function - :initform (error "no function specified") + :initform (error "no slot function specified") :documentation "The function called when the slot is invoked.")) (:metaclass cxx:class) (:documentation "A Qt slot that calls its associated function")) @@ -30,6 +30,7 @@ (defmethod cxx:qt-metacall ((slot qslot) call id arguments) "Invoke the slots function when it is called. The return value of the invoked slot function is ignored." + (declare (ignore id)) (let ((id (call-next-method))) (if (< id 0) id @@ -48,13 +49,13 @@ (defun find-signal-id (sender signal) "Returns the ID of SIGNAL from SENDER." - ;; For efficency assume that SIGNAL is normalized and fallback - ;; to normalzing when not. (Just like Qt does.) + ;; For efficiency assume that SIGNAL is normalized and fallback to + ;; normalizing when not. (Just like Qt does.) (let ((id (cxx:index-of-signal (cxx:meta-object sender) signal))) (when (< id 0) (setf id (cxx:index-of-signal (cxx:meta-object sender) - (cxx:data (qt:meta-object.normalized-signature signal))))) + (qt:meta-object.normalized-signature signal)))) (when (< id 0) (error "No signal ~S for class ~S." signal (class-of sender))) diff -rN -u old-qt.core/src/signal-slot/translate.lisp new-qt.core/src/signal-slot/translate.lisp --- old-qt.core/src/signal-slot/translate.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/signal-slot/translate.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,22 +1,29 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(defun find-type (name &optional start end) - (smoke::make-smoke-type *smoke-module* (subseq name start end))) - -(defun method-arguments-type (metaobject index) - "Returns a type name list for the arguments of method INDEX of METAOBJECT." - (let* ((signature (cxx:signature (cxx:method metaobject index))) +(defun find-type (smoke-module name &optional start end) + (let ((type (make-smoke-type smoke-module (subseq name start end)))) + (assert (not (zerop (id type))) + () + "No type named ~S found in ~A." + (subseq name start end) smoke-module) + type)) + +(defun method-arguments-type (object index) + "Returns a type name list for the arguments of method INDEX of OBJECTs metaobject." + (let* ((metaobject (cxx:meta-object object)) + (signature (cxx:signature (cxx:method metaobject index))) (arguments (subseq signature (1+ (position #\( signature)) (position #\) signature :from-end t))) (argument-types ()) - (last-pos (length arguments))) + (last-pos (length arguments)) + (smoke-module (smoke (class-of object)))) (loop as pos = (position #\, arguments :from-end t :end last-pos) while pos do - (push (find-type arguments (1+ pos) last-pos) argument-types) - (setf last-pos pos)) + (push (find-type smoke-module arguments (1+ pos) last-pos) argument-types) + (setf last-pos pos)) (when (> last-pos 0) - (push (find-type arguments 0 last-pos) argument-types)))) + (push (find-type smoke-module arguments 0 last-pos) argument-types)))) (defun arguments-to-lisp2 (argument types values) @@ -27,7 +34,7 @@ (nconc values (list (typecase (first types) - (smoke::smoke-type + (smoke-type (pointer-to-lisp (mem-ref argument :pointer) (first types))) @@ -37,26 +44,26 @@ (defun disown-object (object) (tg:cancel-finalization object) - (unless (smoke::virtual-destructor-p (class-of object)) - (smoke::remove-object (pointer object))) + (unless (virtual-destructor-p (class-of object)) + (remove-object (pointer object))) object) (defun pointer-to-lisp (pointer type) "Returns the lisp value or object at POINTER of type TYPE." - (if (smoke::class-p type) - (if (smoke::pointer-p type) - (smoke::object-to-lisp (mem-ref pointer :pointer) type) - ;; By value means that they are allocated by the C++ signal - ;; code and have dynamic extend in the slot. The C++ singal code - ;; frees the object when the slot returns. - (disown-object (smoke::object-to-lisp pointer type))) - (ecase (smoke::type-id type) - (0 (let ((cffi-type (smoke::get-type (name type)))) - (if (null cffi-type) - (progn - pointer) - (convert-from-foreign pointer - cffi-type)))) + (if (class-p type) + (if (pointer-p type) + (object-to-lisp (mem-ref pointer :pointer) type) + ;; By-value means that the object at POINTER is allocated by + ;; the C++ signal code and has dynamic extend in the + ;; slot. The C++ signal code frees the object when the slot + ;; returns. + (disown-object (object-to-lisp pointer type))) + (ecase (type-id type) + (0 (if-let ((translation (gethash (name type) *to-lisp-translations*))) + ;; Do not free stack allocated stuff (e.g.: QString); that is the callers + ;; responisbility. + (funcall (car translation) pointer) + (error "Do not know how to convert the type ~A to Lisp." type))) (1 (mem-ref pointer 'cxx-bool)) (2 (code-char (mem-ref pointer :char))) (3 (code-char (mem-ref pointer :unsigned-char))) @@ -75,22 +82,23 @@ (defun arguments-to-lisp (arguments types) "Returns ARGUMENTS for a slot invocation as lisp objects." - (arguments-to-lisp2 (inc-pointer arguments ;; index 0 is for the return value - (foreign-type-size :pointer)) - types ())) + (arguments-to-lisp2 + (inc-pointer arguments ;; index 0 is for the return value + (foreign-type-size :pointer)) + types ())) (defun get-type (smoke-type) "Returns the QMetaType ID for SMOKE-TYPE." (typecase smoke-type - (smoke::smoke-standard-object - (if (smoke::pointer-p smoke-type) - (error "FOO");;qmetatype.+voidstar+ - (let ((type (qt:meta-type.type (smoke::name smoke-type)))) + (smoke-standard-object + (if (pointer-p smoke-type) + (error "Not implemented: pointer type.") ;;qmetatype.+voidstar+ + (let ((type (qt:meta-type.type (name smoke-type)))) (assert (/= 0 type) (type) "The type ~S has no QMetaType." - (smoke::name smoke-type)) + (name smoke-type)) type))) (t *cxx-lisp-object-metatype*))) @@ -98,7 +106,7 @@ (defun types (smoke-types) "Returns a newly allocated array of QMetaType IDs of SMOKE-TYPES." - ;;FIXME free TYPES on error. + ;; FIXME free TYPES on error. (let ((types (cffi:foreign-alloc :int :count (1+ (length smoke-types)))) (index 0)) (dolist (type smoke-types) diff -rN -u old-qt.core/src/string-list.lisp new-qt.core/src/string-list.lisp --- old-qt.core/src/string-list.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/string-list.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,61 +1,49 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) -(defcfun qt-smoke-string-list-size :int +(defcfun cl-smoke-string-list-size :int (string-list :pointer)) -(defcfun qt-smoke-string-list-at :pointer +(defcfun cl-smoke-string-list-at :pointer (string-list :pointer) (index :int)) -(defcfun qt-smoke-free-string-list :void +(defcfun cl-smoke-free-string-list :void (string-list :pointer)) -(defcfun qt-smoke-make-string-list :pointer) +(defcfun cl-smoke-make-string-list :pointer) -(defcfun qt-smoke-string-list-append :void +(defcfun cl-smoke-string-list-append :void (string-list :pointer) (string :pointer) (length :int)) -(define-foreign-type string-list () - () - (:actual-type :pointer)) - -(eval-when (:load-toplevel) - (smoke::add-type "QStringList" 'string-list) - (smoke::add-type "const QStringList&" 'string-list)) - - -(define-parse-method string-list () - (make-instance 'string-list)) - -(defmethod translate-to-foreign (sequence (type string-list)) - (let ((string-list (qt-smoke-make-string-list))) - (map nil #'(lambda (string) - (with-foreign-string ((data length) string :null-terminated-p nil) - (qt-smoke-string-list-append string-list data length))) - sequence) - string-list)) - - -(defmethod translate-from-foreign (string-list (type string-list)) - (let ((vector (make-array (qt-smoke-string-list-size string-list)))) +(defun from-string-list (string-list) + (let ((vector (make-array (cl-smoke-string-list-size string-list) + :initial-element "" + :element-type 'string))) (dotimes (index (length vector) vector) (setf (aref vector index) (cxx:data (make-instance 'qt:byte-array - :pointer (qt-smoke-string-list-at + :pointer (cl-smoke-string-list-at string-list index))))))) + +(define-to-lisp-translation ("QStringList" "const QStringList&") + from-string-list cl-smoke-free-string-list) + +(defun coerce-string-list (sequence) + (let ((string-list (cl-smoke-make-string-list))) + (map nil + #'(lambda (string) + (with-foreign-string ((data length) string :null-terminated-p nil) + (cl-smoke-string-list-append string-list data length))) + sequence) + (make-cleanup-pointer + string-list #'cl-smoke-free-string-list))) -(defmethod free-translated-object (string-list (type string-list) param) - (declare (ignore param)) - (qt-smoke-free-string-list string-list)) - -(defun coerce-string-list (list) - (make-cleanup-pointer - (translate-to-foreign list (make-instance 'string-list)) - #'(lambda (pointer) - (free-translated-object pointer (make-instance 'string-list) - nil)))) +(defun string-list-p (sequence) + (every #'stringp sequence)) (define-from-lisp-translation "const QStringList&" - (vector string) coerce-string-list) + (and (vector string) + (satisfies string-list-p)) + coerce-string-list) diff -rN -u old-qt.core/src/timer.lisp new-qt.core/src/timer.lisp --- old-qt.core/src/timer.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/timer.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defclass single-shot-timer (qt:object) ((function :initarg :function @@ -25,6 +25,7 @@ `(single-shot #'(lambda () ,@body))) (defmethod cxx:timer-event ((timer single-shot-timer) event) + (declare (ignore event)) (cxx:kill-timer timer (slot-value timer 'timer-id)) (funcall (slot-value timer 'function)) (remove timer *single-shot-timers*)) diff -rN -u old-qt.core/src/variant.lisp new-qt.core/src/variant.lisp --- old-qt.core/src/variant.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/src/variant.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,4 +1,4 @@ -(in-package :cl-smoke.qt-impl) +(in-package :cl-smoke.qt.core) (defmethod print-object ((variant qt:variant) stream) "Print the type and value of the variant." @@ -15,16 +15,16 @@ "Returns a new VARIANT containing a C++ version of VALUE or an empty variant when VALUE is not specified." (if value-p - (make-instance 'qt:variant :args (list value)) + (make-instance 'qt:variant :arg0 value) (make-instance 'qt:variant))) (defun qt:make-char (character) "Returns a char for a lisp CHARACTER." (let ((octets (babel:string-to-octets (string character)))) (case (length octets) - (1 (make-instance 'qt:char :args (list (aref octets 0)))) + (1 (make-instance 'qt:char :arg0 (aref octets 0))) (2 (make-instance 'qt:char :args (list (aref octets 0) - (aref octets 1)))) + (aref octets 1)))) (t (error "qt:char requires the character ~A to be encoded in one or two octets, but it is using ~A." character (length octets)))))) @@ -34,7 +34,7 @@ (cxx:is-low-surrogate char))) (defun qt:from-char (char) - "Returns the lisp character represented by CHAR." + "Returns the Lisp character represented by CHAR." (assert (not (surrogate-p char)) (char) "The char ~A is part of a surrogate.") @@ -54,11 +54,11 @@ (princ (qt:from-char char) stream)))) -;; FIXME include in MAKE-VARIANT? +;; FIXME include in MAKE-VARIANT? how?? (defun qt:make-lisp-variant (value) "Returns a new VARIANT that wraps VALUE. -The variant contains the actual Lisp object +The variant contains the actual Lisp object VALUE and not its C++ value like in MAKE-VARIANT." (let ((object (make-cxx-lisp-object value))) (unwind-protect @@ -66,48 +66,69 @@ object)) (free-cxx-lisp-object object)))) -(defcfun qt-smoke-lisp-object-value :pointer +(defcfun cl-smoke-lisp-object-value :pointer (variant :pointer)) (defun qt:variant-boundp (variant) "Returns true when VARIANT is valid (has a value) and false otherwise." (cxx:is-valid variant)) -(defmacro variant-conversions ((variant) &body types) - `(ecase (cxx:user-type ,variant) - - ,@(loop for type in types collect - (if (symbolp type) - `(,(value (symbol-value - (let ((*package* (find-package :cl-smoke.qt))) - (alexandria:symbolicate 'variant.+ type '+)))) - (,(intern (format nil "TO-~A" type) :cxx) ,variant)) - type)))) +(defun copy-object-from-pointer (class pointer) + (make-instance class :arg0 (make-instance class :pointer pointer))) -(defun qt:from-variant (variant) - "Returns the value of VARIANT." - (variant-conversions (variant) - (#.(value qt:variant.+invalid+) - (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant) - (values)) - bit-array bool byte-array - char - date date-time double - int - line line-f list locale long-long - point point-f - rect rect-f reg-exp - size size-f string string-list - time - uint - ulong-long - url - (#.*cxx-lisp-object-metatype* - (let* ((lisp-object (qt-smoke-lisp-object-value (smoke::pointer variant))) - (value)) - (setf value (translate-cxx-lisp-object lisp-object)) - (free-cxx-lisp-object lisp-object) - value)))) +(eval-startup () +;; *cxx-lisp-object-metatype* can change when loading an image +(eval ' + (macrolet + ((variant-conversions ((variant) &body types) + (let* ((special-types '(long-long ulong-long map list hash)) + (exclude-types + (append '(63) ;; ColorGroup + (mapcar #'(lambda (s) + (value + (symbol-value + (intern (format nil "VARIANT.+~A+" s) + :qt)))) + special-types))) + (qt-types (loop for i from 1 to (value qt:variant.+user-type+) + when (and (qt:variant.type-to-name i) + ;; type-to-name returns longlong but + ;; should be LongLong + (not (member i exclude-types))) + collect + (smoke::lispify (qt:variant.type-to-name i) + :qt)))) + `(ecase (cxx:user-type ,variant) + ,@(loop for type in (append special-types + (remove nil qt-types)) + collect + `(,(value (symbol-value + (let ((*package* + (find-package :cl-smoke.qt))) + (symbolicate 'variant.+ type '+)))) + ,(if (fboundp (intern (format nil "TO-~A" type) :cxx)) + `(,(intern (format nil "TO-~A" type) :cxx) ,variant) + `(copy-object-from-pointer + ;; intern since these types are in + ;; qt.gui not qt.core + (intern ,(symbol-name type) :qt) + (cxx:const-data ,variant))))) + ,@(loop for type in types + collect + `(,(eval (first type)) + ,@(rest type))))))) + (defun qt:from-variant (variant) + "Returns the value of VARIANT." + (variant-conversions (variant) + ((value qt:variant.+invalid+) + (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant) + (values)) + (*cxx-lisp-object-metatype* + (let* ((lisp-object (cl-smoke-lisp-object-value (pointer variant))) + (value)) + (setf value (translate-cxx-lisp-object lisp-object)) + (free-cxx-lisp-object lisp-object) + value))))))) (defmethod qt:value ((variant qt:variant)) "Returns the value of VARIANT." diff -rN -u old-qt.core/src/vector.lisp new-qt.core/src/vector.lisp --- old-qt.core/src/vector.lisp 1970-01-01 01:00:00.000000000 +0100 +++ new-qt.core/src/vector.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -0,0 +1,123 @@ +;; see: "Inside the Qt 4 Containers" +;; http://doc.trolltech.com/qq/qq19-containers.html#sequentialcontainers + +(in-package :cl-smoke.qt.core) + +(defcfun cl-smoke-make-qvector :pointer) +(defcfun cl-smoke-delete-qvector :void + (vector :pointer)) + +(defbitfield qvector-data-flags + :sharable + :capacity) + +(defcstruct qvector-data + (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int))) + (alloc :int) + (size :int) + (flags qvector-data-flags)) + +(defcstruct qvector-type-data + (ref :char :count #.(class-size (find-class 'qt:basic-atomic-int))) + (alloc :int) + (size :int) + (flags qvector-data-flags) + (array :pointer)) + +;; FIXME We assume QVector to be a POD struct, which is not +;; neccesarily the case. +(defcstruct qvector + (data (:pointer qvector-data))) + +(defun qvector-size (qvector) + (foreign-slot-value (foreign-slot-value qvector 'qvector 'data) + 'qvector-data 'size)) + +(defun qvector-elt (qvector index element-type) + (pointer-to-lisp + (cffi:inc-pointer + (foreign-slot-pointer (foreign-slot-value qvector 'qvector 'data) + 'qvector-type-data 'array) + (* index (type-size element-type))) + element-type)) + +(defun from-qvector (qvector element-type) + (let ((result (make-array (qvector-size qvector)))) + (dotimes (i (length result) result) + (setf (elt result i) + (qvector-elt qvector i element-type))))) + +(defcfun memcpy :pointer + (destination :pointer) + (source :pointer) + (size :unsigned-int)) + +(defun make-qvector (element-type elements) + (let* ((length (length elements)) + (element-size (type-size element-type)) + (data (foreign-alloc :char :count (+ (foreign-type-size 'qvector-data) + (* length element-size)))) + (darray (foreign-slot-pointer data 'qvector-type-data 'array)) + (vector (cl-smoke-make-qvector))) + (unless (stack-p element-type) + (error "FIXME: TODO")) + (if (class-p element-type) + (dotimes (i length) + (memcpy (inc-pointer darray (* i element-size)) + (pointer (elt elements i)) + element-size)) + (dotimes (i length) + (setf (mem-aref darray (type-foreign-keyword element-type) i) + (elt elements i)))) + (setf (mem-ref data :int) 1) ;; ref count + (with-foreign-slots ((ref alloc size flags) + data qvector-data) + (setf alloc length ;; allocated size + size length + flags :sharable) + (setf (foreign-slot-value vector 'qvector 'data) + data)) + vector)) + +(defun deref (basic-atomic-int-pointer) + ;; decrement and return true when the new value is non-zero + (cxx:deref + (make-instance 'qt:basic-atomic-int :pointer basic-atomic-int-pointer))) + +(defun free-qvector (vector) + (unless (null-pointer-p (foreign-slot-value vector 'qvector 'data)) + (let ((data (foreign-slot-value vector 'qvector 'data))) + (unless (deref (foreign-slot-pointer data 'qvector-type-data 'ref)) + (foreign-free data))) + (setf (foreign-slot-value vector 'qvector 'data) + (null-pointer))) + (cl-smoke-delete-qvector vector)) + +(defmacro define-qvector-translations (element-type lisp-type) + `(progn + (defun ,(symbolicate 'from-vector- element-type) (elements) + (make-cleanup-pointer + (make-qvector (make-smoke-type *smoke-module* ,element-type) + elements) + #'free-qvector)) + (defun ,(symbolicate 'vector- element-type '-p) (sequence) + (every #'(lambda (element) + (typep element ',lisp-type)) + sequence)) + (defun ,(symbolicate 'to-vector- element-type) (pointer) + (from-qvector pointer (make-smoke-type *smoke-module* ,element-type))) + (define-from-lisp-translation (,(format nil "QVector<~A>" element-type) + ;; FIXME QImage::setColorTable + ;; has an "const QVector" + ;; argument! + ,(format nil "const QVector<~A>" element-type) + ,(format nil "const QVector<~A>&" element-type)) + (and vector + (satisfies ,(symbolicate 'vector- element-type '-p))) + ,(symbolicate 'from-vector- element-type)) + (define-to-lisp-translation (,(format nil "QVector<~A>" element-type) + ,(format nil "const QVector<~A>&" element-type)) + ,(symbolicate 'to-vector- element-type) + free-qvector))) + +(define-qvector-translations "double" double-float) diff -rN -u old-qt.core/test.lisp new-qt.core/test.lisp --- old-qt.core/test.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/test.lisp 2014-11-25 14:24:52.000000000 +0100 @@ -1,25 +1,16 @@ #| +v v v v v v v +cmake ./ +make +************* +cmake ./ || exit 1 +make || exit 1 +^ ^ ^ ^ ^ ^ ^ exec -a "$0" sbcl --noinform --noprint --disable-debugger --load $0 --end-toplevel-options "$@" -# do not use --script to allow loading mudballs with ${HOME}/.sbclrc # Used for testing on darcs record. |# - -(in-package :sysdef-user) - -(defun load-sysdef (pathname system) - (load pathname) - (setf (mb.sysdef::pathname-of (find-system system)) pathname)) - -(defun load-sysdef-file (system-name) - "Loads a mbd file in the current directory." - (load-sysdef (make-pathname :defaults *default-pathname-defaults* - :name (string-downcase system-name) - :type "mbd") - system-name)) - -(load-sysdef-file :qt) -(mb:clean :qt) -(mb:test :qt) +(asdf:operate 'asdf:load-op :cl-smoke.qt.core) +(asdf:operate 'asdf:test-op :cl-smoke.qt.core) (sb-ext:quit) diff -rN -u old-qt.core/tests/test.lisp new-qt.core/tests/test.lisp --- old-qt.core/tests/test.lisp 2014-11-25 14:24:52.000000000 +0100 +++ new-qt.core/tests/test.lisp 1970-01-01 01:00:00.000000000 +0100 @@ -1 +0,0 @@ -(mb:test :qt.tests)