anchor.diff:      (let ((result (apply #'invoke-callback callback-id return-type args)))
         (when return-type
   	(gvalue-set return-value result)))))
  -
   
   (defun invoke-callback (callback-id return-type &rest args)
     (restart-case
  
positive.code:   (source-remove idle))
  
  
  ;;;; Signals
  
  (defbinding signal-lookup (name itype) unsigned-int
    ((signal-name-to-string name) string)
    (itype type-number))
  
  (defbinding signal-name () string
    (signal-id unsigned-int))
  
  (defun ensure-signal-id (signal-id instance)
    (etypecase signal-id
      (integer signal-id)
      (string (signal-lookup signal-id (type-number-of instance)))
      (symbol (signal-lookup signal-id (type-number-of instance)))))
    
  (defbinding signal-stop-emission (instance signal-id) nil
    (instance ginstance)
    ((ensure-signal-id signal-id instance) unsigned-int))
  
  ; (defbinding (signal-add-emisson-hook "g_signal_add_emission_hook_full")
  ;     () unsigned-int
  ;   (signal-id unsigned-int)
  ;   (closure gclosure))
  
  ; (defbinding signal-remove-emisson-hook () nil
  ;   (signal-id unsigned-int)
  ;   (hook-id unsigned-int))
  
  (defbinding (signal-has-handler-pending-p "g_signal_has_handler_pending")
      (instance signal-id &key detail blocked) boolean
    (instance ginstance)
    ((ensure-signal-id signal-id instance) unsigned-int)
    ((or detail 0) quark)
    (blocked boolean))
      
  (defbinding (signal-connect-closure "g_signal_connect_closure_by_id")
      (instance signal-id closure &key detail after) unsigned-int
    (instance ginstance)
    ((ensure-signal-id signal-id instance) unsigned-int)
    ((or detail 0) quark)
    (closure gclosure)
    (after boolean))
  
  (defbinding signal-handler-block () nil
    (instance ginstance)
    (handler unsigned-int))
  
  (defbinding signal-handler-unblock () nil
    (instance ginstance)
    (handler unsigned-int))
  
  (defbinding signal-handler-disconnect () nil
    (instance ginstance)
    (handler unsigned-int))
  
  
  (defmethod signal-connect ((gobject gobject) signal function &key after object)
  "Connects a callback function to a signal for a particular object. If :OBJECT 
   is T, the object connected to is passed as the first argument to the callback 
   function, or if :OBJECT is any other non NIL value, it is passed as the first 
   argument instead. If :AFTER is non NIL, the handler will be called after the 
   default handler for the signal."
    (when function
      (let ((callback-id
  	   (make-callback-closure
  	    (cond
  	      ((or (eq object t) (eq object gobject)) function)
  	      ((not object)
  	       #'(lambda (&rest args) (apply function (cdr args))))
  	      (t
  	       #'(lambda (&rest args) (apply function object (rest args))))))))
        (signal-connect-closure gobject signal callback-id :after after))))
  
  
  ;;; Message logging
  
  ;; TODO: define and signal conditions based on log-level
  ;(defun log-handler (domain log-level message)
  (def-callback log-handler (c-call:void (domain c-call:c-string) 
  				       (log-level c-call:int) 
  				       (message c-call:c-string))
  
negative.code:     (unwind-protect
  	 (progn ,@body)
        (destroy-user-data ,id))))
  