Minor changes
authorespen <espen>
Wed, 26 Apr 2006 12:29:11 +0000 (12:29 +0000)
committerespen <espen>
Wed, 26 Apr 2006 12:29:11 +0000 (12:29 +0000)
gtk/gtk.lisp
gtk/gtkaction.lisp
gtk/gtkselection.lisp
gtk/gtktext.lisp

index f054449..4eb3604 100644 (file)
@@ -1,5 +1,5 @@
 ;; Common Lisp bindings for GTK+ v2.x
-;; Copyright 1999-2005 Espen S. Johnsen <espen@users.sf.net>
+;; Copyright 1999-2006 Espen S. Johnsen <espen@users.sf.net>
 ;;
 ;; Permission is hereby granted, free of charge, to any person obtaining
 ;; a copy of this software and associated documentation files (the
@@ -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: gtk.lisp,v 1.61 2006-04-25 13:37:29 espen Exp $
+;; $Id: gtk.lisp,v 1.62 2006-04-26 12:33:52 espen Exp $
 
 
 (in-package "GTK")
@@ -45,7 +45,7 @@
       (format nil "Gtk+ v~A.~A.~A" major minor micro))))
 
 (defun clg-version ()
-  "clg 0.92.1")
+  "clg 0.93pre")
 
 
 ;;;; Initalization
@@ -55,6 +55,8 @@
   (nil null)
   (nil null))
 
