X-Git-Url: https://git.distorted.org.uk/~mdw/clg/blobdiff_plain/3005806e61162b6f55a29bd7b40fcf2bcc8c35fc..fa30048e45d3d71f09ac0b963f7cc7d1c7769475:/glib/gcallback.lisp

diff --git a/glib/gcallback.lisp b/glib/gcallback.lisp
index 2d0d5a6..6fdf198 100644
--- a/glib/gcallback.lisp
+++ b/glib/gcallback.lisp
@@ -20,7 +20,7 @@
 ;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-;; $Id: gcallback.lisp,v 1.28 2006-02-06 18:12:19 espen Exp $
+;; $Id: gcallback.lisp,v 1.34 2006-04-25 21:57:44 espen Exp $
 
 (in-package "GLIB")
 
@@ -29,27 +29,26 @@
 
 ;;;; Callback invokation
 
+(deftype gclosure () 'pointer)
+(register-type 'gclosure '|g_closure_get_type|)
+
 (defun register-callback-function (function)
   (check-type function (or null symbol function))
   (register-user-data function))
 
 ;; Callback marshal for regular signal handlers
-(defcallback closure-marshal (nil
-			      (gclosure pointer)
-			      (return-value gvalue)
-			      (n-params unsigned-int) 
-			      (param-values pointer)
-			      (invocation-hint pointer) 
-			      (callback-id unsigned-int))
+(define-callback closure-marshal nil
+    ((gclosure gclosure) (return-value gvalue) (n-params unsigned-int) 
+     (param-values pointer) (invocation-hint pointer) 
+     (callback-id unsigned-int))
   (declare (ignore gclosure invocation-hint))
   (callback-trampoline callback-id n-params param-values return-value))
 
 ;; Callback function for emission hooks
-(defcallback signal-emission-hook (nil
-				   (invocation-hint pointer)
-				   (n-params unsigned-int) 
-				   (param-values pointer)
-				   (callback-id unsigned-int))
+(define-callback signal-emission-hook nil
+    ((invocation-hint pointer) (n-params unsigned-int) (param-values pointer)
+     (callback-id unsigned-int))
+  (declare (ignore invocation-hint))
   (callback-trampoline callback-id n-params param-values))
 
 (defun callback-trampoline (callback-id n-params param-values &optional
@@ -59,14 +58,16 @@
 	 (args (loop
 		for n from 0 below n-params
 		for offset from 0 by +gvalue-size+
-		collect (gvalue-get (sap+ param-values offset) t))))
+		collect (gvalue-peek (pointer+ param-values offset)))))
     (unwind-protect
 	(let ((result (apply #'invoke-callback callback-id return-type args)))
 	  (when return-type
 	    (gvalue-set return-value result)))
+      ;; TODO: this should be made more general, by adding a type
+      ;; method to return invalidate functions.
       (loop 
        for arg in args
-       when (typep arg 'proxy)
+       when (typep arg 'struct)
        do (invalidate-instance arg)))))
 
 
@@ -93,16 +94,16 @@
 (defbinding source-remove () boolean
   (tag unsigned-int))
 
-(defcallback source-callback-marshal (nil (callback-id unsigned-int))
+(define-callback source-callback-marshal nil ((callback-id unsigned-int))
   (callback-trampoline callback-id 0 nil))
 
 (defbinding (timeout-add "g_timeout_add_full")
     (interval function &optional (priority +priority-default+)) unsigned-int 
   (priority int)
   (interval unsigned-int)
-  ((callback source-callback-marshal) pointer)
+  (source-callback-marshal callback)
   ((register-callback-function function) unsigned-long)
-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))
 
 (defun timeout-remove (timeout)
   (source-remove timeout))
@@ -110,9 +111,9 @@
 (defbinding (idle-add "g_idle_add_full")
     (function &optional (priority +priority-default-idle+)) unsigned-int 
   (priority int)
-  ((callback source-callback-marshal) pointer)
+  (source-callback-marshal callback)
   ((register-callback-function function) unsigned-long)
-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))
 
 (defun idle-remove (idle)
   (source-remove idle))
@@ -166,7 +167,7 @@
 (defbinding signal-query 
     (signal-id &optional (signal-query (make-instance 'signal-query))) nil
   (signal-id unsigned-int)
-  (signal-query signal-query :return))
+  (signal-query signal-query :in/return))
 
 (defun signal-param-types (info)
   (with-slots (n-params param-types) info
@@ -219,16 +220,14 @@
   (args pointer)
   (return-value (or null gvalue)))
 
-;; TODO: implement same semantics as CALL-NEXT-METHOD
-(defun %call-next-handler (n-params types args defaults return-type)
+
+(defun %call-next-handler (n-params types args return-type)
   (let ((params (allocate-memory (* n-params +gvalue-size+))))
     (loop 
-     as tmp = args then (rest tmp)
-     for default in defaults
+     for arg in args
      for type in types
      for offset from 0 by +gvalue-size+
-     as arg = (if tmp (car tmp) default)
-     do (gvalue-init (sap+ params offset) type arg))
+     do (gvalue-init (pointer+ params offset) type arg))
 
     (unwind-protect
 	(if return-type
@@ -239,7 +238,7 @@
 	(loop
 	 repeat n-params
 	 for offset from 0 by +gvalue-size+
-	 do (gvalue-unset (sap+ params offset)))
+	 do (gvalue-unset (pointer+ params offset)))
 	(deallocate-memory params)))))
 
 
@@ -253,15 +252,16 @@
 		until (eq arg '&rest)
 		collect arg))
 	 (rest (cadr (member '&rest args)))
-	 (next (make-symbol "ARGS")))
+	 (next (make-symbol "ARGS"))
+	 (default (make-symbol "DEFAULT")))
 
     `(progn
        (signal-override-class-closure ',name ',class 
 	#'(lambda (,object ,@args)
-	    (flet ((call-next-handler (&rest ,next)
-		     (let ((defaults (list* ,object ,@vars ,rest)))
+	    (let ((,default (list* ,object ,@vars ,rest)))
+	      (flet ((call-next-handler (&rest ,next)
 		       (%call-next-handler 
-			,n-params ',types ,next defaults ',return-type))))
+			,n-params ',types (or ,next ,default) ',return-type))))
 	      ,@body)))
        ',name)))
 
@@ -284,9 +284,9 @@
     unsigned-int
   ((ensure-signal-id-from-type signal type) unsigned-int)
   (detail quark)
-  ((callback signal-emission-hook) pointer)
+  (signal-emission-hook callback)
   ((register-callback-function function) unsigned-int)
-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))
 
 (defbinding signal-remove-emission-hook (type signal hook-id) nil
   ((ensure-signal-id-from-type signal type) unsigned-int)
@@ -323,20 +323,15 @@
   (instance ginstance)
   (handler-id unsigned-int))
 
-(deftype gclosure () 'pointer)
-(register-type 'gclosure "GClosure")
-
 (defbinding (callback-closure-new "clg_callback_closure_new") () gclosure
   (callback-id unsigned-int) 
-  (callback pointer)
-  (destroy-notify pointer))
+  (callback callback)
+  (destroy-notify callback))
 
 (defun make-callback-closure (function)
   (let ((callback-id (register-callback-function function)))
     (values
-     (callback-closure-new 
-      callback-id (callback closure-marshal) 
-      (callback user-data-destroy-func))
+     (callback-closure-new callback-id closure-marshal user-data-destroy-callback)
      callback-id)))
 
 (defgeneric compute-signal-function (gobject signal function object))
@@ -421,7 +416,7 @@ once."
 	      (loop
 	       for arg in (cons object args)
 	       for type in param-types
-	       as tmp = params then (sap+ tmp +gvalue-size+)
+	       as tmp = params then (pointer+ tmp +gvalue-size+)
 	       do (gvalue-init tmp type arg)	      
 	       finally 
 	       (if return-type
@@ -431,7 +426,7 @@ once."
 		 (%signal-emitv params signal-id detail (make-pointer 0))))
 	    (loop
 	     repeat n-params
-	     as tmp = params then (sap+ tmp +gvalue-size+)
+	     as tmp = params then (pointer+ tmp +gvalue-size+)
 	     while (gvalue-p tmp)
 	     do (gvalue-unset tmp)))))))
 
@@ -450,16 +445,34 @@ once."
 
 ;;;; Convenient macros
 
-(defmacro def-callback-marshal (name (return-type &rest args))
-  (let ((names (loop 
-		for arg in args 
-		collect (if (atom arg) (gensym) (first arg))))
-	(types (loop 
-		for arg in args 
-		collect (if (atom arg) arg (second arg)))))
-    `(defcallback ,name (,return-type ,@(mapcar #'list names types)
-			 (callback-id unsigned-int))
-      (invoke-callback callback-id ',return-type ,@names))))
+(defmacro define-callback-marshal (name return-type args &key (callback-id :last))
+  (let* ((ignore ())
+	 (params ())
+	 (names (loop 
+		 for arg in args 
+		 collect (if (or 
+			      (eq arg :ignore) 
+			      (and (consp arg) (eq (first arg) :ignore)))
+			     (let ((name (gensym "IGNORE")))
+			       (push name ignore)
+			       name)
+			   (let ((name (if (atom arg)
+					   (gensym (string arg))
+					 (first arg))))
+			     (push name params)
+			     name))))
+	 (types (loop 
+		 for arg in args 
+		 collect (cond
+			  ((eq arg :ignore) 'pointer)
+			  ((atom arg) arg)
+			  (t (second arg))))))
+    `(define-callback ,name ,return-type 
+       ,(ecase callback-id
+	  (:first `((callback-id unsigned-int) ,@(mapcar #'list names types)))
+	  (:last `(,@(mapcar #'list names types) (callback-id unsigned-int))))
+       (declare (ignore ,@ignore))
+       (invoke-callback callback-id ',return-type ,@(nreverse params)))))
 
 (defmacro with-callback-function ((id function) &body body)
   `(let ((,id (register-callback-function ,function)))