anchor.diff:  		    (let ((*signal-stop-emission* signal-stop-emission))
   		      (apply callback args)))))
         (multiple-value-bind (closure-id callback-id)
  -	  (make-callback-closure wrapper)
  +	  (make-callback-closure wrapper signal-handler-marshal)
   	(let ((handler-id (%signal-connect-closure-by-id 
   			   gobject signal-id detail-quark closure-id after)))
   	  (when remove
  
positive.code:     (if callback-id
  	(update-user-data callback-id function)
        (multiple-value-bind (callback-closure callback-id)
  	  (make-callback-closure function)
  	(%signal-override-class-closure signal-id type-number callback-closure)
  	(setf 
  	 (gethash (cons type-number signal-id) *overridden-signals*)
  
negative.code: 		for offset from 0 by +gvalue-size+
  		collect (gvalue-peek (pointer+ param-values offset)))))
      (unwind-protect
  	(multiple-value-bind (result aborted-p)
  	    (apply restart-wrapper callback-id nil args)
  	  (when (and return-type (not aborted-p))
  	    (gvalue-set return-value result)))
        ;; TODO: this should be made more general, by adding a type
        ;; method to return invalidating functions.
        (loop 
         for arg in args
         when (typep arg 'struct)
         do (invalidate-instance arg)))))
  
  (defun invoke-signal-handler (callback-id return-type &rest args)
    (declare (ignore return-type))
    (let* ((instance (first args))
  	 (handler-id (signal-handler-find instance '(:data) 
  		      0 0 nil nil callback-id)))
      (signal-handler-block instance handler-id)
      (unwind-protect
  	(restart-case (apply #'invoke-callback callback-id nil args)
  	  (abort () :report "Disconnect and exit signal handler"
  	    (when (signal-handler-is-connected-p instance handler-id)
  	      (signal-handler-disconnect instance handler-id))
  	    (values nil t))))
        (when (signal-handler-is-connected-p instance handler-id)
  	(signal-handler-unblock instance handler-id))))
  
  (defun invoke-callback (callback-id return-type &rest args)
    (restart-case (apply (find-user-data callback-id) args)
      (continue nil :report "Return from callback function"
        (cond
         (return-type
  	(format *query-io* "Enter return value of type ~S: " return-type)
  	(force-output *query-io*)
  	(eval (read *query-io*)))
         (t (values nil t))))
      (re-invoke nil :report "Re-invoke callback function"
        (apply #'invoke-callback callback-id return-type args))))
  
  
  ;;;; Timeouts and idle functions
  