+(defparameter *event-poll-interval* 10000)
+
 (defun clg-init (&optional display)
   "Initializes the system and starts the event handling"
   #+sbcl(when (and 
       (error "Initialization of GTK+ failed."))
     (prog1
        (gdk:display-open display)
-      (add-fd-handler (gdk:display-connection-number) :input #'main-iterate-all)
-      (setq *periodic-polling-function* #'main-iterate-all)
-      (setq *max-event-to-sec* 0)
-      (setq *max-event-to-usec* 1000))))
+      #+(or cmu sbcl)
+      (progn
+       (add-fd-handler (gdk:display-connection-number) :input #'main-iterate-all)
+       (setq *periodic-polling-function* #'main-iterate-all)
+       (setq *max-event-to-sec* 0)
+       (setq *max-event-to-usec* *event-poll-interval*))
+      #+(and clisp readline)
+      ;; Readline will call the event hook at most ten times per second
+      (setf readline:event-hook #'main-iterate-all)
+      #+clisp      
+      ;; When running in Slime we need to hook into the Swank server
+      ;; to handle events asynchronously
+      (if (find-symbol "WAIT-UNTIL-READABLE" "SWANK")
+         (setf (symbol-function 'swank::wait-until-readable)
+          #'(lambda (stream)
+              (loop
+               (case (socket:socket-status (cons stream :input) 0 *event-poll-interval*)
+                 (:input (return t))
+                 (:eof (read-char stream))
+                 (otherwise (main-iterate-all))))))
+       #-readline(warn "Not running in Slime and Readline support is missing, so the Gtk main loop has to be invoked explicit.")))))
+
+#+sbcl   
+(defun clg-init-with-threading (&optional display)
+  "Initializes the system and starts the event handling"
+  (unless (gdk:display-get-default)
+    (gdk:gdk-init)
+    (gdk:threads-set-lock-functions)
+    (unless (gtk-init)
+      (error "Initialization of GTK+ failed."))
+    (sb-thread:make-thread 
+     #'(lambda () 
+        (gdk:display-open display)
+        (gdk:with-global-lock (main)))
+     :name "gtk event loop")))
 
 #+sbcl   
 (defun clg-init-with-threading (&optional display)
 
 ;;; About dialog
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (define-callback-marshal %about-dialog-activate-link-callback nil
     (about-dialog (link string)))
 (defbinding accel-group-connect-by-path (group path function) nil
   (group accel-group)
   (path string)
-  ((make-callback-closure function) gclosure :return))
+  ((make-callback-closure function) gclosure :in/return))
 
 (defbinding %accel-group-disconnect (group gclosure) boolean
   (group accel-group)
   (key unsigned-int)
   (modifiers gdk:modifier-type))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding accelerator-get-label () string
   (key unsigned-int)
   (modifiers gdk:modifier-type))
 
 ;;; Accel map
 
-(defbinding (accel-map-init "_gtk_accel_map_init") () nil)
-
 (defbinding %accel-map-add-entry () nil
   (path string)
   (key unsigned-int)
 
 (defbinding %accel-map-lookup-entry () boolean
   (path string)
-  ((make-instance 'accel-key) accel-key :return))
+  ((make-instance 'accel-key) accel-key :in/return))
 
 (defun accel-map-lookup-entry (path)
   (multiple-value-bind (found-p accel-key) (%accel-map-lookup-entry path)
 
 (defmethod initialize-instance ((button button) &rest initargs &key stock)
   (if stock
-      (apply #'call-next-method button :label stock :use-stock t initargs)
+      (apply #'call-next-method button 
+       :label stock :use-stock t :use-underline t initargs)
     (call-next-method)))
 
 
   (combo-box combo-box)
   (text string))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding combo-box-get-active-text () string
   (combo-box combo-box))
 
 
 (defmethod shared-initialize ((dialog dialog) names &rest initargs 
                              &key button buttons)
-  (declare (ignore button buttons))
+  (declare (ignore names button buttons))
   (prog1
       (call-next-method)
     (initial-apply-add dialog #'dialog-add-button initargs :button :buttons)))
   "Returns a numeric response id"
   (if (typep response 'response-type)
       (response-type-to-int response)
-    (let ((responses (object-data dialog 'responses)))
+    (let ((responses (user-data dialog 'responses)))
       (cond
        ((and responses (position response responses :test #'equal)))
        (create-p
          (1- (length responses)))
         (t
          (setf 
-          (object-data dialog 'responses)
+          (user-data dialog 'responses)
           (make-array 1 :adjustable t :fill-pointer t 
                       :initial-element response))
          0)))
   "Finds a symbolic response given a numeric id"
   (if (< id 0)
       (int-to-response-type id)
-    (aref (object-data dialog 'responses) id)))
+    (aref (user-data dialog 'responses) id)))
 
 
 (defmethod compute-signal-id ((dialog dialog) signal)
   ((dialog-response-id dialog response nil t) int)
   (sensitive boolean))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding alternative-dialog-button-order-p (&optional screen) boolean
   (screen (or null gdk:screen)))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding (dialog-set-alternative-button-order 
             "gtk_dialog_set_alternative_button_order_from_array")
     (dialog new-order) nil
        new-order) (vector int)))
 
 
-#+gtk2.8
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.8.0")
 (progn
   (defbinding %dialog-get-response-for-widget () int
     (dialog dialog)
 (defbinding entry-completion-complete () nil
   (completion entry-completion))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding entry-completion-insert-prefix () nil
   (completion entry-completion))
 
   (prog1
       (call-next-method)
     (when pixbuf-formats
-      #-gtk2.6(warn "Initarg :PIXBUF-FORMATS not supportet in this version of Gtk")
-      #+gtk2.6(file-filter-add-pixbuf-formats file-filter))
+      #?-(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
+      (warn "Initarg :PIXBUF-FORMATS not supportet in this version of Gtk")
+      #?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
+      (file-filter-add-pixbuf-formats file-filter))
     (initial-add file-filter #'file-filter-add-mime-type
      initargs :mime-type :mime-types)
     (initial-add file-filter #'file-filter-add-pattern
   (filter file-filter)
   (pattern string))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding file-filter-add-pixbuf-formats () nil
   (filter file-filter))
 
     ((or list vector) (make-instance 'image :pixmap source))
     (gdk:pixmap (make-instance 'image :pixmap source :mask mask))))
 
-#+gtk2.8
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.8.0")
 (defbinding image-clear () nil
   (image image))
 
 
 ;;; Menu tool button
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding menu-tool-button-set-arrow-tooltip () nil
   (menu-tool-button menu-tool-button)
   (tooltips tooltips)
   (%message-dialog-new transient-parent flags message-type buttons))
 
 
-(defmethod shared-initialize ((dialog message-dialog) names
-                             &key text #+gtk 2.6 secondary-text)
+(defmethod shared-initialize ((dialog message-dialog) names &key text 
+                             #?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
+                             secondary-text)
   (declare (ignore names))
   (when text
     (message-dialog-set-markup dialog text))
-  #+gtk2.6
+  #?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
   (when secondary-text
     (message-dialog-format-secondary-markup dialog secondary-text))
   (call-next-method))
   (message-dialog message-dialog)
   (markup string))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding message-dialog-format-secondary-text () nil
   (message-dialog message-dialog)
   (text string))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding message-dialog-format-secondary-markup () nil
   (message-dialog message-dialog)
   (markup string))
        (not (zerop (length (window-title window)))))
       (print-unreadable-object (window stream :type t :identity nil)
         (format stream "~S at 0x~X" 
-        (window-title window) (sap-int (foreign-location window))))
+        (window-title window) (pointer-address (foreign-location window))))
     (call-next-method)))
 
 (defbinding window-set-wmclass () nil
   (window window)
   (event gdk:key-event))
 
-#-gtk2.8
+#?-(pkg-exists-p "gtk+-2.0" :atleast-version "2.8.0")
 (defbinding window-present () nil
   (window window))
 
-#+gtk2.8
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.8.0")
 (progn
   (defbinding %window-present () nil
     (window window))
      (t (notebook-get-nth-page notebook position))))
 
 (defbinding (notebook-insert "gtk_notebook_insert_page_menu")
-    (notebook position child tab-label &optional menu-label) nil
+    (notebook position child &optional tab-label menu-label) nil
   (notebook notebook)
   (child widget)
   ((if (stringp tab-label)
        (make-instance 'label :label tab-label)
-     tab-label) widget)
+     tab-label) (or null widget))
   ((if (stringp menu-label)
        (make-instance 'label :label menu-label)
      menu-label) (or null widget))
   ((%ensure-notebook-position notebook position) position))
 
-(defun notebook-append (notebook child tab-label &optional menu-label)
+(defun notebook-append (notebook child &optional tab-label menu-label)
   (notebook-insert notebook :last child tab-label menu-label))
 
-(defun notebook-prepend (notebook child tab-label &optional menu-label)
+(defun notebook-prepend (notebook child &optional tab-label menu-label)
   (notebook-insert notebook :first child tab-label menu-label))
   
 (defbinding notebook-remove-page (notebook page) nil
     (notebook-get-nth-page notebook (notebook-current-page-num notebook))))
 
 (defun (setf notebook-current-page) (page notebook)
-  (setf (notebook-current-page notebook) (notebook-page-num notebook page)))
+  (setf (notebook-current-page-num notebook) (notebook-page-num notebook page)))
 
 (defbinding (notebook-tab-label "gtk_notebook_get_tab_label")
     (notebook page) widget
   child)
   
 (define-callback %menu-detach-callback nil ((widget widget) (menu menu))
-  (funcall (object-data menu 'detach-func) widget menu))
+  (funcall (user-data menu 'detach-func) widget menu))
 
 (defbinding %menu-attach-to-widget (menu widget) nil
   (menu menu)
   (%menu-detach-callback callback))
 
 (defun menu-attach-to-widget (menu widget function)
-  (setf (object-data menu 'detach-func) function)
+  (setf (user-data menu 'detach-func) function)
   (%menu-attach-to-widget menu widget))
 
 (defbinding menu-detach () nil
   (menu menu))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding menu-get-for-attach-widget () (copy-of (glist widget))
   (widget widget))
 
   (%tool-item-set-proxy-menu-item menu-item-id tool-item menu-item)
    menu-item)
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding tool-item-rebuild-menu () nil
   (tool-item tool-item))
 
   (editable editable)
   (text string)
   ((length text) int)
-  (position position :in-out))
+  (position position :in/out))
 
 (defun editable-append-text (editable text)
   (editable-insert-text editable text nil))
 (defbinding %stock-item-free () nil
   (location pointer))
 
-(defmethod reference-foreign ((class (eql (find-class 'stock-item))) location)
-  (%stock-item-copy location))
-
-(defmethod unreference-foreign ((class (eql (find-class 'stock-item))) location)
-  (%stock-item-free location))
-
 (defbinding stock-add (stock-item) nil
   (stock-item stock-item)
   (1 unsigned-int))
   (location pointer))
 
 (defun stock-lookup (stock-id)
-  (with-allocated-memory (stock-item (foreign-size (find-class 'stock-item)))
+  (with-memory (stock-item (foreign-size (find-class 'stock-item)))
     (when (%stock-lookup stock-id stock-item)
       (ensure-proxy-instance 'stock-item (%stock-item-copy stock-item)))))
 
-#+gtk2.8
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.8.0")
 (progn
   (define-callback-marshal %stock-translate-callback string ((path string)))
 
index 9dff11c..c8c80d7 100644 (file)
@@ -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: gtkaction.lisp,v 1.8 2006-02-28 16:30:37 espen Exp $
+;; $Id: gtkaction.lisp,v 1.9 2006-04-26 12:32:04 espen Exp $
 
 
 (in-package "GTK")
@@ -33,7 +33,7 @@
     (apply #'signal-connect action 'activate (mklist callback))))
 
 (defmethod action-accelerator ((action action))
-  (object-data action 'accelerator))
+  (user-data action 'accelerator))
 
 (defbinding (action-is-sensitive-p "gtk_action_is_sensitive") () boolean
   (action action))
@@ -85,7 +85,7 @@
 
 (defmethod initialize-instance ((action radio-action) &key group)
   (call-next-method)
-  (setf (slot-value action 'self) (sap-int (foreign-location action)))
+  (setf (slot-value action 'self) (pointer-address (foreign-location action)))
   (when group
     (add-to-radio-group action group)))
 
index 8b72f49..d3e7ec2 100644 (file)
@@ -1,5 +1,5 @@
 ;; Common Lisp bindings for GTK+ v2.x
-;; Copyright 2005 Espen S. Johnsen <espen@users.sf.net>
+;; Copyright 2005-2006 Espen S. Johnsen <espen@users.sf.net>
 ;;
 ;; Permission is hereby granted, free of charge, to any person obtaining
 ;; a copy of this software and associated documentation files (the
@@ -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: gtkselection.lisp,v 1.8 2006-04-10 18:54:47 espen Exp $
+;; $Id: gtkselection.lisp,v 1.9 2006-04-26 12:30:30 espen Exp $
 
 
 (in-package "GTK")
 (defbinding %target-list-unref () nil
   (location pointer))
 
-(defmethod reference-foreign ((class (eql (find-class 'target-list))) location)
-  (declare (ignore class))
-  (%target-list-ref location))
-
-(defmethod unreference-foreign ((class (eql (find-class 'target-list))) location)
-  (declare (ignore class))
-  (%target-list-unref location))
-
 (defbinding %target-list-new () pointer
   (targets (vector (inlined target-entry)))
   ((length targets) int))
@@ -66,7 +58,7 @@
      (target-entry 1))
    int))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (defbinding target-list-add-text-targets (target-list info &optional writable-p) nil
     (target-list target-list)
 (defbinding selection-data-get-text () string
   (selection-data selection-data))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (defbinding selection-data-set-pixbuf () boolean
     (selection-data selection-data)
   (targets (vector gdk:atom n-atoms))
   (n-atoms int))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding selection-data-targets-include-image-p (selection-data &optional writable-p) boolean
   (selection-data selection-data)
   (writable-p boolean))
   (text string)
   ((length text) int))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-set-image () nil
   (clipboard clipboard)
   (pixbuf gdk:pixbuf))
 (defun clipboard-set (clipboard object)
   (etypecase object
     (string (clipboard-set-text clipboard object))
-    #+gtk2.6
+    #?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
     (gdk:pixbuf (clipboard-set-image clipboard object))))
 
 (define-callback-marshal %clipboard-receive-callback nil 
   (%clipboard-text-receive-callback callback)
   ((register-callback-function callback) unsigned-int))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (define-callback-marshal %clipboard-image-receive-callback nil 
     ((:ignore clipboard) (image gdk:pixbuf)))
 (define-callback %clipboard-targets-receive-callback nil
     ((clipboard pointer) (atoms (vector gdk:atom n-atoms))
      (n-atoms unsigned-int) (callback-id unsigned-int))
-  (declare (ignore clipboard n-atoms))
+  (declare (ignore clipboard))
   (funcall (find-user-data callback-id) atoms))
 
 (defbinding clipboard-request-targets (clipboard callback) nil
 (defbinding clipboard-wait-for-text () string
   (clipboard clipboard))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-wait-for-image () (referenced gdk:pixbuf)
   (clipboard clipboard))
 
 (defbinding clipboard-wait-is-text-available-p () boolean
   (clipboard clipboard))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-wait-is-image-available-p () boolean
   (clipboard clipboard))
 
   (targets (vector gdk:atom n-targets) :out)
   (n-targets unsigned-int :out))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-wait-is-target-available-p () boolean
   (clipboard clipboard)
   (target gdk:atom))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-set-can-store () nil
   (clipboard clipboard)
   (targets (vector gdk:atom))
   ((length targets) int))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding clipboard-store () nil
   (clipboard clipboard))
 
   (widget widget)
   (targets target-list))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (defbinding drag-dest-add-text-targets () nil
     (widget widget))
 (defbinding drag-source-get-target-list () target-list
   (widget widget))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (progn
   (defbinding drag-source-add-text-targets () nil
     (widget widget))
index 2a28816..d8cb360 100644 (file)
@@ -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: gtktext.lisp,v 1.7 2006-02-19 19:31:15 espen Exp $
+;; $Id: gtktext.lisp,v 1.8 2006-04-26 12:29:11 espen Exp $
 
 
 (in-package "GTK")
@@ -91,7 +91,7 @@
   (end text-iter)
   (default-editable boolean))
 
-#+gtk2.6
+#?(pkg-exists-p "gtk+-2.0" :atleast-version "2.6.0")
 (defbinding text-buffer-backspace () boolean
   (buffer text-buffer)
   (iter text-iter)
 (defbinding text-buffer-get-iter-at-line-offset 
     (buffer line offset &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (line int)
   (offset int))
 
 (defbinding text-buffer-get-iter-at-offset 
     (buffer offset &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   ((case offset
      (:start 0)
      (:end -1)
 (defbinding text-buffer-get-iter-at-line 
     (buffer line &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (line int))
 
 (defbinding text-buffer-get-iter-at-line-index 
     (buffer line index &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (line int)
   (index int))
 
 (defbinding text-buffer-get-iter-at-mark 
     (buffer mark &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (mark text-mark))
 
 (defun text-buffer-get-iter-at-insert (buffer &optional (iter (make-instance 'text-iter)))
 (defbinding text-buffer-get-iter-at-child-anchor 
     (buffer anchor &optional (iter (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (anchor text-child-anchor))
 
 (defbinding text-buffer-get-bounds 
     (buffer &optional (start (make-instance 'text-iter))
      (end (make-instance 'text-iter))) nil
   (buffer text-buffer)
-  (start text-iter :return)
-  (end text-iter :return))
+  (start text-iter :in/return)
+  (end text-iter :in/return))
 
 (defbinding text-buffer-delete-selection () boolean
   (buffer text-buffer)
     (buffer &optional (start (make-instance 'text-iter))
      (end (make-instance 'text-iter))) boolean
   (buffer text-buffer)
-  (start text-iter :return)
-  (end text-iter :return))
+  (start text-iter :in/return)
+  (end text-iter :in/return))
 
 (defbinding text-buffer-begin-user-action () nil
   (buffer text-buffer))
 (defbinding text-iter-get-attributes 
     (iter &optional (values (make-instance 'text-attributes))) boolean
   (iter text-iter)
-  (values text-attributes :return))
+  (values text-attributes :in/return))
 
 (defbinding text-iter-get-language () pango:language
   (iter text-iter))
   (iter text-iter)
   (text string)
   (flags text-search-flags)
-  (match-start text-iter :return)
-  (match-end text-iter :return)
+  (match-start text-iter :in/return)
+  (match-end text-iter :in/return)
   (limit (or null text-iter)))
 
 (defbinding text-iter-backward-search 
   (iter text-iter)
   (text string)
   (flags text-search-flags)
-  (match-start text-iter :return)
-  (match-end text-iter :return)
+  (match-start text-iter :in/return)
+  (match-end text-iter :in/return)
   (limit (or null text-iter)))
 
 (defbinding text-iter-equal-p () boolean
 (defbinding text-view-get-visible-rect 
     (text-view &optional (rect (make-instance 'gdk:rectangle))) nil
   (text-view text-view)
-  (rect gdk:rectangle :return))
+  (rect gdk:rectangle :in/return))
 
 (defbinding text-view-get-iter-location 
     (text-view iter &optional (location (make-instance 'gdk:rectangle))) nil
   (text-view text-view)
   (iter text-iter)
-  (location gdk:rectangle :return))
+  (location gdk:rectangle :in/return))
 
 (defbinding text-view-get-line-at-y 
     (text-view y &optional (iter (make-instance 'text-iter))) nil
   (text-view text-view)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (y int)
   (line-top int :out))
 
 (defbinding text-view-get-iter-at-location 
     (text-view x y &optional (iter (make-instance 'text-iter))) nil
   (text-view text-view)
-  (iter text-iter :return)
+  (iter text-iter :in/return)
   (x int)
   (y int))