[clg] / glib / gtype.lisp

;; Common Lisp bindings for GTK+ v2.0
;; Copyright (C) 2000-2001 Espen S. Johnsen <esj@stud.cs.uit.no>
;;
;; This library is free software; you can redistribute it and/or
;; modify it under the terms of the GNU Lesser General Public
;; License as published by the Free Software Foundation; either
;; version 2 of the License, or (at your option) any later version.
;;
;; This library 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
;; Lesser General Public License for more details.
;;
;; You should have received a copy of the GNU Lesser General Public
;; License along with this library; if not, write to the Free Software
;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

;; $Id: gtype.lisp,v 1.29 2005-03-11 20:16:07 espen Exp $

(in-package "GLIB")

(use-prefix "g")

;; Initialize the glib type system
(defbinding type-init () nil)
(type-init)

(deftype type-number () '(unsigned 32))

(deftype gtype () 'symbol)

(defmethod alien-type ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (alien-type 'type-number))

(defmethod size-of ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (size-of 'type-number))

(defmethod to-alien-form (gtype (type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  `(find-type-number ,gtype t)) 

(defmethod to-alien-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  #'(lambda (gtype)
      (find-type-number gtype t)))

(defmethod from-alien-form (type-number (type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  `(type-from-number ,type-number)) 

(defmethod from-alien-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  #'(lambda (type-number)
      (type-from-number type-number)))

(defmethod writer-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (let ((writer (writer-function 'type-number)))
    #'(lambda (gtype location &optional (offset 0))
	(funcall writer (find-type-number gtype t) location offset))))

(defmethod reader-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (let ((reader (reader-function 'type-number)))
    #'(lambda (location &optional (offset 0))
	(type-from-number (funcall reader location offset)))))


(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass type-query (struct)
    ((type-number :allocation :alien :type type-number)
     (name :allocation :alien :type string)
     (class-size :allocation :alien :type unsigned-int)
     (instance-size :allocation :alien :type unsigned-int))
    (:metaclass struct-class)))


(defbinding type-query (type) nil
  ((find-type-number type t) type-number)
  ((make-instance 'type-query) type-query :return))

(defun type-instance-size (type)
  (slot-value (type-query type) 'instance-size))

(defun type-class-size (type)
  (slot-value (type-query type) 'class-size))

(defbinding type-class-ref (type) pointer
  ((find-type-number type t) type-number))

(defbinding type-class-unref (type) nil
  ((find-type-number type t) type-number))

(defbinding type-class-peek (type) pointer
  ((find-type-number type t) type-number))


;;;; Mapping between lisp types and glib types

(defvar *registered-types* ())
(defvar *registered-type-aliases* ())
(defvar *lisp-type-to-type-number* (make-hash-table))
(defvar *type-number-to-lisp-type* (make-hash-table))

(defbinding %type-from-name () type-number
  (name string))

(defun type-number-from-glib-name (name &optional (error-p t))
  (let ((type-number (%type-from-name name)))
    (cond
     ((not (zerop type-number)) type-number)
     (error-p (error "Invalid gtype name: ~A" name)))))

(defun register-type (type id)
  (pushnew (cons type id) *registered-types* :key #'car)
  (let ((type-number 
	 (typecase id
	   (string (type-number-from-glib-name id))
	   (symbol (funcall id)))))
       (setf (gethash type *lisp-type-to-type-number*) type-number)
       (setf (gethash type-number *type-number-to-lisp-type*) type)
       type-number))

(defun register-type-alias (type alias)
  (pushnew (cons type alias) *registered-type-aliases* :key #'car)
  (setf 
   (gethash type *lisp-type-to-type-number*)
   (find-type-number alias t)))

(defun reinitialize-all-types ()
  (clrhash *lisp-type-to-type-number*)
  (clrhash *type-number-to-lisp-type*)
  (type-init) ; initialize the glib type system
  (mapc #'(lambda (type) 
	    (register-type (car type) (cdr type)))
	*registered-types*)
  (mapc #'(lambda (type) 
	    (register-type-alias (car type) (cdr type)))
	*registered-type-aliases*))

(pushnew 'reinitialize-all-types 
  #+cmu *after-save-initializations*
  #+sbcl *init-hooks*)

#+cmu
(pushnew 'system::reinitialize-global-table ; we shouldn't have to do this?
 *after-save-initializations*)


(defun find-type-number (type &optional error-p)
  (etypecase type
    (integer type)
    (string (type-number-from-glib-name type error-p))
    (symbol
     (or
      (gethash type *lisp-type-to-type-number*)
      (and error-p (error "Type not registered: ~A" type))))
    (class (find-type-number (class-name type) error-p))))
 
(defun type-from-number (type-number &optional error)
  (multiple-value-bind (type found)
      (gethash type-number *type-number-to-lisp-type*)
    (when (and error (not found))
      (let ((name (find-foreign-type-name type-number)))
	(if name
	    (error "Type number not registered: ~A (~A)" type-number name)
	  (error "Invalid type number: ~A" type-number))))
    type))

(defbinding (find-foreign-type-name "g_type_name") (type) (copy-of string)
  ((find-type-number type t) type-number))

(defun type-number-of (object)
  (find-type-number (type-of object) t))

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defvar *type-initializers* ())
  (defun %find-types-in-library (pathname prefixes ignore)
    (let ((process (run-program
		    "/usr/bin/nm" (list "--defined-only" "-D" (namestring (truename pathname)))
		    :output :stream :wait nil)))
      (unwind-protect
	  (loop 
	   as symbol = (let ((line (read-line (process-output process) nil)))
			 (when line (subseq line 11)))			  
	   while symbol
	   when (and
		 (> (length symbol) 9)
		 (or 
		  (not prefixes)
		  (some #'(lambda (prefix)
			    (and
			     (> (length symbol) (length prefix))
			     (string= prefix symbol :end2 (length prefix))))
			(mklist prefixes)))
		 (string= "_get_type" symbol :start2 (- (length symbol) 9))
		 (not (member symbol ignore :test #'string=)))
	   collect symbol)
	(process-close process)))))


(defmacro init-types-in-library (filename &key prefix ignore)
  (let ((names (%find-types-in-library filename prefix ignore)))
    `(progn
       ,@(mapcar #'(lambda (name)
		     `(progn
			(defbinding (,(intern name) ,name) () type-number)
			(,(intern name))
			(pushnew ',(intern name) *type-initializers*)))
		 names))))

(defun find-type-init-function (type-number)
  (loop
   for type-init in *type-initializers*
   when (= type-number (funcall type-init))
   do (return type-init)))

(defun register-type-as (type-number)
  (or 
   (find-type-init-function type-number)
   (find-foreign-type-name type-number)
   (error "Unknown type-number: ~A" type-number)))

(defun default-type-init-name (type)
  (find-symbol (format nil "~A_~A_get_type" 
		(package-prefix *package*)
		(substitute #\_ #\- (string-downcase type)))))


;;;; Metaclass for subclasses of ginstance

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass ginstance-class (proxy-class)
    ()))


(defmethod shared-initialize ((class ginstance-class) names &key name gtype)
  (declare (ignore names))
  (let* ((class-name (or name (class-name class)))
	 (type-number 
	  (or 
	   (find-type-number class-name)
	   (register-type class-name 
	     (or (first gtype) (default-type-init-name class-name))))))
    (call-next-method)
    (when (slot-boundp class 'size)
      (setf (slot-value class 'size) (type-instance-size type-number)))))


(defmethod validate-superclass ((class ginstance-class) (super standard-class))
  (subtypep (class-name super) 'ginstance))


;;;; Superclass for wrapping types in the glib type system

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass ginstance (proxy)
    ((class :allocation :alien :type pointer))
    (:metaclass proxy-class)))

(defun %type-number-of-ginstance (location)
  (let ((class (sap-ref-sap location 0)))
    (sap-ref-32 class 0)))

(defmethod ensure-proxy-instance ((class ginstance-class) location)
  (declare (ignore class))
  (let ((class (labels ((find-known-class (type-number)
		          (or
			   (find-class (type-from-number type-number) nil)
			   (unless (zerop type-number)
			     (find-known-class (type-parent type-number))))))
		 (find-known-class (%type-number-of-ginstance location)))))
    (if class
	(make-instance class :location (reference-foreign class location))
      (error "Object at ~A has an unkown type number: ~A" 
        location (%type-number-of-ginstance location)))))

(defmethod copy-from-alien-form (location (class ginstance-class) &rest args)
  (declare (ignore location class args))
  (error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))

(defmethod copy-from-alien-function ((class ginstance-class) &rest args)
  (declare (ignore class args))  
  (error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))

(defmethod reader-function ((class ginstance-class) &rest args)
  (declare (ignore args))
  #'(lambda (location &optional (offset 0))
      (ensure-proxy-instance class (sap-ref-sap location offset))))


;;;; Registering fundamental types

(register-type 'nil "void")
(register-type 'pointer "gpointer")
(register-type 'char "gchar")
(register-type 'unsigned-char "guchar")
(register-type 'boolean "gboolean")
(register-type 'int "gint")
(register-type-alias 'fixnum 'int)
(register-type 'unsigned-int "guint")
(register-type 'long "glong")
(register-type 'unsigned-long "gulong")
(register-type 'single-float "gfloat")
(register-type 'double-float "gdouble")
(register-type 'pathname "gchararray")
(register-type 'string "gchararray")


;;;; Introspection of type information

(defvar *derivable-type-info* (make-hash-table))

(defun register-derivable-type (type id expander &optional dependencies)
  (register-type type id)
  (let ((type-number (register-type type id)))
    (setf 
     (gethash type-number *derivable-type-info*) 
     (list expander dependencies))))

(defun find-type-info (type)
  (dolist (super (cdr (type-hierarchy type)))
    (let ((info (gethash super *derivable-type-info*)))
      (return-if info))))

(defun expand-type-definition (type forward-p options)
  (let ((expander (first (find-type-info type))))
    (funcall expander (find-type-number type t) forward-p options)))

(defbinding type-parent (type) type-number
  ((find-type-number type t) type-number))

(defun supertype (type)
  (type-from-number (type-parent type)))

(defbinding %type-interfaces (type) pointer
  ((find-type-number type t) type-number)
  (n-interfaces unsigned-int :out))

(defun type-interfaces (type)
  (multiple-value-bind (array length) (%type-interfaces type)
    (unwind-protect
	(map-c-vector 'list #'identity array 'type-number length)
      (deallocate-memory array))))

(defun implements (type)
  (mapcar #'type-from-number (type-interfaces type)))

(defun type-hierarchy (type)
  (let ((type-number (find-type-number type t)))
    (unless (= type-number 0)
      (cons type-number (type-hierarchy (type-parent type-number))))))
  
(defbinding (type-is-p "g_type_is_a") (type super) boolean
  ((find-type-number type) type-number)
  ((find-type-number super) type-number))

(defbinding %type-children () pointer
  (type-number type-number)
  (num-children unsigned-int :out))

(defun map-subtypes (function type &optional prefix)
  (let ((type-number (find-type-number type t)))
    (multiple-value-bind (array length) (%type-children type-number)
      (unwind-protect
	  (map-c-vector
	   'nil
	   #'(lambda (type-number)
	       (when (or
		      (not prefix)
		      (string-prefix-p prefix (find-foreign-type-name type-number)))
		 (funcall function type-number))
	       (map-subtypes function type-number prefix))
	   array 'type-number length)
	(deallocate-memory array)))))

(defun find-types (prefix)
  (let ((type-list nil))
    (maphash
     #'(lambda (type-number expander)
	 (declare (ignore expander))
	 (map-subtypes
	  #'(lambda (type-number)
	      (pushnew type-number type-list))
	  type-number prefix))
     *derivable-type-info*)
    type-list))

(defun find-type-dependencies (type)
  (let ((list-dependencies (second (find-type-info type))))
    (when list-dependencies
      (funcall list-dependencies (find-type-number type t)))))

(defun %sort-types-topologicaly (types)
  (let ((partial-sorted
	 (sort
	  (mapcar 
	   #'(lambda (type)
	       (cons type (remove-if #'(lambda (dep)
					 (not (find dep types)))
				     (find-type-dependencies type))))
	   types)
	  #'(lambda (type1 type2) (type-is-p type2 type1)) :key #'car))
	(sorted ()))

    (loop
     as tmp = partial-sorted then (or (rest tmp) partial-sorted)
     while tmp
     do (destructuring-bind (type . dependencies) (first tmp)
	  (cond
	   ((every #'(lambda (dep)
		       (assoc dep sorted))
		   dependencies)
	    (push (cons type nil) sorted) ; no forward definition needed
	    (setq partial-sorted (delete type partial-sorted :key #'first)))
	   ((some #'(lambda (dep)
		      (find type (find-type-dependencies dep)))
		  dependencies)
	    (push (cons type t) sorted) ; forward definition needed
	    (setq partial-sorted (delete type partial-sorted :key #'first))))))
    (nreverse sorted)))


(defun expand-type-definitions (prefix &optional args)
  (flet ((type-options (type-number)
	   (let ((name (find-foreign-type-name type-number)))
	     (cdr (assoc name args :test #'string=)))))

   (let ((type-list
	  (delete-if
	   #'(lambda (type-number)
	       (let ((name (find-foreign-type-name type-number)))
		 (or
		  (getf (type-options type-number) :ignore)
		  (find-if
		   #'(lambda (options)
		       (and
			(string-prefix-p (first options) name)
			(getf (cdr options) :ignore-prefix)
			(not (some
			      #'(lambda (exception)
				  (string= name exception))
			      (getf (cdr options) :except)))))
		   args))))
	   (find-types prefix))))

     (dolist (type-number type-list)
       (let ((name (find-foreign-type-name type-number)))
	 (register-type
	  (getf (type-options type-number) :type (default-type-name name))
	  (register-type-as type-number))))

     (let ((sorted-type-list (%sort-types-topologicaly type-list)))
       `(progn
	  ,@(mapcar
	     #'(lambda (pair)
		 (destructuring-bind (type . forward-p) pair
		   (expand-type-definition type forward-p (type-options type))))
	     sorted-type-list)
	  ,@(mapcar
	     #'(lambda (pair)
		 (destructuring-bind (type . forward-p) pair
		   (when forward-p
		     (expand-type-definition type nil (type-options type)))))
	     sorted-type-list))))))

(defmacro define-types-by-introspection (prefix &rest args)
  (expand-type-definitions prefix args))


;;;; Initialize all non static types in GObject

(init-types-in-library #.(concatenate 'string (pkg-config:pkg-variable "glib-2.0" "libdir") "/libgobject-2.0.so"))
Commit	Line	Data
560af5c5	1	;; Common Lisp bindings for GTK+ v2.0
d4b21b08	2	;; Copyright (C) 2000-2001 Espen S. Johnsen <esj@stud.cs.uit.no>
560af5c5	3	;;
	4	;; This library is free software; you can redistribute it and/or
	5	;; modify it under the terms of the GNU Lesser General Public
	6	;; License as published by the Free Software Foundation; either
	7	;; version 2 of the License, or (at your option) any later version.
	8	;;
	9	;; This library is distributed in the hope that it will be useful,
	10	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	;; Lesser General Public License for more details.
	13	;;
	14	;; You should have received a copy of the GNU Lesser General Public
	15	;; License along with this library; if not, write to the Free Software
	16	;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	17
895c9a9e	18	;; $Id: gtype.lisp,v 1.29 2005-03-11 20:16:07 espen Exp $
560af5c5	19
	20	(in-package "GLIB")
	21
	22	(use-prefix "g")
	23
e0349dbd	24	;; Initialize the glib type system
	25	(defbinding type-init () nil)
	26	(type-init)
560af5c5	27
	28	(deftype type-number () '(unsigned 32))
	29
e74cfcab	30	(deftype gtype () 'symbol)
	31
	32	(defmethod alien-type ((type (eql 'gtype)) &rest args)
	33	(declare (ignore type args))
	34	(alien-type 'type-number))
	35
	36	(defmethod size-of ((type (eql 'gtype)) &rest args)
	37	(declare (ignore type args))
	38	(size-of 'type-number))
	39
	40	(defmethod to-alien-form (gtype (type (eql 'gtype)) &rest args)
	41	(declare (ignore type args))
	42	`(find-type-number ,gtype t))
	43
	44	(defmethod to-alien-function ((type (eql 'gtype)) &rest args)
	45	(declare (ignore type args))
	46	#'(lambda (gtype)
	47	(find-type-number gtype t)))
	48
	49	(defmethod from-alien-form (type-number (type (eql 'gtype)) &rest args)
	50	(declare (ignore type args))
63752532	51	`(type-from-number ,type-number))
e74cfcab	52
	53	(defmethod from-alien-function ((type (eql 'gtype)) &rest args)
	54	(declare (ignore type args))
	55	#'(lambda (type-number)
63752532	56	(type-from-number type-number)))
e74cfcab	57
e74cfcab	58	(defmethod writer-function ((type (eql 'gtype)) &rest args)
73572c12	59	(declare (ignore type args))
e74cfcab	60	(let ((writer (writer-function 'type-number)))
	61	#'(lambda (gtype location &optional (offset 0))
	62	(funcall writer (find-type-number gtype t) location offset))))
	63
	64	(defmethod reader-function ((type (eql 'gtype)) &rest args)
73572c12	65	(declare (ignore type args))
e74cfcab	66	(let ((reader (reader-function 'type-number)))
e74cfcab	67	#'(lambda (location &optional (offset 0))
63752532	68	(type-from-number (funcall reader location offset)))))
e74cfcab	69
e74cfcab	70
93aa67db	71	(eval-when (:compile-toplevel :load-toplevel :execute)
d4b21b08	72	(defclass type-query (struct)
93aa67db	73	((type-number :allocation :alien :type type-number)
	74	(name :allocation :alien :type string)
	75	(class-size :allocation :alien :type unsigned-int)
	76	(instance-size :allocation :alien :type unsigned-int))
d168bafd	77	(:metaclass struct-class)))
93aa67db	78
93aa67db	79
e74cfcab	80	(defbinding type-query (type) nil
	81	((find-type-number type t) type-number)
	82	((make-instance 'type-query) type-query :return))
93aa67db	83
	84	(defun type-instance-size (type)
	85	(slot-value (type-query type) 'instance-size))
	86
	87	(defun type-class-size (type)
	88	(slot-value (type-query type) 'class-size))
560af5c5	89
d4b21b08	90	(defbinding type-class-ref (type) pointer
d4b21b08	91	((find-type-number type t) type-number))
560af5c5	92
d4b21b08	93	(defbinding type-class-unref (type) nil
d4b21b08	94	((find-type-number type t) type-number))
93aa67db	95
d4b21b08	96	(defbinding type-class-peek (type) pointer
d4b21b08	97	((find-type-number type t) type-number))
93aa67db	98
560af5c5	99
d4b21b08	100	;;;; Mapping between lisp types and glib types
560af5c5	101
dfa4f314	102	(defvar registered-types ())
	103	(defvar registered-type-aliases ())
	104	(defvar lisp-type-to-type-number (make-hash-table))
	105	(defvar type-number-to-lisp-type (make-hash-table))
d4b21b08	106
	107	(defbinding %type-from-name () type-number
	108	(name string))
	109
dfa4f314	110	(defun type-number-from-glib-name (name &optional (error-p t))
	111	(let ((type-number (%type-from-name name)))
	112	(cond
	113	((not (zerop type-number)) type-number)
	114	(error-p (error "Invalid gtype name: ~A" name)))))
	115
	116	(defun register-type (type id)
	117	(pushnew (cons type id) registered-types :key #'car)
	118	(let ((type-number
	119	(typecase id
	120	(string (type-number-from-glib-name id))
	121	(symbol (funcall id)))))
	122	(setf (gethash type lisp-type-to-type-number) type-number)
	123	(setf (gethash type-number type-number-to-lisp-type) type)
	124	type-number))
	125
	126	(defun register-type-alias (type alias)
	127	(pushnew (cons type alias) registered-type-aliases :key #'car)
	128	(setf
	129	(gethash type lisp-type-to-type-number)
	130	(find-type-number alias t)))
	131
	132	(defun reinitialize-all-types ()
	133	(clrhash lisp-type-to-type-number)
	134	(clrhash type-number-to-lisp-type)
	135	(type-init) ; initialize the glib type system
	136	(mapc #'(lambda (type)
	137	(register-type (car type) (cdr type)))
	138	registered-types)
	139	(mapc #'(lambda (type)
	140	(register-type-alias (car type) (cdr type)))
	141	registered-type-aliases))
	142
	143	(pushnew 'reinitialize-all-types
	144	#+cmu after-save-initializations
	145	#+sbcl init-hooks)
	146
	147	#+cmu
	148	(pushnew 'system::reinitialize-global-table ; we shouldn't have to do this?
	149	after-save-initializations)
	150
	151
	152	(defun find-type-number (type &optional error-p)
560af5c5	153	(etypecase type
560af5c5	154	(integer type)
dfa4f314	155	(string (type-number-from-glib-name type error-p))
d4b21b08	156	(symbol
dfa4f314	157	(or
	158	(gethash type lisp-type-to-type-number)
	159	(and error-p (error "Type not registered: ~A" type))))
	160	(class (find-type-number (class-name type) error-p))))
560af5c5	161
4de90d10	162	(defun type-from-number (type-number &optional error)
4de90d10	163	(multiple-value-bind (type found)
dfa4f314	164	(gethash type-number type-number-to-lisp-type)
4de90d10	165	(when (and error (not found))
dfa4f314	166	(let ((name (find-foreign-type-name type-number)))
4de90d10	167	(if name
	168	(error "Type number not registered: ~A (~A)" type-number name)
	169	(error "Invalid type number: ~A" type-number))))
	170	type))
560af5c5	171
dfa4f314	172	(defbinding (find-foreign-type-name "g_type_name") (type) (copy-of string)
d4b21b08	173	((find-type-number type t) type-number))
	174
	175	(defun type-number-of (object)
	176	(find-type-number (type-of object) t))
	177
21299acf	178	(eval-when (:compile-toplevel :load-toplevel :execute)
dfa4f314	179	(defvar type-initializers ())
dfa4f314	180	(defun %find-types-in-library (pathname prefixes ignore)
21299acf	181	(let ((process (run-program
	182	"/usr/bin/nm" (list "--defined-only" "-D" (namestring (truename pathname)))
	183	:output :stream :wait nil)))
	184	(unwind-protect
	185	(loop
	186	as symbol = (let ((line (read-line (process-output process) nil)))
	187	(when line (subseq line 11)))
	188	while symbol
	189	when (and
dfa4f314	190	(> (length symbol) 9)
	191	(or
	192	(not prefixes)
	193	(some #'(lambda (prefix)
	194	(and
	195	(> (length symbol) (length prefix))
	196	(string= prefix symbol :end2 (length prefix))))
	197	(mklist prefixes)))
	198	(string= "_get_type" symbol :start2 (- (length symbol) 9))
21299acf	199	(not (member symbol ignore :test #'string=)))
	200	collect symbol)
	201	(process-close process)))))
	202
560af5c5	203
735a29da	204	(defmacro init-types-in-library (filename &key prefix ignore)
21299acf	205	(let ((names (%find-types-in-library filename prefix ignore)))
	206	`(progn
	207	,@(mapcar #'(lambda (name)
	208	`(progn
	209	(defbinding (,(intern name) ,name) () type-number)
dfa4f314	210	(,(intern name))
dfa4f314	211	(pushnew ',(intern name) type-initializers)))
21299acf	212	names))))
21299acf	213
dfa4f314	214	(defun find-type-init-function (type-number)
735a29da	215	(loop
	216	for type-init in type-initializers
	217	when (= type-number (funcall type-init))
	218	do (return type-init)))
	219
	220	(defun register-type-as (type-number)
	221	(or
	222	(find-type-init-function type-number)
	223	(find-foreign-type-name type-number)
	224	(error "Unknown type-number: ~A" type-number)))
dfa4f314	225
	226	(defun default-type-init-name (type)
	227	(find-symbol (format nil "~A_~A_get_type"
	228	(package-prefix package)
	229	(substitute #\_ #\- (string-downcase type)))))
	230
21299acf	231
	232
	233	;;;; Metaclass for subclasses of ginstance
	234
	235	(eval-when (:compile-toplevel :load-toplevel :execute)
	236	(defclass ginstance-class (proxy-class)
	237	()))
	238
	239
dfa4f314	240	(defmethod shared-initialize ((class ginstance-class) names &key name gtype)
21299acf	241	(declare (ignore names))
21299acf	242	(let* ((class-name (or name (class-name class)))
dfa4f314	243	(type-number
	244	(or
	245	(find-type-number class-name)
	246	(register-type class-name
	247	(or (first gtype) (default-type-init-name class-name))))))
	248	(call-next-method)
	249	(when (slot-boundp class 'size)
	250	(setf (slot-value class 'size) (type-instance-size type-number)))))
4de90d10	251
4de90d10	252
21299acf	253	(defmethod validate-superclass ((class ginstance-class) (super standard-class))
	254	(subtypep (class-name super) 'ginstance))
	255
560af5c5	256
93aa67db	257	;;;; Superclass for wrapping types in the glib type system
560af5c5	258
560af5c5	259	(eval-when (:compile-toplevel :load-toplevel :execute)
93aa67db	260	(defclass ginstance (proxy)
d4b21b08	261	((class :allocation :alien :type pointer))
d4b21b08	262	(:metaclass proxy-class)))
560af5c5	263
895c9a9e	264	(defun %type-number-of-ginstance (location)
93aa67db	265	(let ((class (sap-ref-sap location 0)))
895c9a9e	266	(sap-ref-32 class 0)))
560af5c5	267
d168bafd	268	(defmethod ensure-proxy-instance ((class ginstance-class) location)
d168bafd	269	(declare (ignore class))
895c9a9e	270	(let ((class (labels ((find-known-class (type-number)
	271	(or
	272	(find-class (type-from-number type-number) nil)
	273	(unless (zerop type-number)
	274	(find-known-class (type-parent type-number))))))
	275	(find-known-class (%type-number-of-ginstance location)))))
d168bafd	276	(if class
d168bafd	277	(make-instance class :location (reference-foreign class location))
895c9a9e	278	(error "Object at ~A has an unkown type number: ~A"
895c9a9e	279	location (%type-number-of-ginstance location)))))
560af5c5	280
9ca5565a	281	(defmethod copy-from-alien-form (location (class ginstance-class) &rest args)
	282	(declare (ignore location class args))
	283	(error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))
	284
	285	(defmethod copy-from-alien-function ((class ginstance-class) &rest args)
	286	(declare (ignore class args))
	287	(error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))
	288
	289	(defmethod reader-function ((class ginstance-class) &rest args)
	290	(declare (ignore args))
	291	#'(lambda (location &optional (offset 0))
	292	(ensure-proxy-instance class (sap-ref-sap location offset))))
	293
560af5c5	294
d4b21b08	295	;;;; Registering fundamental types
d4b21b08	296
63752532	297	(register-type 'nil "void")
d4b21b08	298	(register-type 'pointer "gpointer")
	299	(register-type 'char "gchar")
	300	(register-type 'unsigned-char "guchar")
	301	(register-type 'boolean "gboolean")
d4b21b08	302	(register-type 'int "gint")
dfa4f314	303	(register-type-alias 'fixnum 'int)
d4b21b08	304	(register-type 'unsigned-int "guint")
	305	(register-type 'long "glong")
	306	(register-type 'unsigned-long "gulong")
	307	(register-type 'single-float "gfloat")
	308	(register-type 'double-float "gdouble")
a8cb9408	309	(register-type 'pathname "gchararray")
4de90d10	310	(register-type 'string "gchararray")
d4b21b08	311
d4b21b08	312
62f12808	313	;;;; Introspection of type information
d4b21b08	314
e77e7713	315	(defvar derivable-type-info (make-hash-table))
d4b21b08	316
62f12808	317	(defun register-derivable-type (type id expander &optional dependencies)
d4b21b08	318	(register-type type id)
e77e7713	319	(let ((type-number (register-type type id)))
62f12808	320	(setf
	321	(gethash type-number derivable-type-info)
	322	(list expander dependencies))))
d4b21b08	323
4de90d10	324	(defun find-type-info (type)
4de90d10	325	(dolist (super (cdr (type-hierarchy type)))
e77e7713	326	(let ((info (gethash super derivable-type-info)))
4de90d10	327	(return-if info))))
4de90d10	328
62f12808	329	(defun expand-type-definition (type forward-p options)
	330	(let ((expander (first (find-type-info type))))
	331	(funcall expander (find-type-number type t) forward-p options)))
d4b21b08	332
d4b21b08	333	(defbinding type-parent (type) type-number
	334	((find-type-number type t) type-number))
	335
	336	(defun supertype (type)
	337	(type-from-number (type-parent type)))
	338
337933d8	339	(defbinding %type-interfaces (type) pointer
	340	((find-type-number type t) type-number)
	341	(n-interfaces unsigned-int :out))
	342
	343	(defun type-interfaces (type)
	344	(multiple-value-bind (array length) (%type-interfaces type)
	345	(unwind-protect
d168bafd	346	(map-c-vector 'list #'identity array 'type-number length)
337933d8	347	(deallocate-memory array))))
	348
	349	(defun implements (type)
	350	(mapcar #'type-from-number (type-interfaces type)))
	351
d4b21b08	352	(defun type-hierarchy (type)
	353	(let ((type-number (find-type-number type t)))
	354	(unless (= type-number 0)
	355	(cons type-number (type-hierarchy (type-parent type-number))))))
	356
	357	(defbinding (type-is-p "g_type_is_a") (type super) boolean
	358	((find-type-number type) type-number)
	359	((find-type-number super) type-number))
	360
	361	(defbinding %type-children () pointer
	362	(type-number type-number)
	363	(num-children unsigned-int :out))
	364
	365	(defun map-subtypes (function type &optional prefix)
	366	(let ((type-number (find-type-number type t)))
	367	(multiple-value-bind (array length) (%type-children type-number)
	368	(unwind-protect
d168bafd	369	(map-c-vector
d4b21b08	370	'nil
	371	#'(lambda (type-number)
	372	(when (or
	373	(not prefix)
dfa4f314	374	(string-prefix-p prefix (find-foreign-type-name type-number)))
d4b21b08	375	(funcall function type-number))
	376	(map-subtypes function type-number prefix))
	377	array 'type-number length)
	378	(deallocate-memory array)))))
	379
	380	(defun find-types (prefix)
	381	(let ((type-list nil))
e77e7713	382	(maphash
	383	#'(lambda (type-number expander)
	384	(declare (ignore expander))
	385	(map-subtypes
	386	#'(lambda (type-number)
	387	(pushnew type-number type-list))
	388	type-number prefix))
	389	derivable-type-info)
d4b21b08	390	type-list))
d4b21b08	391
62f12808	392	(defun find-type-dependencies (type)
	393	(let ((list-dependencies (second (find-type-info type))))
	394	(when list-dependencies
	395	(funcall list-dependencies (find-type-number type t)))))
	396
	397	(defun %sort-types-topologicaly (types)
21299acf	398	(let ((partial-sorted
	399	(sort
	400	(mapcar
	401	#'(lambda (type)
	402	(cons type (remove-if #'(lambda (dep)
	403	(not (find dep types)))
	404	(find-type-dependencies type))))
	405	types)
	406	#'(lambda (type1 type2) (type-is-p type2 type1)) :key #'car))
62f12808	407	(sorted ()))
	408
	409	(loop
21299acf	410	as tmp = partial-sorted then (or (rest tmp) partial-sorted)
62f12808	411	while tmp
62f12808	412	do (destructuring-bind (type . dependencies) (first tmp)
d4b21b08	413	(cond
62f12808	414	((every #'(lambda (dep)
21299acf	415	(assoc dep sorted))
62f12808	416	dependencies)
21299acf	417	(push (cons type nil) sorted) ; no forward definition needed
21299acf	418	(setq partial-sorted (delete type partial-sorted :key #'first)))
62f12808	419	((some #'(lambda (dep)
	420	(find type (find-type-dependencies dep)))
	421	dependencies)
21299acf	422	(push (cons type t) sorted) ; forward definition needed
	423	(setq partial-sorted (delete type partial-sorted :key #'first))))))
	424	(nreverse sorted)))
d4b21b08	425
	426
	427	(defun expand-type-definitions (prefix &optional args)
dfa4f314	428	(flet ((type-options (type-number)
dfa4f314	429	(let ((name (find-foreign-type-name type-number)))
4de90d10	430	(cdr (assoc name args :test #'string=)))))
d4b21b08	431
e77e7713	432	(let ((type-list
	433	(delete-if
	434	#'(lambda (type-number)
dfa4f314	435	(let ((name (find-foreign-type-name type-number)))
e77e7713	436	(or
	437	(getf (type-options type-number) :ignore)
	438	(find-if
	439	#'(lambda (options)
	440	(and
	441	(string-prefix-p (first options) name)
80a09c29	442	(getf (cdr options) :ignore-prefix)
	443	(not (some
	444	#'(lambda (exception)
	445	(string= name exception))
	446	(getf (cdr options) :except)))))
e77e7713	447	args))))
e77e7713	448	(find-types prefix))))
21299acf	449
e77e7713	450	(dolist (type-number type-list)
dfa4f314	451	(let ((name (find-foreign-type-name type-number)))
e77e7713	452	(register-type
e77e7713	453	(getf (type-options type-number) :type (default-type-name name))
735a29da	454	(register-type-as type-number))))
21299acf	455
21299acf	456	(let ((sorted-type-list (%sort-types-topologicaly type-list)))
62f12808	457	`(progn
62f12808	458	,@(mapcar
21299acf	459	#'(lambda (pair)
	460	(destructuring-bind (type . forward-p) pair
	461	(expand-type-definition type forward-p (type-options type))))
	462	sorted-type-list)
62f12808	463	,@(mapcar
21299acf	464	#'(lambda (pair)
	465	(destructuring-bind (type . forward-p) pair
	466	(when forward-p
	467	(expand-type-definition type nil (type-options type)))))
62f12808	468	sorted-type-list))))))
e77e7713	469
d4b21b08	470	(defmacro define-types-by-introspection (prefix &rest args)
4de90d10	471	(expand-type-definitions prefix args))
21299acf	472
	473
	474	;;;; Initialize all non static types in GObject
	475
	476	(init-types-in-library #.(concatenate 'string (pkg-config:pkg-variable "glib-2.0" "libdir") "/libgobject-2.0.so"))