From d7df5fa0caf83043500796cc4253254263775c7e Mon Sep 17 00:00:00 2001 From: Mike Kestner Date: Thu, 25 Oct 2001 22:16:10 +0000 Subject: [PATCH] 2001-10-25 Mike Kestner * codegen/get-props-from-source.pl : Temporary (possibly) defs generator for props. Will probably kill this when the official defs support props. * codegen/defs-parse.pl : Added object-based aggregation of defs. Generate the class shells, methods, and props. * codegen/gdk-types.defs : ripped from pygtk. * codegen/gtk.defs : ripped from pygtk. * codegen/gtk-props.defs : some props defs. * codegen/makefile : add the new defs files. svn path=/trunk/gtk-sharp/; revision=1203 --- ChangeLog | 12 + codegen/defs-parse.pl | 297 +- codegen/gdk-types.defs | 912 ++ codegen/get-props-from-source.pl | 144 + codegen/gtk-props.defs | 282 + codegen/gtk.defs | 15379 +++++++++++++++++++++++++++++ codegen/makefile | 2 +- 7 files changed, 17005 insertions(+), 23 deletions(-) create mode 100644 codegen/gdk-types.defs create mode 100755 codegen/get-props-from-source.pl create mode 100644 codegen/gtk-props.defs create mode 100644 codegen/gtk.defs diff --git a/ChangeLog b/ChangeLog index 85e379f56..a9e8aab82 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,15 @@ +2001-10-25 Mike Kestner + + * codegen/get-props-from-source.pl : Temporary (possibly) defs + generator for props. Will probably kill this when the official + defs support props. + * codegen/defs-parse.pl : Added object-based aggregation of + defs. Generate the class shells, methods, and props. + * codegen/gdk-types.defs : ripped from pygtk. + * codegen/gtk.defs : ripped from pygtk. + * codegen/gtk-props.defs : some props defs. + * codegen/makefile : add the new defs files. + 2001-10-11 Mike Kestner * makefile : Add the codegen directory diff --git a/codegen/defs-parse.pl b/codegen/defs-parse.pl index 32e83a75b..3ba05efd2 100755 --- a/codegen/defs-parse.pl +++ b/codegen/defs-parse.pl @@ -1,56 +1,126 @@ #!/usr/bin/perl +# +# defs-parse.pl : Gtk+ defs format parser and code generator. +# +# Author: Mike Kestner +# +# 2001 Mike Kestner -while ($line = ) { +%maptypes = ( + 'none', "void", 'gboolean', "bool", 'gint', "int", 'guint', "uint", + 'guint32', "uint", 'const-gchar', "String", 'GObject', "GLib.Object", + 'gchar', "String"); - if ($line =~ /^\(define-(enum|flags)/) { - parse_enum_flags (); +%marshaltypes = ( + 'none', "void", 'gboolean', "bool", 'gint', "int", 'guint', "uint", + 'guint32', "uint", 'const-gchar', "IntPtr", 'GObject', "IntPtr", + 'gchar', "IntPtr"); + +while ($def = get_def()) { + + if ($def =~ /^\(define-(enum|flags)/) { + gen_enum (split (/\n/, $def)); + } elsif ($def =~ /^\(define-object (\w+)/) { + $name = $1; + $def =~ /c-name "(\w+)"/; + $cname=$1; + $def =~ s/\n\s*//g; + $objects{$cname} = $def; + $maptypes{$cname} = $name; + $marshaltypes{$cname} = "IntPtr"; + } elsif ($def =~ /^\(define-(prop|event|method)/) { + $def =~ /of-object "(\w+)"/; + $cname=$1; + $def =~ s/\n\s*//g; + $objects{$cname} .= "\n$def"; + } elsif ($def =~ /^\(define-(interface)/) { + # Nothing much to do here, I think. + } elsif ($def =~ /^\(define-(boxed|function)/) { + # Probably need to handle these though... + } else { + die "Unexpected definition $def\n"; } + } -sub parse_enum_flags () +foreach $key (sort (keys (%objects))) { + next if ($key !~ /(GtkBin|GtkButton|GtkContainer|GtkObject|GtkWidget|GtkWindow)$/); + gen_object (split (/\n/, $objects{$key})); +} + +############### +# subroutines +############### + +# Gets a single definition from the input stream. +sub get_def { + while ($line = ) { + next if ($line !~ /^\(define/); + $expr = $line; + do { + $line = ; + $expr .= $line; + } until ($line =~ /^\)/); + return $expr; + } + return; +} + +# Converts a dash or underscore separated name to StudlyCaps. +sub StudCaps +{ + my ($symb) = @_; + $symb =~ s/^([a-z])/\u\1/; + $symb =~ s/[-_]([a-z])/\u\1/g; + $symb =~ s/[-_](\d)/\1/g; + return $symb; +} + +# Code generation for the enum and flags definitions. +sub gen_enum +{ + my (@lines) = @_; + $line = $lines[$pos=0]; $line =~ /^\(define-(enum|flags) (\w+)/; $type = $1; $typename = $2; - $line = ; + $line = $lines[++$pos]; $line =~ /\(in-module "(\w+)"/; $namespace = $1; - do { $line = ; } until ($line =~ /\(values/); + $maptypes{"$namespace$typename"} = $typename; + $marshaltypes{"$namespace$typename"} = "int"; + + do { $line = $lines[++$pos]; } until ($line =~ /\(values/); @enums = (); - while ($line = ) { + while ($line = $lines[++$pos]) { last if ($line =~ /^\s*\)/); - if ($line =~ /\((.+)\)/) { ($name, $dontcare, $val) = split (/ /, $1); $name =~ s/\"//g; - $name =~ s/^([a-z])/\u\1/; - $name =~ s/\-([a-z])/\u\1/g; - $name =~ s/\-(\d)/\1/g; + $name = StudCaps ($name); @enums = (@enums, "$name:$val"); - } else { - die $line; } } - $dir = lc ($namespace); - if (! -e "../$dir") { - `mkdir ../$dir`; - } + $dir = "../generated/" . lc ($namespace); + `mkdir -p $dir`; - open (OUTFILE, ">../$dir/$typename.cs") || die "can't open file"; + open (OUTFILE, ">$dir/$typename.cs") || die "can't open file"; print OUTFILE "// Generated file: Do not modify\n\n"; print OUTFILE "namespace $namespace {\n\n"; print OUTFILE "\t/// $typename Enumeration \n"; - print OUTFILE "\t/// \n\t///\t Valid values:\n"; + print OUTFILE "\t/// Valid values:\n"; + print OUTFILE "\t///\t\n"; foreach $enum (@enums) { ($name) = split (/:/, $enum); - print OUTFILE "\t///\t\t$name\n" + print OUTFILE "\t///\t\t $name \n" } - print OUTFILE "\t/// \n\n"; + print OUTFILE "\t///\t\n\t/// \n\n"; if ($type eq "flags") { print OUTFILE "\tusing System;\n\n\t[Flags]\n"; @@ -71,7 +141,190 @@ sub parse_enum_flags () } print OUTFILE "\t}\n\n}\n"; - close (OUTFILE); } +# Code generation for objects. +sub gen_object +{ + my ($objdef, @defs) = @_; + my ($key, $typename, $parent, $dir, $namespace, $abstract, $def); + + $objdef =~ /define-object (\w+)/; + $typename = $1; + + $objdef =~ /parent "(\w+)"/; + $parent = $maptypes{$1}; + + $objdef =~ /in-module "(\w+)"/; + $dir = "../generated/" . lc ($namespace = $1); + `mkdir -p $dir`; + + %props = (); + %events = (); + %methods = (); + foreach $def (@defs) { + if ($def =~ /define-property (\w+)/) { + $props{StudCaps($1)} = $def; + }elsif ($def =~ /define-event (\w+)/) { + $events{StudCaps($1)} = $def; + }elsif ($def =~ /define-method (\w+)/) { + $methods{StudCaps($1)} = $def; + } + } + + print "Generating Class $typename in ../$dir/$typename.cs\n"; + open (OUTFILE, ">$dir/$typename.cs") || die "can't open file"; + + print OUTFILE "// Generated file: Do not modify\n\n"; + print OUTFILE "namespace $namespace {\n\n"; + print OUTFILE "\t/// $typename Class \n"; + print OUTFILE "\t/// \n\t///\t FIXME: Generate docs\n"; + print OUTFILE "\t/// \n\n"; + print OUTFILE "\tpublic "; + if ($abstract) { + print OUTFILE "abstract "; + } + print OUTFILE "class $typename : $parent {\n\n"; + + foreach $key (sort (keys (%props))) { + print OUTFILE gen_prop ($key, $props{$key}, "gtk-1.3.dll"); + } + + foreach $key (sort (keys (%methods))) { + print OUTFILE gen_method ($key, $methods{$key}, "gtk-1.3.dll"); + } + + print OUTFILE "\t}\n}\n"; + close (OUTFILE); + print "done\n"; +} + +sub gen_prop () +{ + my ($name, $def, $dll) = @_; + my ($cname, $mode, $sret, $mret, $docs, $code); + + $def =~ /define-property (\w+)/; + $cname = $1; + + $def =~ /prop-type "(\w+)/; + if (exists ($objects{$1})) { + $sret = $maptypes{$1}; + $mret = "GLib.Object"; + } elsif (exists ($maptypes{$1})) { + $sret = $maptypes{$1}; + $mret = $marshaltypes{$1}; + } else { + $sret = $mret = $1; + } + + $def =~ /doc-string "(.+)"\)/; + $docs = $1; + + $mode = 0; + if ($def =~ /\(readable #t\)/) { + $mode = 1; + } + + if (($def =~ /\(writeable #t\)/) && ($def !~ /\(construct-only #t\)/)) { + $mode += 2; + } + + $code = "\t\t/// $name Property \n"; + $code .= "\t\t/// \n\t\t///\t$docs\n"; + $code .= "\t\t/// \n\n"; + $code .= "\t\tpublic $sret $name {\n"; + if ($mode & 1) { + $code .= "\t\t\tget {\n\t\t\t\t$mret val;\n"; + $code .= "\t\t\t\tGetProperty (\"$cname\", out val);\n"; + $code .= "\t\t\t\treturn "; + if ($sret ne $mret) { + $code .= "($sret) "; + } + $code .= "val;\n\t\t\t}\n"; + } + if ($mode & 2) { + $code .= "\t\t\tset {\n"; + $code .= "\t\t\t\tSetProperty (\"$cname\", ($mret) value);\n"; + $code .= "\t\t\t}\n"; + } + $code .= "\t\t}\n\n"; + return $code; +} + +# Generate the code for a method definition. +sub gen_method +{ + my ($name, $def, $dll) = @_; + my ($cname, $sret, $ret, $mret, $sig, $call, $pinv, $code); + + $def =~ /\(c-name "(\w+)"/; + $cname = $1; + + $def =~ /return-type "(\w+)/; + if (exists ($maptypes{$1})) { + $sret = $maptypes{$1}; + $mret = $marshaltypes{$1}; + $ret = $1; + } else { + $sret = $mret = $ret = $1; + } + + ($call, $pinv, $sig) = gen_param_strings($def); + + $code = "\t\t/// $name Method \n"; + $code .= "\t\t/// \n\t\t///\t FIXME: Generate docs\n"; + $code .= "\t\t/// \n\n"; + $code .= "\t\t[DllImport(\"$dll\", CharSet=CharSet.Ansi,\n"; + $code .= "\t\t\t CallingConvention=CallingConvention.Cdecl)]\n"; + $code .= "\t\tstatic extern $mret $cname (IntPtr obj$pinv);\n\n"; + $code .= "\t\tpublic $sret $name ($sig)\n"; + $code .= "\t\t{\n\t\t\t"; + if ($sret ne "void") { $code .= "return "; } + $call = "$cname (RawObject$call)"; + if ($sret eq $mret) { + $code .= "$call"; + } elsif ($sret eq "String") { + $code .= "Marshal.PtrToStringAnsi($call)"; + } elsif ($mret eq "int") { + $code .= "($sret) $call"; + } elsif (exists ($objects{$ret})) { + $code .= "($sret) GLib.Object.GetObject($call)"; + } else { + die "Unexpected return type match $sret:$mret\n"; + } + $code .= ";\n\t\t}\n\n"; + return $code; +} + +# Generate the DllImport, signature, and call parameter strings. +sub gen_param_strings +{ + my ($def) = @_; + my ($call, $parm, $pinv, $sig); + + $call = $pinv = $sig = ""; + if ($def =~ /parameters'\((.*)\)\)\)/) { + foreach $parm (split(/\)'\(/, $1)) { + $parm =~ s/\*//g; + $parm =~ /"(.*)" "(.*)"/; + $pinv .= ", $marshaltypes{$1} $2"; + if ($sig) { $sig .= ', '; } + $sig .= "$maptypes{$1} $2"; + if ($maptypes{$1} eq $marshaltypes{$1}) { + $call .= ", $2"; + } elsif (exists ($objects{$1})) { + $call .= ", $2.Handle"; + } elsif ($1 =~ /gchar/) { + $call .= ", Marshal.StringToHGlobalAnsi($2)"; + } elsif ($marshaltypes{$1} = "int") { + $call .= ", (int) $2"; + } else { + die "Unexpected type encountered $1\n"; + } + } + } + return ($call, $pinv, $sig); +} + diff --git a/codegen/gdk-types.defs b/codegen/gdk-types.defs new file mode 100644 index 000000000..9a2458ffe --- /dev/null +++ b/codegen/gdk-types.defs @@ -0,0 +1,912 @@ +;; -*- scheme -*- +; object definitions ... +(define-object Colormap + (in-module "Gdk") + (parent "GObject") + (c-name "GdkColormap") + (gtype-id "GDK_TYPE_COLORMAP") +) + +(define-object Device + (in-module "Gdk") + (parent "GObject") + (c-name "GdkDevice") + (gtype-id "GDK_TYPE_DEVICE") + (fields + '("gchar*" "name") + '("GdkInputSource" "source") + '("GdkInputMode" "mode") + '("gboolean" "has_cursor") + '("gint" "num_axes") + '("GdkDeviceAxis*" "axes") + '("gint" "num_keys") + '("GdkDeviceKey*" "keys") + ) +) + +(define-object DragContext + (in-module "Gdk") + (parent "GObject") + (c-name "GdkDragContext") + (gtype-id "GDK_TYPE_DRAG_CONTEXT") + (fields + '("GdkDragProtocol" "protocol") + '("gboolean" "is_source") + '("GdkWindow*" "source_window") + '("GdkWindow*" "dest_window") + '("GList*" "targets") + '("GdkDragAction" "actions") + '("GdkDragAction" "suggested_action") + '("GdkDragAction" "action") + '("guint32" "start_time") + ) +) + +(define-object Drawable + (in-module "Gdk") + (parent "GObject") + (c-name "GdkDrawable") + (gtype-id "GDK_TYPE_DRAWABLE") +) + +(define-object Window + (in-module "Gdk") + (parent "GdkDrawable") + (c-name "GdkWindow") + (gtype-id "GDK_TYPE_WINDOW") +) + +(define-object Pixmap + (in-module "Gdk") + (parent "GdkDrawable") + (c-name "GdkPixmap") + (gtype-id "GDK_TYPE_PIXMAP") +) + +(define-object GC + (in-module "Gdk") + (parent "GObject") + (c-name "GdkGC") + (gtype-id "GDK_TYPE_GC") +) + +(define-object Image + (in-module "Gdk") + (parent "GObject") + (c-name "GdkImage") + (gtype-id "GDK_TYPE_IMAGE") +) + +(define-object Pixbuf + (in-module "Gdk") + (parent "GObject") + (c-name "GdkPixbuf") + (gtype-id "GDK_TYPE_PIXBUF") +) + +(define-object PixbufAnimation + (in-module "Gdk") + (parent "GObject") + (c-name "GdkPixbufAnimation") + (gtype-id "GDK_TYPE_PIXBUF_ANIMATION") +) + +(define-object PixbufAnimationIter + (in-module "Gdk") + (parent "GObject") + (c-name "GdkPixbufAnimationIter") + (gtype-id "GDK_TYPE_PIXBUF_ANIMATION_ITER") +) + +(define-object Visual + (in-module "Gdk") + (parent "GObject") + (c-name "GdkVisual") + (gtype-id "GDK_TYPE_VISUAL") + (fields + '("GdkVisualType" "type") + '("gint" "depth") + '("GdkByteOrder" "byte_order") + '("gint" "colormap_size") + '("gint" "bits_per_rgb") + '("guint32" "red_mask") + '("gint" "red_shift") + '("gint" "red_prec") + '("guint32" "green_mask") + '("gint" "green_shift") + '("gint" "green_prec") + '("guint32" "blue_mask") + '("gint" "blue_shift") + '("gint" "blue_prec") + ) +) + + +;; Boxed types ... + +(define-boxed Event + (in-module "Gdk") + (c-name "GdkEvent") + (gtype-id "GDK_TYPE_EVENT") + (copy-func "gdk_event_copy") + (release-func "gdk_event_free") +) + +(define-boxed Font + (in-module "Gdk") + (c-name "GdkFont") + (gtype-id "GDK_TYPE_FONT") + (copy-func "gdk_font_ref") + (release-func "gdk_font_unref") + (fields + '("GdkFontType" "type") + '("gint" "ascent") + '("gint" "descent") + ) +) + +(define-boxed Color + (in-module "Gdk") + (c-name "GdkColor") + (gtype-id "GDK_TYPE_COLOR") + (copy-func "gdk_color_copy") + (release-func "gdk_color_free") + (fields + '("guint32" "pixel") + '("guint16" "red") + '("guint16" "green") + '("guint16" "blue") + ) +) + +(define-boxed Cursor + (in-module "Gdk") + (c-name "GdkCursor") + (gtype-id "GDK_TYPE_CURSOR") + (copy-func "gdk_cursor_ref") + (release-func "gdk_cursor_unref") + (fields + '("GdkCursorType" "type") + ) +) + +(define-boxed Rectangle + (in-module "Gdk") + (c-name "GdkRectangle") + (gtype-id "GDK_TYPE_RECTANGLE") + (copy-func "gdk_rectangle_copy") + (release-func "g_free") + (fields + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +;; Enumerations and flags ... + +(define-enum CursorType + (in-module "Gdk") + (c-name "GdkCursorType") + (gtype-id "GDK_TYPE_CURSOR_TYPE") +; (value (name #include) (c-name #include)) + (values + '("gdk-cursor-is-pixmap" "GDK_CURSOR_IS_PIXMAP") + ) +) + +(define-flags DragAction + (in-module "Gdk") + (c-name "GdkDragAction") + (gtype-id "GDK_TYPE_DRAG_ACTION") + (values + '("default" "GDK_ACTION_DEFAULT") + '("copy" "GDK_ACTION_COPY") + '("move" "GDK_ACTION_MOVE") + '("link" "GDK_ACTION_LINK") + '("private" "GDK_ACTION_PRIVATE") + '("ask" "GDK_ACTION_ASK") + ) +) + +(define-enum DragProtocol + (in-module "Gdk") + (c-name "GdkDragProtocol") + (gtype-id "GDK_TYPE_DRAG_PROTOCOL") + (values + '("motif" "GDK_DRAG_PROTO_MOTIF") + '("xdnd" "GDK_DRAG_PROTO_XDND") + '("rootwin" "GDK_DRAG_PROTO_ROOTWIN") + '("none" "GDK_DRAG_PROTO_NONE") + '("win32-dropfiles" "GDK_DRAG_PROTO_WIN32_DROPFILES") + '("ole2" "GDK_DRAG_PROTO_OLE2") + '("local" "GDK_DRAG_PROTO_LOCAL") + ) +) + +(define-enum FilterReturn + (in-module "Gdk") + (c-name "GdkFilterReturn") + (gtype-id "GDK_TYPE_FILTER_RETURN") + (values + '("continue" "GDK_FILTER_CONTINUE") + '("translate" "GDK_FILTER_TRANSLATE") + '("remove" "GDK_FILTER_REMOVE") + ) +) + +(define-enum EventType + (in-module "Gdk") + (c-name "GdkEventType") + (gtype-id "GDK_TYPE_EVENT_TYPE") + (values + '("nothing" "GDK_NOTHING") + '("delete" "GDK_DELETE") + '("destroy" "GDK_DESTROY") + '("expose" "GDK_EXPOSE") + '("motion-notify" "GDK_MOTION_NOTIFY") + '("button-press" "GDK_BUTTON_PRESS") + '("2button-press" "GDK_2BUTTON_PRESS") + '("3button-press" "GDK_3BUTTON_PRESS") + '("button-release" "GDK_BUTTON_RELEASE") + '("key-press" "GDK_KEY_PRESS") + '("key-release" "GDK_KEY_RELEASE") + '("enter-notify" "GDK_ENTER_NOTIFY") + '("leave-notify" "GDK_LEAVE_NOTIFY") + '("focus-change" "GDK_FOCUS_CHANGE") + '("configure" "GDK_CONFIGURE") + '("map" "GDK_MAP") + '("unmap" "GDK_UNMAP") + '("property-notify" "GDK_PROPERTY_NOTIFY") + '("selection-clear" "GDK_SELECTION_CLEAR") + '("selection-request" "GDK_SELECTION_REQUEST") + '("selection-notify" "GDK_SELECTION_NOTIFY") + '("proximity-in" "GDK_PROXIMITY_IN") + '("proximity-out" "GDK_PROXIMITY_OUT") + '("drag-enter" "GDK_DRAG_ENTER") + '("drag-leave" "GDK_DRAG_LEAVE") + '("drag-motion" "GDK_DRAG_MOTION") + '("drag-status" "GDK_DRAG_STATUS") + '("drop-start" "GDK_DROP_START") + '("drop-finished" "GDK_DROP_FINISHED") + '("client-event" "GDK_CLIENT_EVENT") + '("visibility-notify" "GDK_VISIBILITY_NOTIFY") + '("no-expose" "GDK_NO_EXPOSE") + '("scroll" "GDK_SCROLL") + '("window-state" "GDK_WINDOW_STATE") + '("setting" "GDK_SETTING") + ) +) + +(define-flags EventMask + (in-module "Gdk") + (c-name "GdkEventMask") + (gtype-id "GDK_TYPE_EVENT_MASK") + (values + '("exposure-mask" "GDK_EXPOSURE_MASK") + '("pointer-motion-mask" "GDK_POINTER_MOTION_MASK") + '("pointer-motion-hint-mask" "GDK_POINTER_MOTION_HINT_MASK") + '("button-motion-mask" "GDK_BUTTON_MOTION_MASK") + '("button1-motion-mask" "GDK_BUTTON1_MOTION_MASK") + '("button2-motion-mask" "GDK_BUTTON2_MOTION_MASK") + '("button3-motion-mask" "GDK_BUTTON3_MOTION_MASK") + '("button-press-mask" "GDK_BUTTON_PRESS_MASK") + '("button-release-mask" "GDK_BUTTON_RELEASE_MASK") + '("key-press-mask" "GDK_KEY_PRESS_MASK") + '("key-release-mask" "GDK_KEY_RELEASE_MASK") + '("enter-notify-mask" "GDK_ENTER_NOTIFY_MASK") + '("leave-notify-mask" "GDK_LEAVE_NOTIFY_MASK") + '("focus-change-mask" "GDK_FOCUS_CHANGE_MASK") + '("structure-mask" "GDK_STRUCTURE_MASK") + '("property-change-mask" "GDK_PROPERTY_CHANGE_MASK") + '("visibility-notify-mask" "GDK_VISIBILITY_NOTIFY_MASK") + '("proximity-in-mask" "GDK_PROXIMITY_IN_MASK") + '("proximity-out-mask" "GDK_PROXIMITY_OUT_MASK") + '("substructure-mask" "GDK_SUBSTRUCTURE_MASK") + '("scroll-mask" "GDK_SCROLL_MASK") + '("all-events-mask" "GDK_ALL_EVENTS_MASK") + ) +) + +(define-enum VisibilityState + (in-module "Gdk") + (c-name "GdkVisibilityState") + (gtype-id "GDK_TYPE_VISIBILITY_STATE") + (values + '("unobscured" "GDK_VISIBILITY_UNOBSCURED") + '("partial" "GDK_VISIBILITY_PARTIAL") + '("fully-obscured" "GDK_VISIBILITY_FULLY_OBSCURED") + ) +) + +(define-enum ScrollDirection + (in-module "Gdk") + (c-name "GdkScrollDirection") + (gtype-id "GDK_TYPE_SCROLL_DIRECTION") + (values + '("up" "GDK_SCROLL_UP") + '("down" "GDK_SCROLL_DOWN") + '("left" "GDK_SCROLL_LEFT") + '("right" "GDK_SCROLL_RIGHT") + ) +) + +(define-enum NotifyType + (in-module "Gdk") + (c-name "GdkNotifyType") + (gtype-id "GDK_TYPE_NOTIFY_TYPE") + (values + '("ancestor" "GDK_NOTIFY_ANCESTOR") + '("virtual" "GDK_NOTIFY_VIRTUAL") + '("inferior" "GDK_NOTIFY_INFERIOR") + '("nonlinear" "GDK_NOTIFY_NONLINEAR") + '("nonlinear-virtual" "GDK_NOTIFY_NONLINEAR_VIRTUAL") + '("unknown" "GDK_NOTIFY_UNKNOWN") + ) +) + +(define-enum CrossingMode + (in-module "Gdk") + (c-name "GdkCrossingMode") + (gtype-id "GDK_TYPE_CROSSING_MODE") + (values + '("normal" "GDK_CROSSING_NORMAL") + '("grab" "GDK_CROSSING_GRAB") + '("ungrab" "GDK_CROSSING_UNGRAB") + ) +) + +(define-enum PropertyState + (in-module "Gdk") + (c-name "GdkPropertyState") + (gtype-id "GDK_TYPE_PROPERTY_STATE") + (values + '("new-value" "GDK_PROPERTY_NEW_VALUE") + '("delete" "GDK_PROPERTY_DELETE") + ) +) + +(define-flags WindowState + (in-module "Gdk") + (c-name "GdkWindowState") + (gtype-id "GDK_TYPE_WINDOW_STATE") + (values + '("withdrawn" "GDK_WINDOW_STATE_WITHDRAWN") + '("iconified" "GDK_WINDOW_STATE_ICONIFIED") + '("maximized" "GDK_WINDOW_STATE_MAXIMIZED") + '("sticky" "GDK_WINDOW_STATE_STICKY") + ) +) + +(define-enum SettingAction + (in-module "Gdk") + (c-name "GdkSettingAction") + (gtype-id "GDK_TYPE_SETTING_ACTION") + (values + '("new" "GDK_SETTING_ACTION_NEW") + '("changed" "GDK_SETTING_ACTION_CHANGED") + '("deleted" "GDK_SETTING_ACTION_DELETED") + ) +) + +(define-enum FontType + (in-module "Gdk") + (c-name "GdkFontType") + (gtype-id "GDK_TYPE_FONT_TYPE") + (values + '("font" "GDK_FONT_FONT") + '("fontset" "GDK_FONT_FONTSET") + ) +) + +(define-enum CapStyle + (in-module "Gdk") + (c-name "GdkCapStyle") + (gtype-id "GDK_TYPE_CAP_STYLE") + (values + '("not-last" "GDK_CAP_NOT_LAST") + '("butt" "GDK_CAP_BUTT") + '("round" "GDK_CAP_ROUND") + '("projecting" "GDK_CAP_PROJECTING") + ) +) + +(define-enum Fill + (in-module "Gdk") + (c-name "GdkFill") + (gtype-id "GDK_TYPE_FILL") + (values + '("solid" "GDK_SOLID") + '("tiled" "GDK_TILED") + '("stippled" "GDK_STIPPLED") + '("opaque-stippled" "GDK_OPAQUE_STIPPLED") + ) +) + +(define-enum Function + (in-module "Gdk") + (c-name "GdkFunction") + (gtype-id "GDK_TYPE_FUNCTION") + (values + '("copy" "GDK_COPY") + '("invert" "GDK_INVERT") + '("xor" "GDK_XOR") + '("clear" "GDK_CLEAR") + '("and" "GDK_AND") + '("and-reverse" "GDK_AND_REVERSE") + '("and-invert" "GDK_AND_INVERT") + '("noop" "GDK_NOOP") + '("or" "GDK_OR") + '("equiv" "GDK_EQUIV") + '("or-reverse" "GDK_OR_REVERSE") + '("copy-invert" "GDK_COPY_INVERT") + '("or-invert" "GDK_OR_INVERT") + '("nand" "GDK_NAND") + '("nor" "GDK_NOR") + '("set" "GDK_SET") + ) +) + +(define-enum JoinStyle + (in-module "Gdk") + (c-name "GdkJoinStyle") + (gtype-id "GDK_TYPE_JOIN_STYLE") + (values + '("miter" "GDK_JOIN_MITER") + '("round" "GDK_JOIN_ROUND") + '("bevel" "GDK_JOIN_BEVEL") + ) +) + +(define-enum LineStyle + (in-module "Gdk") + (c-name "GdkLineStyle") + (gtype-id "GDK_TYPE_LINE_STYLE") + (values + '("solid" "GDK_LINE_SOLID") + '("on-off-dash" "GDK_LINE_ON_OFF_DASH") + '("double-dash" "GDK_LINE_DOUBLE_DASH") + ) +) + +(define-enum SubwindowMode + (in-module "Gdk") + (c-name "GdkSubwindowMode") + (gtype-id "GDK_TYPE_SUBWINDOW_MODE") + (values + '("clip-by-children" "GDK_CLIP_BY_CHILDREN") + '("include-inferiors" "GDK_INCLUDE_INFERIORS") + ) +) + +(define-flags GCValuesMask + (in-module "Gdk") + (c-name "GdkGCValuesMask") + (gtype-id "GDK_TYPE_GC_VALUES_MASK") + (values + '("foreground" "GDK_GC_FOREGROUND") + '("background" "GDK_GC_BACKGROUND") + '("font" "GDK_GC_FONT") + '("function" "GDK_GC_FUNCTION") + '("fill" "GDK_GC_FILL") + '("tile" "GDK_GC_TILE") + '("stipple" "GDK_GC_STIPPLE") + '("clip-mask" "GDK_GC_CLIP_MASK") + '("subwindow" "GDK_GC_SUBWINDOW") + '("ts-x-origin" "GDK_GC_TS_X_ORIGIN") + '("ts-y-origin" "GDK_GC_TS_Y_ORIGIN") + '("clip-x-origin" "GDK_GC_CLIP_X_ORIGIN") + '("clip-y-origin" "GDK_GC_CLIP_Y_ORIGIN") + '("exposures" "GDK_GC_EXPOSURES") + '("line-width" "GDK_GC_LINE_WIDTH") + '("line-style" "GDK_GC_LINE_STYLE") + '("cap-style" "GDK_GC_CAP_STYLE") + '("join-style" "GDK_GC_JOIN_STYLE") + ) +) + +(define-enum ImageType + (in-module "Gdk") + (c-name "GdkImageType") + (gtype-id "GDK_TYPE_IMAGE_TYPE") + (values + '("normal" "GDK_IMAGE_NORMAL") + '("shared" "GDK_IMAGE_SHARED") + '("fastest" "GDK_IMAGE_FASTEST") + ) +) + +(define-enum ExtensionMode + (in-module "Gdk") + (c-name "GdkExtensionMode") + (gtype-id "GDK_TYPE_EXTENSION_MODE") + (values + '("none" "GDK_EXTENSION_EVENTS_NONE") + '("all" "GDK_EXTENSION_EVENTS_ALL") + '("cursor" "GDK_EXTENSION_EVENTS_CURSOR") + ) +) + +(define-enum InputSource + (in-module "Gdk") + (c-name "GdkInputSource") + (gtype-id "GDK_TYPE_INPUT_SOURCE") + (values + '("mouse" "GDK_SOURCE_MOUSE") + '("pen" "GDK_SOURCE_PEN") + '("eraser" "GDK_SOURCE_ERASER") + '("cursor" "GDK_SOURCE_CURSOR") + ) +) + +(define-enum InputMode + (in-module "Gdk") + (c-name "GdkInputMode") + (gtype-id "GDK_TYPE_INPUT_MODE") + (values + '("disabled" "GDK_MODE_DISABLED") + '("screen" "GDK_MODE_SCREEN") + '("window" "GDK_MODE_WINDOW") + ) +) + +(define-enum AxisUse + (in-module "Gdk") + (c-name "GdkAxisUse") + (gtype-id "GDK_TYPE_AXIS_USE") + (values + '("ignore" "GDK_AXIS_IGNORE") + '("x" "GDK_AXIS_X") + '("y" "GDK_AXIS_Y") + '("pressure" "GDK_AXIS_PRESSURE") + '("xtilt" "GDK_AXIS_XTILT") + '("ytilt" "GDK_AXIS_YTILT") + '("wheel" "GDK_AXIS_WHEEL") + '("last" "GDK_AXIS_LAST") + ) +) + +(define-enum PropMode + (in-module "Gdk") + (c-name "GdkPropMode") + (gtype-id "GDK_TYPE_PROP_MODE") + (values + '("replace" "GDK_PROP_MODE_REPLACE") + '("prepend" "GDK_PROP_MODE_PREPEND") + '("append" "GDK_PROP_MODE_APPEND") + ) +) + +(define-enum FillRule + (in-module "Gdk") + (c-name "GdkFillRule") + (gtype-id "GDK_TYPE_FILL_RULE") + (values + '("even-odd-rule" "GDK_EVEN_ODD_RULE") + '("winding-rule" "GDK_WINDING_RULE") + ) +) + +(define-enum OverlapType + (in-module "Gdk") + (c-name "GdkOverlapType") + (gtype-id "GDK_TYPE_OVERLAP_TYPE") + (values + '("in" "GDK_OVERLAP_RECTANGLE_IN") + '("out" "GDK_OVERLAP_RECTANGLE_OUT") + '("part" "GDK_OVERLAP_RECTANGLE_PART") + ) +) + +(define-enum RgbDither + (in-module "Gdk") + (c-name "GdkRgbDither") + (gtype-id "GDK_TYPE_RGB_DITHER") + (values + '("none" "GDK_RGB_DITHER_NONE") + '("normal" "GDK_RGB_DITHER_NORMAL") + '("max" "GDK_RGB_DITHER_MAX") + ) +) + +(define-enum Selection + (in-module "Gdk") + (c-name "GdkSelection") + (gtype-id "GDK_TYPE_SELECTION") + (values + '("primary" "GDK_SELECTION_PRIMARY") + '("secondary" "GDK_SELECTION_SECONDARY") + ) +) + +(define-enum Target + (in-module "Gdk") + (c-name "GdkTarget") + (gtype-id "GDK_TYPE_TARGET") + (values + '("bitmap" "GDK_TARGET_BITMAP") + '("colormap" "GDK_TARGET_COLORMAP") + '("drawable" "GDK_TARGET_DRAWABLE") + '("pixmap" "GDK_TARGET_PIXMAP") + '("string" "GDK_TARGET_STRING") + ) +) + +(define-enum SelectionType + (in-module "Gdk") + (c-name "GdkSelectionType") + (gtype-id "GDK_TYPE_SELECTION_TYPE") + (values + '("atom" "GDK_SELECTION_TYPE_ATOM") + '("bitmap" "GDK_SELECTION_TYPE_BITMAP") + '("colormap" "GDK_SELECTION_TYPE_COLORMAP") + '("drawable" "GDK_SELECTION_TYPE_DRAWABLE") + '("integer" "GDK_SELECTION_TYPE_INTEGER") + '("pixmap" "GDK_SELECTION_TYPE_PIXMAP") + '("window" "GDK_SELECTION_TYPE_WINDOW") + '("string" "GDK_SELECTION_TYPE_STRING") + ) +) + +(define-enum ByteOrder + (in-module "Gdk") + (c-name "GdkByteOrder") + (gtype-id "GDK_TYPE_BYTE_ORDER") + (values + '("lsb-first" "GDK_LSB_FIRST") + '("msb-first" "GDK_MSB_FIRST") + ) +) + +(define-flags ModifierType + (in-module "Gdk") + (c-name "GdkModifierType") + (gtype-id "GDK_TYPE_MODIFIER_TYPE") + (values + '("shift-mask" "GDK_SHIFT_MASK") + '("lock-mask" "GDK_LOCK_MASK") + '("control-mask" "GDK_CONTROL_MASK") + '("mod1-mask" "GDK_MOD1_MASK") + '("mod2-mask" "GDK_MOD2_MASK") + '("mod3-mask" "GDK_MOD3_MASK") + '("mod4-mask" "GDK_MOD4_MASK") + '("mod5-mask" "GDK_MOD5_MASK") + '("button1-mask" "GDK_BUTTON1_MASK") + '("button2-mask" "GDK_BUTTON2_MASK") + '("button3-mask" "GDK_BUTTON3_MASK") + '("button4-mask" "GDK_BUTTON4_MASK") + '("button5-mask" "GDK_BUTTON5_MASK") + '("release-mask" "GDK_RELEASE_MASK") + '("modifier-mask" "GDK_MODIFIER_MASK") + ) +) + +(define-flags InputCondition + (in-module "Gdk") + (c-name "GdkInputCondition") + (gtype-id "GDK_TYPE_INPUT_CONDITION") + (values + '("read" "GDK_INPUT_READ") + '("write" "GDK_INPUT_WRITE") + '("exception" "GDK_INPUT_EXCEPTION") + ) +) + +(define-enum Status + (in-module "Gdk") + (c-name "GdkStatus") + (gtype-id "GDK_TYPE_STATUS") + (values + '("ok" "GDK_OK") + '("error" "GDK_ERROR") + '("error-param" "GDK_ERROR_PARAM") + '("error-file" "GDK_ERROR_FILE") + '("error-mem" "GDK_ERROR_MEM") + ) +) + +(define-enum GrabStatus + (in-module "Gdk") + (c-name "GdkGrabStatus") + (gtype-id "GDK_TYPE_GRAB_STATUS") + (values + '("success" "GDK_GRAB_SUCCESS") + '("already-grabbed" "GDK_GRAB_ALREADY_GRABBED") + '("invalid-time" "GDK_GRAB_INVALID_TIME") + '("not-viewable" "GDK_GRAB_NOT_VIEWABLE") + '("frozen" "GDK_GRAB_FROZEN") + ) +) + +(define-enum VisualType + (in-module "Gdk") + (c-name "GdkVisualType") + (gtype-id "GDK_TYPE_VISUAL_TYPE") + (values + '("static-gray" "GDK_VISUAL_STATIC_GRAY") + '("grayscale" "GDK_VISUAL_GRAYSCALE") + '("static-color" "GDK_VISUAL_STATIC_COLOR") + '("pseudo-color" "GDK_VISUAL_PSEUDO_COLOR") + '("true-color" "GDK_VISUAL_TRUE_COLOR") + '("direct-color" "GDK_VISUAL_DIRECT_COLOR") + ) +) + +(define-enum WindowClass + (in-module "Gdk") + (c-name "GdkWindowClass") + (gtype-id "GDK_TYPE_WINDOW_CLASS") + (values + '("utput" "GDK_INPUT_OUTPUT") + '("nly" "GDK_INPUT_ONLY") + ) +) + +(define-enum WindowType + (in-module "Gdk") + (c-name "GdkWindowType") + (gtype-id "GDK_TYPE_WINDOW_TYPE") + (values + '("root" "GDK_WINDOW_ROOT") + '("toplevel" "GDK_WINDOW_TOPLEVEL") + '("child" "GDK_WINDOW_CHILD") + '("dialog" "GDK_WINDOW_DIALOG") + '("temp" "GDK_WINDOW_TEMP") + '("foreign" "GDK_WINDOW_FOREIGN") + ) +) + +(define-flags WindowAttributesType + (in-module "Gdk") + (c-name "GdkWindowAttributesType") + (gtype-id "GDK_TYPE_WINDOW_ATTRIBUTES_TYPE") + (values + '("title" "GDK_WA_TITLE") + '("x" "GDK_WA_X") + '("y" "GDK_WA_Y") + '("cursor" "GDK_WA_CURSOR") + '("colormap" "GDK_WA_COLORMAP") + '("visual" "GDK_WA_VISUAL") + '("wmclass" "GDK_WA_WMCLASS") + '("noredir" "GDK_WA_NOREDIR") + ) +) + +(define-flags WindowHints + (in-module "Gdk") + (c-name "GdkWindowHints") + (gtype-id "GDK_TYPE_WINDOW_HINTS") + (values + '("pos" "GDK_HINT_POS") + '("min-size" "GDK_HINT_MIN_SIZE") + '("max-size" "GDK_HINT_MAX_SIZE") + '("base-size" "GDK_HINT_BASE_SIZE") + '("aspect" "GDK_HINT_ASPECT") + '("resize-inc" "GDK_HINT_RESIZE_INC") + '("win-gravity" "GDK_HINT_WIN_GRAVITY") + ) +) + +(define-enum WindowTypeHint + (in-module "Gdk") + (c-name "GdkWindowTypeHint") + (gtype-id "GDK_TYPE_WINDOW_TYPE_HINT") + (values + '("normal" "GDK_WINDOW_TYPE_HINT_NORMAL") + '("dialog" "GDK_WINDOW_TYPE_HINT_DIALOG") + '("menu" "GDK_WINDOW_TYPE_HINT_MENU") + '("toolbar" "GDK_WINDOW_TYPE_HINT_TOOLBAR") + ) +) + +(define-flags WMDecoration + (in-module "Gdk") + (c-name "GdkWMDecoration") + (gtype-id "GDK_TYPE_WM_DECORATION") + (values + '("all" "GDK_DECOR_ALL") + '("border" "GDK_DECOR_BORDER") + '("resizeh" "GDK_DECOR_RESIZEH") + '("title" "GDK_DECOR_TITLE") + '("menu" "GDK_DECOR_MENU") + '("minimize" "GDK_DECOR_MINIMIZE") + '("maximize" "GDK_DECOR_MAXIMIZE") + ) +) + +(define-flags WMFunction + (in-module "Gdk") + (c-name "GdkWMFunction") + (gtype-id "GDK_TYPE_WM_FUNCTION") + (values + '("all" "GDK_FUNC_ALL") + '("resize" "GDK_FUNC_RESIZE") + '("move" "GDK_FUNC_MOVE") + '("minimize" "GDK_FUNC_MINIMIZE") + '("maximize" "GDK_FUNC_MAXIMIZE") + '("close" "GDK_FUNC_CLOSE") + ) +) + +(define-enum Gravity + (in-module "Gdk") + (c-name "GdkGravity") + (gtype-id "GDK_TYPE_GRAVITY") + (values + '("north-west" "GDK_GRAVITY_NORTH_WEST") + '("north" "GDK_GRAVITY_NORTH") + '("north-east" "GDK_GRAVITY_NORTH_EAST") + '("west" "GDK_GRAVITY_WEST") + '("center" "GDK_GRAVITY_CENTER") + '("east" "GDK_GRAVITY_EAST") + '("south-west" "GDK_GRAVITY_SOUTH_WEST") + '("south" "GDK_GRAVITY_SOUTH") + '("south-east" "GDK_GRAVITY_SOUTH_EAST") + '("static" "GDK_GRAVITY_STATIC") + ) +) + +(define-enum WindowEdge + (in-module "Gdk") + (c-name "GdkWindowEdge") + (gtype-id "GDK_TYPE_WINDOW_EDGE") + (values + '("north-west" "GDK_WINDOW_EDGE_NORTH_WEST") + '("north" "GDK_WINDOW_EDGE_NORTH") + '("north-east" "GDK_WINDOW_EDGE_NORTH_EAST") + '("west" "GDK_WINDOW_EDGE_WEST") + '("east" "GDK_WINDOW_EDGE_EAST") + '("south-west" "GDK_WINDOW_EDGE_SOUTH_WEST") + '("south" "GDK_WINDOW_EDGE_SOUTH") + '("south-east" "GDK_WINDOW_EDGE_SOUTH_EAST") + ) +) + +(define-enum PixbufAlphaMode + (in-module "Gdk") + (c-name "GdkPixbufAlphaMode") + (gtype-id "GDK_TYPE_PIXBUF_ALPHA_MODE") + (values + '("bilevel" "GDK_PIXBUF_ALPHA_BILEVEL") + '("full" "GDK_PIXBUF_ALPHA_FULL") + ) +) + +(define-enum Colorspace + (in-module "Gdk") + (c-name "GdkColorspace") + (gtype-id "GDK_TYPE_COLORSPACE") + (values + '("b" "GDK_COLORSPACE_RGB") + ) +) + +(define-enum PixbufError + (in-module "Gdk") + (c-name "GdkPixbufError") + (gtype-id "GDK_TYPE_PIXBUF_ERROR") + (values + '("header-corrupt" "GDK_PIXBUF_ERROR_HEADER_CORRUPT") + '("pixel-corrupt" "GDK_PIXBUF_ERROR_PIXEL_CORRUPT") + '("unknown-format" "GDK_PIXBUF_ERROR_UNKNOWN_FORMAT") + '("corrupt-image" "GDK_PIXBUF_ERROR_CORRUPT_IMAGE") + '("insufficient-memory" "GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY") + '("bad-option-value" "GDK_PIXBUF_ERROR_BAD_OPTION_VALUE") + '("unknown-type" "GDK_PIXBUF_ERROR_UNKNOWN_TYPE") + '("unsupported-operation" "GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION") + '("failed" "GDK_PIXBUF_ERROR_FAILED") + ) +) + +(define-enum InterpType + (in-module "Gdk") + (c-name "GdkInterpType") + (gtype-id "GDK_TYPE_INTERP_TYPE") + (values + '("nearest" "GDK_INTERP_NEAREST") + '("tiles" "GDK_INTERP_TILES") + '("bilinear" "GDK_INTERP_BILINEAR") + '("hyper" "GDK_INTERP_HYPER") + ) +) diff --git a/codegen/get-props-from-source.pl b/codegen/get-props-from-source.pl new file mode 100755 index 000000000..0ef16d96f --- /dev/null +++ b/codegen/get-props-from-source.pl @@ -0,0 +1,144 @@ +#!/usr/bin/perl + +open (SRCFILE, $ARGV[0]) || die "Could open $ARGV[0]"; + +@lines = ; +$linenum = 0; + +while ($linenum < @lines) { + + $line = $lines[$linenum]; + + if ($line =~ /^(\w+)_class_init/) { + $typename = StudCaps($1); + $fstr = ""; + + do { + $fstr .= $lines[$linenum++]; + } until ($lines[$linenum] =~ /^}/); + + parse_init_func ($typename, $fstr); + } + + $linenum++; +} + +sub parse_init_func +{ + my ($class, $func) = @_; + my @init_lines = split (/\n/, $func); + + my $linenum = 0; + while ($linenum < @init_lines) { + + my $line = $init_lines[$linenum]; + + while ($linenum < @init_lines) { + $line = $init_lines[$linenum]; + if ($line =~ /g_object_class_install_prop/) { + my $prop = $line; + do { + $prop .= $init_lines[++$linenum]; + } until ($init_lines[$linenum] =~ /;/); + print_prop ($prop, $class); + } elsif ($line =~ /g_signal_new/) { + my $sig = $line; + do { + $sig .= $init_lines[++$linenum]; + } until ($init_lines[$linenum] =~ /;/); + print_signal ($sig, $class); + } + $linenum++; + } + + $linenum++; + } +} + +sub print_signal +{ + my ($spec, $class) = @_; + $spec =~ s/\n\s*//g; + + $spec =~ /\((.*)\);/; + my @args = split (/,\s*/, $1); + + $args[0] =~ /\w+/; + my $name = $&; + + my $ret = $args[8]; + if ($ret =~ /G_TYPE_(\w+)/) { + $ret = lc ($1); + } + + my $param_cnt = $args[9]; + + my $pstr = "\t\n"; + $pstr .= "\t\t $ret \n"; + if ($param_cnt) { + $pstr .= "\t\t\n"; + for ($i=0; $i < $param_cnt; $i++) { + if ($args[$i+10] =~ /G_TYPE_(\w+)/) { + $args[$i+10] = lc ($1); + } + $pstr .= "\t\t\t $args[$i+10] \n"; + } + $pstr .= "\t\t\n"; + } + $pstr .= "\t\n\n"; + + $signals{$name} = $pstr; +} + +sub print_prop +{ + my ($spec, $class) = @_; + + $spec =~ /g_param_spec_(\w+)\s*\((.*)/; + $type = $1; + $params = $2; + + if ($type =~ /boolean|^u*int|pointer/) { + $params =~ /\"(.+)\",.+\".+\".+\"(.+)\".*(,\s*G_PARAM_\w+.*)\)\s*\)/; + $name = $1; $docs = $2; $mode = $3; + $type = "g$type"; + } elsif ($type =~ /string/) { + $params =~ /\"(.+)\",.+\".+\".+\"(.+)\".*(,\s*G_PARAM_\w+.*)\)\s*\)/; + $name = $1; $docs = $2; $mode = $3; + $type = "gchar*"; + } elsif ($type =~ /enum|flags/) { + $params =~ /\"(.+)\",.+,.+\"(.+)\".*,\s+(\w+),.*,(\s*G_PARAM_\w+.*)\)\s*\)/; + $name = $1; $docs = $2; $type = $3; $mode = $4; + $type =~ s/TYPE_//; + $type = StudCaps(lc($type)); + } elsif ($type =~ /object/) { + $params =~ /\"(.+)\",.+,.+\"(.+)\".*,\s+(\w+),(\s*G_PARAM_\w+.*)\)\s*\)/; + $name = $1; $docs = $2; $type = $3; $mode = $4; + $type =~ s/TYPE_//; + $type = StudCaps(lc($type)); + } + + + print "(define-property $name\n"; + print " (of-object \"$class\")\n"; + print " (prop-type \"$type\")\n"; + print " (doc-string \"$docs\")\n"; + + if ($mode =~ /READ/) { print " (readable #t)\n"; } + if ($mode =~ /WRIT/) { print " (writeable #t)\n"; } + if ($mode =~ /CONS/) { print " (construct-only #t)\n"; } + + print ")\n\n"; + + $props{$name} = $pstr; +} + +sub StudCaps +{ + my ($str) = @_; + + $str =~ s/^(\w)/\u\1/; + $str =~ s/[_-]([a-z])/\u\1/g; + $str =~ s/[_-](\d)/\1/g; + return $str; +} diff --git a/codegen/gtk-props.defs b/codegen/gtk-props.defs new file mode 100644 index 000000000..525c5e83b --- /dev/null +++ b/codegen/gtk-props.defs @@ -0,0 +1,282 @@ +(define-property name + (of-object "GtkWidget") + (prop-type "gchar*") + (doc-string "The name of the widget") + (readable #t) + (writeable #t) +) + +(define-property parent + (of-object "GtkWidget") + (prop-type "GtkContainer") + (doc-string "The parent widget of this widget. Must be a Container widget.") + (readable #t) + (writeable #t) +) + +(define-property width_request + (of-object "GtkWidget") + (prop-type "gint") + (doc-string "Override for width request of the widget, or -1 if natural request should be used.") + (readable #t) + (writeable #t) +) + +(define-property height_request + (of-object "GtkWidget") + (prop-type "gint") + (doc-string "Override for height request of the widget, or -1 if natural request should be used.") + (readable #t) + (writeable #t) +) + +(define-property visible + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget is visible") + (readable #t) + (writeable #t) +) + +(define-property sensitive + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget responds to input") + (readable #t) + (writeable #t) +) + +(define-property app_paintable + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the application will paint directly on the widget") + (readable #t) + (writeable #t) +) + +(define-property can_focus + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget can accept the input focus") + (readable #t) + (writeable #t) +) + +(define-property has_focus + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget has the input focus") + (readable #t) + (writeable #t) +) + +(define-property can_default + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget can be the default widget") + (readable #t) + (writeable #t) +) + +(define-property has_default + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget is the default widget") + (readable #t) + (writeable #t) +) + +(define-property receives_default + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "If TRUE, the widget will receive the default action when it is focused.") + (readable #t) + (writeable #t) +) + +(define-property composite_child + (of-object "GtkWidget") + (prop-type "gboolean") + (doc-string "Whether the widget is composed of other widgets") + (readable #t) +) + +(define-property style + (of-object "GtkWidget") + (prop-type "GtkStyle") + (doc-string "The style of the widget, which contains information about how it will look (colors etc).") + (readable #t) + (writeable #t) +) + +(define-property events + (of-object "GtkWidget") + (prop-type "GdkEventMask") + (doc-string "The event mask that decides what kind of GdkEvents this widget gets.") + (readable #t) + (writeable #t) +) + +(define-property extension_events + (of-object "GtkWidget") + (prop-type "GdkExtensionMode") + (doc-string "The mask that decides what kind of extension events this widget gets.") + (readable #t) + (writeable #t) +) + +(define-property user_data + (of-object "GtkObject") + (prop-type "gpointer") + (doc-string "Anonymous User Data Pointer") + (readable #t) + (writeable #t) +) + +(define-property resize_mode + (of-object "GtkContainer") + (prop-type "GtkResizeMode") + (doc-string "Specify how resize events are handled") + (readable #t) + (writeable #t) +) + +(define-property border_width + (of-object "GtkContainer") + (prop-type "guint") + (doc-string "The width of the empty border outside the containers children.") + (readable #t) + (writeable #t) +) + +(define-property child + (of-object "GtkContainer") + (prop-type "GtkWidget") + (doc-string "Can be used to add a new child to the container.") + (writeable #t) +) + +(define-property type + (of-object "GtkWindow") + (prop-type "GtkWindowType") + (doc-string "The type of the window") + (readable #t) + (writeable #t) + (construct-only #t) +) + +(define-property title + (of-object "GtkWindow") + (prop-type "gchar*") + (doc-string "The title of the window") + (readable #t) + (writeable #t) +) + +(define-property allow_shrink + (of-object "GtkWindow") + (prop-type "gboolean") + (doc-string "If TRUE, the window has no mimimum size. Setting this to TRUE is 99% of the time a bad idea.") + (readable #t) + (writeable #t) +) + +(define-property allow_grow + (of-object "GtkWindow") + (prop-type "gboolean") + (doc-string "If TRUE, users can expand the window beyond its minimum size.") + (readable #t) + (writeable #t) +) + +(define-property resizable + (of-object "GtkWindow") + (prop-type "gboolean") + (doc-string "If TRUE, users can resize the window.") + (readable #t) + (writeable #t) +) + +(define-property modal + (of-object "GtkWindow") + (prop-type "gboolean") + (doc-string "If TRUE, the window is modal (other windows are not usable while this one is up).") + (readable #t) + (writeable #t) +) + +(define-property window_position + (of-object "GtkWindow") + (prop-type "GtkWindowPosition") + (doc-string "The initial position of the window.") + (readable #t) + (writeable #t) +) + +(define-property default_width + (of-object "GtkWindow") + (prop-type "gint") + (doc-string "The default width of the window, used when initially showing the window.") + (readable #t) + (writeable #t) +) + +(define-property default_height + (of-object "GtkWindow") + (prop-type "gint") + (doc-string "The default height of the window, used when initially showing the window.") + (readable #t) + (writeable #t) +) + +(define-property destroy_with_parent + (of-object "GtkWindow") + (prop-type "gboolean") + (doc-string "If this window should be destroyed when the parent is destroyed") + (readable #t) + (writeable #t) +) + +(define-property icon + (of-object "GtkWindow") + (prop-type "GdkPixbuf") + (doc-string "Icon for this window") + (readable #t) + (writeable #t) +) + +(define-property label + (of-object "GtkButton") + (prop-type "gchar*") + (doc-string "Text of the label widget inside the button, if the button contains a label widget.") + (readable #t) + (writeable #t) + (construct-only #t) +) + +(define-property use_underline + (of-object "GtkButton") + (prop-type "gboolean") + (doc-string "If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key") + (readable #t) + (writeable #t) + (construct-only #t) +) + +(define-property use_stock + (of-object "GtkButton") + (prop-type "gboolean") + (doc-string "If set, the label is used to pick a stock item instead of being displayed") + (readable #t) + (writeable #t) + (construct-only #t) +) + +(define-property relief + (of-object "GtkButton") + (prop-type "GtkReliefStyle") + (doc-string "The border relief style.") + (readable #t) + (writeable #t) +) + diff --git a/codegen/gtk.defs b/codegen/gtk.defs new file mode 100644 index 000000000..4c81434a4 --- /dev/null +++ b/codegen/gtk.defs @@ -0,0 +1,15379 @@ +;; -*- scheme -*- + +(include "gtk-extrafuncs.defs") +(include "gtk-types.defs") + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtk.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkaccelgroup.h + +(define-function gtk_accelerator_valid + (c-name "gtk_accelerator_valid") + (return-type "gboolean") + (parameters + '("guint" "keyval") + '("GdkModifierType" "modifiers") + ) +) + +(define-function gtk_accelerator_parse + (c-name "gtk_accelerator_parse") + (return-type "none") + (parameters + '("const-gchar*" "accelerator") + '("guint*" "accelerator_key") + '("GdkModifierType*" "accelerator_mods") + ) +) + +(define-function gtk_accelerator_name + (c-name "gtk_accelerator_name") + (return-type "gchar*") + (parameters + '("guint" "accelerator_key") + '("GdkModifierType" "accelerator_mods") + ) +) + +(define-function gtk_accelerator_set_default_mod_mask + (c-name "gtk_accelerator_set_default_mod_mask") + (return-type "none") + (parameters + '("GdkModifierType" "default_mod_mask") + ) +) + +(define-function gtk_accelerator_get_default_mod_mask + (c-name "gtk_accelerator_get_default_mod_mask") + (return-type "guint") +) + +(define-function gtk_accel_group_new + (is-constructor-of GtkAccelGroup) + (c-name "gtk_accel_group_new") + (return-type "GtkAccelGroup*") +) + +(define-function accel_group_get_default + (c-name "gtk_accel_group_get_default") + (return-type "GtkAccelGroup*") +) + +(define-method ref + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_ref") + (return-type "GtkAccelGroup*") +) + +(define-method unref + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_unref") + (return-type "none") +) + +(define-method lock + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_lock") + (return-type "none") +) + +(define-method unlock + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_unlock") + (return-type "none") +) + +(define-function groups_activate + (c-name "gtk_accel_groups_activate") + (return-type "gboolean") + (parameters + '("GObject*" "object") + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-method activate + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_activate") + (return-type "gboolean") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-method attach + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_attach") + (return-type "none") + (parameters + '("GObject*" "object") + ) +) + +(define-method detach + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_detach") + (return-type "none") + (parameters + '("GObject*" "object") + ) +) + +(define-method get_entry + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_get_entry") + (return-type "GtkAccelEntry*") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-method lock_entry + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_lock_entry") + (return-type "none") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-method unlock_entry + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_unlock_entry") + (return-type "none") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-method add + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_add") + (return-type "none") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + '("GtkAccelFlags" "accel_flags") + '("GObject*" "object") + '("const-gchar*" "accel_signal") + ) +) + +(define-method remove + (of-object "GtkAccelGroup") + (c-name "gtk_accel_group_remove") + (return-type "none") + (parameters + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + '("GObject*" "object") + ) +) + +(define-function gtk_accel_group_handle_add + (c-name "gtk_accel_group_handle_add") + (return-type "none") + (parameters + '("GObject*" "object") + '("guint" "accel_signal_id") + '("GtkAccelGroup*" "accel_group") + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + '("GtkAccelFlags" "accel_flags") + ) +) + +(define-function gtk_accel_group_handle_remove + (c-name "gtk_accel_group_handle_remove") + (return-type "none") + (parameters + '("GtkObject*" "object") + '("GtkAccelGroup*" "accel_group") + '("guint" "accel_key") + '("GdkModifierType" "accel_mods") + ) +) + +(define-function gtk_accel_group_create_add + (c-name "gtk_accel_group_create_add") + (return-type "guint") + (parameters + '("GtkType" "class_type") + '("GtkSignalRunType" "signal_flags") + '("guint" "handler_offset") + ) +) + +(define-function gtk_accel_group_create_remove + (c-name "gtk_accel_group_create_remove") + (return-type "guint") + (parameters + '("GtkType" "class_type") + '("GtkSignalRunType" "signal_flags") + '("guint" "handler_offset") + ) +) + +(define-function gtk_accel_groups_from_object + (c-name "gtk_accel_groups_from_object") + (return-type "GSList*") + (parameters + '("GObject*" "object") + ) +) + +(define-function gtk_accel_group_entries_from_object + (c-name "gtk_accel_group_entries_from_object") + (return-type "GSList*") + (parameters + '("GObject*" "object") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkaccellabel.h + +(define-function gtk_accel_label_get_type + (c-name "gtk_accel_label_get_type") + (return-type "GtkType") +) + +(define-function gtk_accel_label_new + (c-name "gtk_accel_label_new") + (is-constructor-of GtkAccelLabel) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-method get_accel_object + (of-object "GtkAccelLabel") + (c-name "gtk_accel_label_get_accel_object") + (return-type "GObject*") +) + +(define-method get_accel_width + (of-object "GtkAccelLabel") + (c-name "gtk_accel_label_get_accel_width") + (return-type "guint") +) + +(define-method set_accel_object + (of-object "GtkAccelLabel") + (c-name "gtk_accel_label_set_accel_object") + (return-type "none") + (parameters + '("GObject*" "accel_object") + ) +) + +(define-method refetch + (of-object "GtkAccelLabel") + (c-name "gtk_accel_label_refetch") + (return-type "gboolean") +) + +; DEPRECATED +(define-method set_accel_widget + (of-object "GtkAccelLabel") + (c-name "gtk_accel_label_set_accel_widget") + (return-type "none") + (parameters + '("GtkWidget*" "accel_widget") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkadjustment.h + +(define-function gtk_adjustment_get_type + (c-name "gtk_adjustment_get_type") + (return-type "GtkType") +) + +(define-function gtk_adjustment_new + (c-name "gtk_adjustment_new") + (is-constructor-of GtkAdjustment) + (return-type "GtkObject*") + (parameters + '("gdouble" "value" (default "0")) + '("gdouble" "lower" (default "0")) + '("gdouble" "upper" (default "0")) + '("gdouble" "step_incr" (default "0")) + '("gdouble" "page_incr" (default "0")) + '("gdouble" "page_size" (default "0")) + ) +) + +(define-method changed + (of-object "GtkAdjustment") + (c-name "gtk_adjustment_changed") + (return-type "none") +) + +(define-method value_changed + (of-object "GtkAdjustment") + (c-name "gtk_adjustment_value_changed") + (return-type "none") +) + +(define-method clamp_page + (of-object "GtkAdjustment") + (c-name "gtk_adjustment_clamp_page") + (return-type "none") + (parameters + '("gdouble" "lower") + '("gdouble" "upper") + ) +) + +(define-method get_value + (of-object "GtkAdjustment") + (c-name "gtk_adjustment_get_value") + (return-type "gdouble") +) + +(define-method set_value + (of-object "GtkAdjustment") + (c-name "gtk_adjustment_set_value") + (return-type "none") + (parameters + '("gdouble" "value") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkalignment.h + +(define-function gtk_alignment_get_type + (c-name "gtk_alignment_get_type") + (return-type "GtkType") +) + +(define-function gtk_alignment_new + (c-name "gtk_alignment_new") + (is-constructor-of GtkAlignment) + (return-type "GtkWidget*") + (parameters + '("gfloat" "xalign" (default "0.0")) + '("gfloat" "yalign" (default "0.0")) + '("gfloat" "xscale" (default "0.0")) + '("gfloat" "yscale" (default "0.0")) + ) +) + +(define-method set + (of-object "GtkAlignment") + (c-name "gtk_alignment_set") + (return-type "none") + (parameters + '("gfloat" "xalign") + '("gfloat" "yalign") + '("gfloat" "xscale") + '("gfloat" "yscale") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkarrow.h + +(define-function gtk_arrow_get_type + (c-name "gtk_arrow_get_type") + (return-type "GtkType") +) + +(define-function gtk_arrow_new + (c-name "gtk_arrow_new") + (is-constructor-of GtkArrow) + (return-type "GtkWidget*") + (parameters + '("GtkArrowType" "arrow_type") + '("GtkShadowType" "shadow_type") + ) +) + +(define-method set + (of-object "GtkArrow") + (c-name "gtk_arrow_set") + (return-type "none") + (parameters + '("GtkArrowType" "arrow_type") + '("GtkShadowType" "shadow_type") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkaspectframe.h + +(define-function gtk_aspect_frame_get_type + (c-name "gtk_aspect_frame_get_type") + (return-type "GtkType") +) + +(define-function gtk_aspect_frame_new + (c-name "gtk_aspect_frame_new") + (is-constructor-of GtkAspectFrame) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label" (null-ok) (default "NULL")) + '("gfloat" "xalign" (default "0.5")) + '("gfloat" "yalign" (default "0.5")) + '("gfloat" "ratio" (default "1")) + '("gboolean" "obey_child" (default "TRUE")) + ) +) + +(define-method set + (of-object "GtkAspectFrame") + (c-name "gtk_aspect_frame_set") + (return-type "none") + (parameters + '("gfloat" "xalign" (default "0.0")) + '("gfloat" "yalign" (default "0.0")) + '("gfloat" "ratio" (default "1.0")) + '("gboolean" "obey_child" (default "1")) + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkbbox.h + +(define-function gtk_button_box_get_type + (c-name "gtk_button_box_get_type") + (return-type "GtkType") +) + +(define-method get_layout + (of-object "GtkButtonBox") + (c-name "gtk_button_box_get_layout") + (return-type "GtkButtonBoxStyle") +) + +(define-method set_layout + (of-object "GtkButtonBox") + (c-name "gtk_button_box_set_layout") + (return-type "none") + (parameters + '("GtkButtonBoxStyle" "layout_style") + ) +) + +(define-method set_child_secondary + (of-object "GtkButtonBox") + (c-name "gtk_button_box_set_child_secondary") + (return-type "none") + (parameters + '("GtkWidget" "child") + '("gboolean" "is_secondary") + ) +) + +(define-method set_child_size + (of-object "GtkButtonBox") + (c-name "gtk_button_box_set_child_size") + (return-type "none") + (parameters + '("gint" "min_width") + '("gint" "min_height") + ) +) + +(define-method set_child_ipadding + (of-object "GtkButtonBox") + (c-name "gtk_button_box_set_child_ipadding") + (return-type "none") + (parameters + '("gint" "ipad_x") + '("gint" "ipad_y") + ) +) + +(define-method get_child_size + (of-object "GtkButtonBox") + (c-name "gtk_button_box_get_child_size") + (return-type "none") + (parameters + '("gint*" "min_width") + '("gint*" "min_height") + ) +) + +(define-method get_child_ipadding + (of-object "GtkButtonBox") + (c-name "gtk_button_box_get_child_ipadding") + (return-type "none") + (parameters + '("gint*" "ipad_x") + '("gint*" "ipad_y") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkbin.h + +(define-function gtk_bin_get_type + (c-name "gtk_bin_get_type") + (return-type "GtkType") +) + +(define-method get_child + (of-object "GtkBin") + (c-name "gtk_bin_get_child") + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkbindings.h + +(define-function gtk_binding_set_new + (c-name "gtk_binding_set_new") + (return-type "GtkBindingSet*") + (parameters + '("const-gchar*" "set_name") + ) +) + +(define-function gtk_binding_set_by_class + (c-name "gtk_binding_set_by_class") + (return-type "GtkBindingSet*") + (parameters + '("gpointer" "object_class") + ) +) + +(define-function gtk_binding_set_find + (c-name "gtk_binding_set_find") + (return-type "GtkBindingSet*") + (parameters + '("const-gchar*" "set_name") + ) +) + +(define-function bindings_activate + (c-name "gtk_bindings_activate") + (return-type "gboolean") + (parameters + '("GtkObject*" "object") + '("guint" "keyval") + '("guint" "modifiers") + ) +) + +(define-method activate + (of-object "GtkBindingSet") + (c-name "gtk_binding_set_activate") + (return-type "gboolean") + (parameters + '("guint" "keyval") + '("guint" "modifiers") + '("GtkObject*" "object") + ) +) + +(define-function binding_entry_clear + (c-name "gtk_binding_entry_clear") + (return-type "none") + (parameters + '("GtkBindingSet*" "binding_set") + '("guint" "keyval") + '("guint" "modifiers") + ) +) + +(define-function binding_entry_add_signal + (c-name "gtk_binding_entry_add_signal") + (return-type "none") + (parameters + '("GtkBindingSet*" "binding_set") + '("guint" "keyval") + '("guint" "modifiers") + '("const-gchar*" "signal_name") + '("guint" "n_args") + ) + (varargs #t) +) + +(define-method add_path + (of-object "GtkBindingSet") + (c-name "gtk_binding_set_add_path") + (return-type "none") + (parameters + '("GtkPathType" "path_type") + '("const-gchar*" "path_pattern") + '("GtkPathPriorityType" "priority") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkbox.h + +(define-function gtk_box_get_type + (c-name "gtk_box_get_type") + (return-type "GtkType") +) + +(define-method pack_start + (of-object "GtkBox") + (c-name "gtk_box_pack_start") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "expand" (default "TRUE")) + '("gboolean" "fill" (default "TRUE")) + '("guint" "padding" (default "0")) + ) +) + +(define-method pack_end + (of-object "GtkBox") + (c-name "gtk_box_pack_end") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "expand" (default "TRUE")) + '("gboolean" "fill" (default "TRUE")) + '("guint" "padding" (default "0")) + ) +) + +(define-method pack_start_defaults + (of-object "GtkBox") + (c-name "gtk_box_pack_start_defaults") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method pack_end_defaults + (of-object "GtkBox") + (c-name "gtk_box_pack_end_defaults") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method set_homogeneous + (of-object "GtkBox") + (c-name "gtk_box_set_homogeneous") + (return-type "none") + (parameters + '("gboolean" "homogeneous") + ) +) + +(define-method get_homogeneous + (of-object "GtkBox") + (c-name "gtk_box_get_homogeneous") + (return-type "gboolean") +) + +(define-method set_spacing + (of-object "GtkBox") + (c-name "gtk_box_set_spacing") + (return-type "none") + (parameters + '("gint" "spacing") + ) +) + +(define-method get_spacing + (of-object "GtkBox") + (c-name "gtk_box_get_spacing") + (return-type "gint") +) + +(define-method reorder_child + (of-object "GtkBox") + (c-name "gtk_box_reorder_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "position") + ) +) + +(define-method query_child_packing + (of-object "GtkBox") + (c-name "gtk_box_query_child_packing") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean*" "expand") + '("gboolean*" "fill") + '("guint*" "padding") + '("GtkPackType*" "pack_type") + ) +) + +(define-method set_child_packing + (of-object "GtkBox") + (c-name "gtk_box_set_child_packing") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "expand") + '("gboolean" "fill") + '("guint" "padding") + '("GtkPackType" "pack_type") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkbutton.h + +(define-function gtk_button_get_type + (c-name "gtk_button_get_type") + (return-type "GtkType") +) + +(define-function gtk_button_new + (c-name "gtk_button_new") + (is-constructor-of GtkButton) + (return-type "GtkWidget*") +) + +(define-function gtk_button_new_with_label + (c-name "gtk_button_new_with_label") + (is-constructor-of GtkButton) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_button_new_from_stock + (c-name "gtk_button_new_from_stock") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "stock_id") + ) +) + +(define-function gtk_button_new_with_mnemonic + (c-name "gtk_button_new_with_mnemonic") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method pressed + (of-object "GtkButton") + (c-name "gtk_button_pressed") + (return-type "none") +) + +(define-method released + (of-object "GtkButton") + (c-name "gtk_button_released") + (return-type "none") +) + +(define-method clicked + (of-object "GtkButton") + (c-name "gtk_button_clicked") + (return-type "none") +) + +(define-method enter + (of-object "GtkButton") + (c-name "gtk_button_enter") + (return-type "none") +) + +(define-method leave + (of-object "GtkButton") + (c-name "gtk_button_leave") + (return-type "none") +) + +(define-method set_relief + (of-object "GtkButton") + (c-name "gtk_button_set_relief") + (return-type "none") + (parameters + '("GtkReliefStyle" "newstyle") + ) +) + +(define-method get_relief + (of-object "GtkButton") + (c-name "gtk_button_get_relief") + (return-type "GtkReliefStyle") +) + +(define-method set_label + (of-object "GtkButton") + (c-name "gtk_button_set_label") + (return-type "none") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method get_label + (of-object "GtkButton") + (c-name "gtk_button_get_label") + (return-type "const-gchar*") +) + +(define-method set_use_underline + (of-object "GtkButton") + (c-name "gtk_button_set_use_underline") + (return-type "none") + (parameters + '("gboolean" "value") + ) +) + +(define-method get_use_underline + (of-object "GtkButton") + (c-name "gtk_button_get_use_underline") + (return-type "gboolean") +) + +(define-method set_use_stock + (of-object "GtkButton") + (c-name "gtk_button_set_use_stock") + (return-type "none") + (parameters + '("gboolean" "value") + ) +) + +(define-method get_use_stock + (of-object "GtkButton") + (c-name "gtk_button_get_use_stock") + (return-type "gboolean") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcalendar.h + +(define-function gtk_calendar_get_type + (c-name "gtk_calendar_get_type") + (return-type "GtkType") +) + +(define-function gtk_calendar_new + (c-name "gtk_calendar_new") + (is-constructor-of GtkCalendar) + (return-type "GtkWidget*") +) + +(define-method select_month + (of-object "GtkCalendar") + (c-name "gtk_calendar_select_month") + (return-type "gint") + (parameters + '("guint" "month") + '("guint" "year") + ) +) + +(define-method select_day + (of-object "GtkCalendar") + (c-name "gtk_calendar_select_day") + (return-type "none") + (parameters + '("guint" "day") + ) +) + +(define-method mark_day + (of-object "GtkCalendar") + (c-name "gtk_calendar_mark_day") + (return-type "gint") + (parameters + '("guint" "day") + ) +) + +(define-method unmark_day + (of-object "GtkCalendar") + (c-name "gtk_calendar_unmark_day") + (return-type "gint") + (parameters + '("guint" "day") + ) +) + +(define-method clear_marks + (of-object "GtkCalendar") + (c-name "gtk_calendar_clear_marks") + (return-type "none") +) + +(define-method display_options + (of-object "GtkCalendar") + (c-name "gtk_calendar_display_options") + (return-type "none") + (parameters + '("GtkCalendarDisplayOptions" "flags") + ) +) + +(define-method get_date + (of-object "GtkCalendar") + (c-name "gtk_calendar_get_date") + (return-type "none") + (parameters + '("guint*" "year") + '("guint*" "month") + '("guint*" "day") + ) +) + +(define-method freeze + (of-object "GtkCalendar") + (c-name "gtk_calendar_freeze") + (return-type "none") +) + +(define-method thaw + (of-object "GtkCalendar") + (c-name "gtk_calendar_thaw") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcellrenderer.h + +(define-function gtk_cell_renderer_get_type + (c-name "gtk_cell_renderer_get_type") + (return-type "GtkType") +) + +(define-method get_size + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_get_size") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("gint*" "width") + '("gint*" "height") + ) +) + +(define-method render + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_render") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkWidget*" "widget") + '("GdkRectangle*" "background_area") + '("GdkRectangle*" "cell_area") + '("GdkRectangle*" "expose_area") + '("guint" "flags") + ) +) + +(define-method activate + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_activate") + (return-type "gboolean") + (parameters + '("GdkEvent*" "event") + '("GtkWidget*" "widget") + '("gchar*" "path") + '("GdkRectangle*" "background_area") + '("GdkRectangle*" "cell_area") + '("guint" "flags") + ) +) + +(define-method start_editing + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_start_editing") + (return-type "none") + (parameters + '("GdkEvent*" "event") + '("GtkWidget*" "widget") + '("gchar*" "path") + '("GdkRectangle*" "background_area") + '("GdkRectangle*" "cell_area") + '("guint" "flags") + ) +) + +(define-method set_fixed_size + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_set_fixed_size") + (return-type "none") + (parameters + '("gint" "width") + '("gint" "height") + ) +) + +(define-method get_fixed_size + (of-object "GtkCellRenderer") + (c-name "gtk_cell_renderer_get_fixed_size") + (return-type "none") + (parameters + '("gint*" "width") + '("gint*" "height") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcellrendererpixbuf.h + +(define-function gtk_cell_renderer_pixbuf_get_type + (c-name "gtk_cell_renderer_pixbuf_get_type") + (return-type "GtkType") +) + +(define-function gtk_cell_renderer_pixbuf_new + (c-name "gtk_cell_renderer_pixbuf_new") + (is-constructor-of GtkCellRendererPixbuf) + (return-type "GtkCellRenderer*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcellrenderertext.h + +(define-function gtk_cell_renderer_text_get_type + (c-name "gtk_cell_renderer_text_get_type") + (return-type "GtkType") +) + +(define-function gtk_cell_renderer_text_new + (c-name "gtk_cell_renderer_text_new") + (is-constructor-of GtkCellRendererText) + (return-type "GtkCellRenderer*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcellrenderertoggle.h + +(define-function gtk_cell_renderer_toggle_get_type + (c-name "gtk_cell_renderer_toggle_get_type") + (return-type "GtkType") +) + +(define-function gtk_cell_renderer_toggle_new + (c-name "gtk_cell_renderer_toggle_new") + (is-constructor-of GtkCellRendererToggle) + (return-type "GtkCellRenderer*") +) + +(define-method set_radio + (of-object "GtkCellRendererToggle") + (c-name "gtk_cell_renderer_toggle_set_radio") + (return-type "none") + (parameters + '("gboolean" "radio") + ) +) + +(define-method get_active + (of-object "GtkCellRendererToggle") + (c-name "gtk_cell_renderer_toggle_get_active") + (return-type "gboolean") +) + +(define-method set_active + (of-object "GtkCellRendererToggle") + (c-name "gtk_cell_renderer_toggle_set_active") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcheckbutton.h + +(define-function gtk_check_button_get_type + (c-name "gtk_check_button_get_type") + (return-type "GtkType") +) + +(define-function gtk_check_button_new + (c-name "gtk_check_button_new") + (is-constructor-of GtkCheckButton) + (return-type "GtkWidget*") +) + +(define-function gtk_check_button_new_with_label + (c-name "gtk_check_button_new_with_label") + (is-constructor-of GtkCheckButton) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_check_button_new_with_mnemonic + (c-name "gtk_check_button_new_with_mnemonic") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcheckmenuitem.h + +(define-function gtk_check_menu_item_get_type + (c-name "gtk_check_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_check_menu_item_new + (c-name "gtk_check_menu_item_new") + (is-constructor-of GtkCheckMenuItem) + (return-type "GtkWidget*") +) + +(define-function gtk_check_menu_item_new_with_label + (c-name "gtk_check_menu_item_new_with_label") + (is-constructor-of GtkCheckMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_check_menu_item_new_with_mnemonic + (c-name "gtk_check_menu_item_new_with_mnemonic") + (is-constructor-of GtkCheckMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method set_active + (of-object "GtkCheckMenuItem") + (c-name "gtk_check_menu_item_set_active") + (return-type "none") + (parameters + '("gboolean" "is_active") + ) +) + +(define-method get_active + (of-object "GtkCheckMenuItem") + (c-name "gtk_check_menu_item_get_active") + (return-type "gboolean") +) + +(define-method toggled + (of-object "GtkCheckMenuItem") + (c-name "gtk_check_menu_item_toggled") + (return-type "none") +) + +(define-method set_inconsistent + (of-object "GtkCheckMenuItem") + (c-name "gtk_check_menu_item_set_inconsistent") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_inconsistent + (of-object "GtkCheckMenuItem") + (c-name "gtk_check_menu_item_get_inconsistent") + (return-type "gboolean") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkclipboard.h + +(define-method set_with_data + (of-object "GtkClipboard") + (c-name "gtk_clipboard_set_with_data") + (return-type "gboolean") + (parameters + '("const-GtkTargetEntry*" "targets") + '("guint" "n_targets") + '("GtkClipboardGetFunc" "get_func") + '("GtkClipboardClearFunc" "clear_func") + '("gpointer" "user_data") + ) +) + +(define-method set_with_owner + (of-object "GtkClipboard") + (c-name "gtk_clipboard_set_with_owner") + (return-type "gboolean") + (parameters + '("const-GtkTargetEntry*" "targets") + '("guint" "n_targets") + '("GtkClipboardGetFunc" "get_func") + '("GtkClipboardClearFunc" "clear_func") + '("GObject*" "owner") + ) +) + +(define-method get_owner + (of-object "GtkClipboard") + (c-name "gtk_clipboard_get_owner") + (return-type "GObject*") +) + +(define-method clear + (of-object "GtkClipboard") + (c-name "gtk_clipboard_clear") + (return-type "none") +) + +(define-method set_text + (of-object "GtkClipboard") + (c-name "gtk_clipboard_set_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("gint" "len") + ) +) + +(define-method request_contents + (of-object "GtkClipboard") + (c-name "gtk_clipboard_request_contents") + (return-type "none") + (parameters + '("GdkAtom" "target") + '("GtkClipboardReceivedFunc" "callback") + '("gpointer" "user_data") + ) +) + +(define-method request_text + (of-object "GtkClipboard") + (c-name "gtk_clipboard_request_text") + (return-type "none") + (parameters + '("GtkClipboardTextReceivedFunc" "callback") + '("gpointer" "user_data") + ) +) + +(define-method wait_for_contents + (of-object "GtkClipboard") + (c-name "gtk_clipboard_wait_for_contents") + (return-type "GtkSelectionData*") + (parameters + '("GdkAtom" "target") + ) +) + +(define-method wait_for_text + (of-object "GtkClipboard") + (c-name "gtk_clipboard_wait_for_text") + (return-type "gchar*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkclist.h + +(define-function gtk_clist_get_type + (c-name "gtk_clist_get_type") + (return-type "GtkType") +) + +(define-method construct + (of-object "GtkCList") + (c-name "gtk_clist_construct") + (return-type "none") + (parameters + '("gint" "columns" (default "1")) + '("gchar*[]" "titles") + ) +) + +(define-function gtk_clist_new + (c-name "gtk_clist_new") + (is-constructor-of GtkCList) + (return-type "GtkWidget*") + (parameters + '("gint" "columns" (default "1")) + ) +) + +(define-function gtk_clist_new_with_titles + (c-name "gtk_clist_new_with_titles") + (is-constructor-of GtkCList) + (return-type "GtkWidget*") + (parameters + '("gint" "columns" (default "1")) + '("gchar*[]" "titles") + ) +) + +(define-method set_hadjustment + (of-object "GtkCList") + (c-name "gtk_clist_set_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method set_vadjustment + (of-object "GtkCList") + (c-name "gtk_clist_set_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_hadjustment + (of-object "GtkCList") + (c-name "gtk_clist_get_hadjustment") + (return-type "GtkAdjustment*") +) + +(define-method get_vadjustment + (of-object "GtkCList") + (c-name "gtk_clist_get_vadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_shadow_type + (of-object "GtkCList") + (c-name "gtk_clist_set_shadow_type") + (return-type "none") + (parameters + '("GtkShadowType" "type") + ) +) + +(define-method set_selection_mode + (of-object "GtkCList") + (c-name "gtk_clist_set_selection_mode") + (return-type "none") + (parameters + '("GtkSelectionMode" "mode") + ) +) + +(define-method set_reorderable + (of-object "GtkCList") + (c-name "gtk_clist_set_reorderable") + (return-type "none") + (parameters + '("gboolean" "reorderable") + ) +) + +(define-method set_use_drag_icons + (of-object "GtkCList") + (c-name "gtk_clist_set_use_drag_icons") + (return-type "none") + (parameters + '("gboolean" "use_icons") + ) +) + +(define-method set_button_actions + (of-object "GtkCList") + (c-name "gtk_clist_set_button_actions") + (return-type "none") + (parameters + '("guint" "button") + '("guint8" "button_actions") + ) +) + +(define-method freeze + (of-object "GtkCList") + (c-name "gtk_clist_freeze") + (return-type "none") +) + +(define-method thaw + (of-object "GtkCList") + (c-name "gtk_clist_thaw") + (return-type "none") +) + +(define-method column_titles_show + (of-object "GtkCList") + (c-name "gtk_clist_column_titles_show") + (return-type "none") +) + +(define-method column_titles_hide + (of-object "GtkCList") + (c-name "gtk_clist_column_titles_hide") + (return-type "none") +) + +(define-method column_title_active + (of-object "GtkCList") + (c-name "gtk_clist_column_title_active") + (return-type "none") + (parameters + '("gint" "column") + ) +) + +(define-method column_title_passive + (of-object "GtkCList") + (c-name "gtk_clist_column_title_passive") + (return-type "none") + (parameters + '("gint" "column") + ) +) + +(define-method column_titles_active + (of-object "GtkCList") + (c-name "gtk_clist_column_titles_active") + (return-type "none") +) + +(define-method column_titles_passive + (of-object "GtkCList") + (c-name "gtk_clist_column_titles_passive") + (return-type "none") +) + +(define-method set_column_title + (of-object "GtkCList") + (c-name "gtk_clist_set_column_title") + (return-type "none") + (parameters + '("gint" "column") + '("const-gchar*" "title") + ) +) + +(define-method get_column_title + (of-object "GtkCList") + (c-name "gtk_clist_get_column_title") + (return-type "gchar*") + (parameters + '("gint" "column") + ) +) + +(define-method set_column_widget + (of-object "GtkCList") + (c-name "gtk_clist_set_column_widget") + (return-type "none") + (parameters + '("gint" "column") + '("GtkWidget*" "widget") + ) +) + +(define-method get_column_widget + (of-object "GtkCList") + (c-name "gtk_clist_get_column_widget") + (return-type "GtkWidget*") + (parameters + '("gint" "column") + ) +) + +(define-method set_column_justification + (of-object "GtkCList") + (c-name "gtk_clist_set_column_justification") + (return-type "none") + (parameters + '("gint" "column") + '("GtkJustification" "justification") + ) +) + +(define-method set_column_visibility + (of-object "GtkCList") + (c-name "gtk_clist_set_column_visibility") + (return-type "none") + (parameters + '("gint" "column") + '("gboolean" "visible") + ) +) + +(define-method set_column_resizeable + (of-object "GtkCList") + (c-name "gtk_clist_set_column_resizeable") + (return-type "none") + (parameters + '("gint" "column") + '("gboolean" "resizeable") + ) +) + +(define-method set_column_auto_resize + (of-object "GtkCList") + (c-name "gtk_clist_set_column_auto_resize") + (return-type "none") + (parameters + '("gint" "column") + '("gboolean" "auto_resize") + ) +) + +(define-method columns_autosize + (of-object "GtkCList") + (c-name "gtk_clist_columns_autosize") + (return-type "gint") +) + +(define-method optimal_column_width + (of-object "GtkCList") + (c-name "gtk_clist_optimal_column_width") + (return-type "gint") + (parameters + '("gint" "column") + ) +) + +(define-method set_column_width + (of-object "GtkCList") + (c-name "gtk_clist_set_column_width") + (return-type "none") + (parameters + '("gint" "column") + '("gint" "width") + ) +) + +(define-method set_column_min_width + (of-object "GtkCList") + (c-name "gtk_clist_set_column_min_width") + (return-type "none") + (parameters + '("gint" "column") + '("gint" "min_width") + ) +) + +(define-method set_column_max_width + (of-object "GtkCList") + (c-name "gtk_clist_set_column_max_width") + (return-type "none") + (parameters + '("gint" "column") + '("gint" "max_width") + ) +) + +(define-method set_row_height + (of-object "GtkCList") + (c-name "gtk_clist_set_row_height") + (return-type "none") + (parameters + '("guint" "height") + ) +) + +(define-method moveto + (of-object "GtkCList") + (c-name "gtk_clist_moveto") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("gfloat" "row_align") + '("gfloat" "col_align") + ) +) + +(define-method row_is_visible + (of-object "GtkCList") + (c-name "gtk_clist_row_is_visible") + (return-type "GtkVisibility") + (parameters + '("gint" "row") + ) +) + +(define-method get_cell_type + (of-object "GtkCList") + (c-name "gtk_clist_get_cell_type") + (return-type "GtkCellType") + (parameters + '("gint" "row") + '("gint" "column") + ) +) + +(define-method set_text + (of-object "GtkCList") + (c-name "gtk_clist_set_text") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("const-gchar*" "text") + ) +) + +(define-method get_text + (of-object "GtkCList") + (c-name "gtk_clist_get_text") + (return-type "gint") + (parameters + '("gint" "row") + '("gint" "column") + '("gchar**" "text") + ) +) + +(define-method set_pixmap + (of-object "GtkCList") + (c-name "gtk_clist_set_pixmap") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask" (null-ok) (default "NULL")) + ) +) + +(define-method get_pixmap + (of-object "GtkCList") + (c-name "gtk_clist_get_pixmap") + (return-type "gint") + (parameters + '("gint" "row") + '("gint" "column") + '("GdkPixmap**" "pixmap") + '("GdkBitmap**" "mask") + ) +) + +(define-method set_pixtext + (of-object "GtkCList") + (c-name "gtk_clist_set_pixtext") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("const-gchar*" "text") + '("guint8" "spacing") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask") + ) +) + +(define-method get_pixtext + (of-object "GtkCList") + (c-name "gtk_clist_get_pixtext") + (return-type "gint") + (parameters + '("gint" "row") + '("gint" "column") + '("gchar**" "text") + '("guint8*" "spacing") + '("GdkPixmap**" "pixmap") + '("GdkBitmap**" "mask") + ) +) + +(define-method set_foreground + (of-object "GtkCList") + (c-name "gtk_clist_set_foreground") + (return-type "none") + (parameters + '("gint" "row") + '("GdkColor*" "color") + ) +) + +(define-method set_background + (of-object "GtkCList") + (c-name "gtk_clist_set_background") + (return-type "none") + (parameters + '("gint" "row") + '("GdkColor*" "color") + ) +) + +(define-method set_cell_style + (of-object "GtkCList") + (c-name "gtk_clist_set_cell_style") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("GtkStyle*" "style") + ) +) + +(define-method get_cell_style + (of-object "GtkCList") + (c-name "gtk_clist_get_cell_style") + (return-type "GtkStyle*") + (parameters + '("gint" "row") + '("gint" "column") + ) +) + +(define-method set_row_style + (of-object "GtkCList") + (c-name "gtk_clist_set_row_style") + (return-type "none") + (parameters + '("gint" "row") + '("GtkStyle*" "style") + ) +) + +(define-method get_row_style + (of-object "GtkCList") + (c-name "gtk_clist_get_row_style") + (return-type "GtkStyle*") + (parameters + '("gint" "row") + ) +) + +(define-method set_shift + (of-object "GtkCList") + (c-name "gtk_clist_set_shift") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + '("gint" "vertical") + '("gint" "horizontal") + ) +) + +(define-method set_selectable + (of-object "GtkCList") + (c-name "gtk_clist_set_selectable") + (return-type "none") + (parameters + '("gint" "row") + '("gboolean" "selectable") + ) +) + +(define-method get_selectable + (of-object "GtkCList") + (c-name "gtk_clist_get_selectable") + (return-type "gboolean") + (parameters + '("gint" "row") + ) +) + +(define-method prepend + (of-object "GtkCList") + (c-name "gtk_clist_prepend") + (return-type "gint") + (parameters + '("gchar*[]" "text") + ) +) + +(define-method append + (of-object "GtkCList") + (c-name "gtk_clist_append") + (return-type "gint") + (parameters + '("gchar*[]" "text") + ) +) + +(define-method insert + (of-object "GtkCList") + (c-name "gtk_clist_insert") + (return-type "gint") + (parameters + '("gint" "row") + '("gchar*[]" "text") + ) +) + +(define-method remove + (of-object "GtkCList") + (c-name "gtk_clist_remove") + (return-type "none") + (parameters + '("gint" "row") + ) +) + +(define-method set_row_data + (of-object "GtkCList") + (c-name "gtk_clist_set_row_data") + (return-type "none") + (parameters + '("gint" "row") + '("gpointer" "data") + ) +) + +(define-method set_row_data_full + (of-object "GtkCList") + (c-name "gtk_clist_set_row_data_full") + (return-type "none") + (parameters + '("gint" "row") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-method get_row_data + (of-object "GtkCList") + (c-name "gtk_clist_get_row_data") + (return-type "gpointer") + (parameters + '("gint" "row") + ) +) + +(define-method find_row_from_data + (of-object "GtkCList") + (c-name "gtk_clist_find_row_from_data") + (return-type "gint") + (parameters + '("gpointer" "data") + ) +) + +(define-method select_row + (of-object "GtkCList") + (c-name "gtk_clist_select_row") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + ) +) + +(define-method unselect_row + (of-object "GtkCList") + (c-name "gtk_clist_unselect_row") + (return-type "none") + (parameters + '("gint" "row") + '("gint" "column") + ) +) + +(define-method undo_selection + (of-object "GtkCList") + (c-name "gtk_clist_undo_selection") + (return-type "none") +) + +(define-method clear + (of-object "GtkCList") + (c-name "gtk_clist_clear") + (return-type "none") +) + +(define-method get_selection_info + (of-object "GtkCList") + (c-name "gtk_clist_get_selection_info") + (return-type "gint") + (parameters + '("gint" "x") + '("gint" "y") + '("gint*" "row") + '("gint*" "column") + ) +) + +(define-method select_all + (of-object "GtkCList") + (c-name "gtk_clist_select_all") + (return-type "none") +) + +(define-method unselect_all + (of-object "GtkCList") + (c-name "gtk_clist_unselect_all") + (return-type "none") +) + +(define-method swap_rows + (of-object "GtkCList") + (c-name "gtk_clist_swap_rows") + (return-type "none") + (parameters + '("gint" "row1") + '("gint" "row2") + ) +) + +(define-method row_move + (of-object "GtkCList") + (c-name "gtk_clist_row_move") + (return-type "none") + (parameters + '("gint" "source_row") + '("gint" "dest_row") + ) +) + +(define-method set_compare_func + (of-object "GtkCList") + (c-name "gtk_clist_set_compare_func") + (return-type "none") + (parameters + '("GtkCListCompareFunc" "cmp_func") + ) +) + +(define-method set_sort_column + (of-object "GtkCList") + (c-name "gtk_clist_set_sort_column") + (return-type "none") + (parameters + '("gint" "column") + ) +) + +(define-method set_sort_type + (of-object "GtkCList") + (c-name "gtk_clist_set_sort_type") + (return-type "none") + (parameters + '("GtkSortType" "sort_type") + ) +) + +(define-method sort + (of-object "GtkCList") + (c-name "gtk_clist_sort") + (return-type "none") +) + +(define-method set_auto_sort + (of-object "GtkCList") + (c-name "gtk_clist_set_auto_sort") + (return-type "none") + (parameters + '("gboolean" "auto_sort") + ) +) + +(define-method _create_cell_layout + (of-object "GtkCList") + (c-name "_gtk_clist_create_cell_layout") + (return-type "PangoLayout*") + (parameters + '("GtkCListRow*" "clist_row") + '("gint" "column") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcolorsel.h + +(define-function gtk_color_selection_get_type + (c-name "gtk_color_selection_get_type") + (return-type "GtkType") +) + +(define-function gtk_color_selection_new + (c-name "gtk_color_selection_new") + (is-constructor-of GtkColorSelection) + (return-type "GtkWidget*") +) + +(define-method get_has_opacity_control + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_has_opacity_control") + (return-type "gboolean") +) + +(define-method set_has_opacity_control + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_has_opacity_control") + (return-type "none") + (parameters + '("gboolean" "use_opacity") + ) +) + +(define-method get_has_palette + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_has_palette") + (return-type "gboolean") +) + +(define-method set_has_palette + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_has_palette") + (return-type "none") + (parameters + '("gboolean" "use_palette") + ) +) + +(define-method set_current_color + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_current_color") + (return-type "none") + (parameters + '("GdkColor*" "color") + ) +) + +(define-method set_current_alpha + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_current_alpha") + (return-type "none") + (parameters + '("guint16" "alpha") + ) +) + +(define-method get_current_color + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_current_color") + (return-type "none") + (parameters + '("GdkColor*" "color") + ) +) + +(define-method get_current_alpha + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_current_alpha") + (return-type "guint16") +) + +(define-method set_previous_color + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_previous_color") + (return-type "none") + (parameters + '("GdkColor*" "color") + ) +) + +(define-method set_previous_alpha + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_previous_alpha") + (return-type "none") + (parameters + '("guint16" "alpha") + ) +) + +(define-method get_previous_color + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_previous_color") + (return-type "none") + (parameters + '("GdkColor*" "color") + ) +) + +(define-method get_previous_alpha + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_get_previous_alpha") + (return-type "guint16") +) + +(define-method is_adjusting + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_is_adjusting") + (return-type "gboolean") +) + +(define-method set_update_policy + (of-object "GtkColorSelection") + (c-name "gtk_color_selection_set_update_policy") + (return-type "none") + (parameters + '("GtkUpdateType" "policy") + ) +) + +(define-function color_selection_palette_from_string + (c-name "gtk_color_selection_palette_from_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + '("GdkColor**" "colors") + '("gint" "n_colors") + ) +) + +(define-function color_selection_palette_to_string + (c-name "gtk_color_selection_palette_to_string") + (return-type "gchar*") + (parameters + '("const-GdkColor*" "colors") + '("gint" "n_colors") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcolorseldialog.h + +(define-function gtk_color_selection_dialog_get_type + (c-name "gtk_color_selection_dialog_get_type") + (return-type "GtkType") +) + +(define-function gtk_color_selection_dialog_new + (c-name "gtk_color_selection_dialog_new") + (is-constructor-of GtkColorSelectionDialog) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "title") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcombo.h + +(define-function gtk_combo_get_type + (c-name "gtk_combo_get_type") + (return-type "GtkType") +) + +(define-function gtk_combo_new + (c-name "gtk_combo_new") + (is-constructor-of GtkCombo) + (return-type "GtkWidget*") +) + +(define-method set_value_in_list + (of-object "GtkCombo") + (c-name "gtk_combo_set_value_in_list") + (return-type "none") + (parameters + '("gint" "val") + '("gint" "ok_if_empty") + ) +) + +(define-method set_use_arrows + (of-object "GtkCombo") + (c-name "gtk_combo_set_use_arrows") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method set_use_arrows_always + (of-object "GtkCombo") + (c-name "gtk_combo_set_use_arrows_always") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method set_case_sensitive + (of-object "GtkCombo") + (c-name "gtk_combo_set_case_sensitive") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method set_item_string + (of-object "GtkCombo") + (c-name "gtk_combo_set_item_string") + (return-type "none") + (parameters + '("GtkItem*" "item") + '("const-gchar*" "item_value") + ) +) + +(define-method set_popdown_strings + (of-object "GtkCombo") + (c-name "gtk_combo_set_popdown_strings") + (return-type "none") + (parameters + '("GList*" "strings") + ) +) + +(define-method disable_activate + (of-object "GtkCombo") + (c-name "gtk_combo_disable_activate") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcompat.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcontainer.h + +(define-function gtk_container_get_type + (c-name "gtk_container_get_type") + (return-type "GtkType") +) + +(define-method set_border_width + (of-object "GtkContainer") + (c-name "gtk_container_set_border_width") + (return-type "none") + (parameters + '("guint" "border_width") + ) +) + +(define-method get_border_width + (of-object "GtkContainer") + (c-name "gtk_container_get_border_width") + (return-type "guint") +) + +(define-method add + (of-object "GtkContainer") + (c-name "gtk_container_add") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method remove + (of-object "GtkContainer") + (c-name "gtk_container_remove") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method set_resize_mode + (of-object "GtkContainer") + (c-name "gtk_container_set_resize_mode") + (return-type "none") + (parameters + '("GtkResizeMode" "resize_mode") + ) +) + +(define-method get_resize_mode + (of-object "GtkContainer") + (c-name "gtk_container_get_resize_mode") + (return-type "GtkResizeMode") +) + +(define-method check_resize + (of-object "GtkContainer") + (c-name "gtk_container_check_resize") + (return-type "none") +) + +(define-method foreach + (of-object "GtkContainer") + (c-name "gtk_container_foreach") + (return-type "none") + (parameters + '("GtkCallback" "callback") + '("gpointer" "callback_data") + ) +) + +(define-method foreach_full + (of-object "GtkContainer") + (c-name "gtk_container_foreach_full") + (return-type "none") + (parameters + '("GtkCallback" "callback") + '("GtkCallbackMarshal" "marshal") + '("gpointer" "callback_data") + '("GtkDestroyNotify" "notify") + ) +) + +(define-method get_children + (of-object "GtkContainer") + (c-name "gtk_container_get_children") + (return-type "GList*") +) + +; DEPRECATED +(define-method children + (of-object "GtkContainer") + (c-name "gtk_container_children") + (return-type "GList*") +) + +(define-method propagate_expose + (of-object "GtkContainer") + (c-name "gtk_container_propagate_expose") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GdkEventExpose*" "event") + ) +) + +(define-method set_focus_chain + (of-object "GtkContainer") + (c-name "gtk_container_set_focus_chain") + (return-type "none") + (parameters + '("GList*" "focusable_widgets") + ) +) + +(define-method get_focus_chain + (of-object "GtkContainer") + (c-name "gtk_container_get_focus_chain") + (return-type "gboolean") + (parameters + '("GList**" "focusable_widgets") + ) +) + +(define-method unset_focus_chain + (of-object "GtkContainer") + (c-name "gtk_container_unset_focus_chain") + (return-type "none") +) + +(define-method set_reallocate_redraws + (of-object "GtkContainer") + (c-name "gtk_container_set_reallocate_redraws") + (return-type "none") + (parameters + '("gboolean" "needs_redraws") + ) +) + +(define-method set_focus_child + (of-object "GtkContainer") + (c-name "gtk_container_set_focus_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method set_focus_vadjustment + (of-object "GtkContainer") + (c-name "gtk_container_set_focus_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_focus_vadjustment + (of-object "GtkContainer") + (c-name "gtk_container_get_focus_vadjustment") + (return-type "GtkAdjustment") +) + +(define-method set_focus_hadjustment + (of-object "GtkContainer") + (c-name "gtk_container_set_focus_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_focus_hadjustment + (of-object "GtkContainer") + (c-name "gtk_container_get_focus_hadjustment") + (return-type "GtkAdjustment") +) + +(define-method resize_children + (of-object "GtkContainer") + (c-name "gtk_container_resize_children") + (return-type "none") +) + +(define-method child_type + (of-object "GtkContainer") + (c-name "gtk_container_child_type") + (return-type "GtkType") +) + +; FIXME +; +;gtk_container_class_install_child_property +;gtk_container_class_find_child_property +;gtk_container_class_list_child_properties +;gtk_container_child_set_property +;gtk_container_child_get_property + +(define-method add_with_properties + (of-object "GtkContainer") + (c-name "gtk_container_add_with_properties") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-method child_set + (of-object "GtkContainer") + (c-name "gtk_container_child_set") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-method child_get + (of-object "GtkContainer") + (c-name "gtk_container_child_get") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-method forall + (of-object "GtkContainer") + (c-name "gtk_container_forall") + (return-type "none") + (parameters + '("GtkCallback" "callback") + '("gpointer" "callback_data") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkctree.h + +(define-function gtk_ctree_get_type + (c-name "gtk_ctree_get_type") + (return-type "GtkType") +) + +(define-method construct + (of-object "GtkCTree") + (c-name "gtk_ctree_construct") + (return-type "none") + (parameters + '("gint" "columns" (default "1")) + '("gint" "tree_column" (default "0")) + '("gchar*[]" "titles") + ) +) + +(define-function gtk_ctree_new_with_titles + (c-name "gtk_ctree_new_with_titles") + (is-constructor-of GtkCTree) + (return-type "GtkWidget*") + (parameters + '("gint" "columns" (default "1")) + '("gint" "tree_column" (default "0")) + '("gchar*[]" "titles") + ) +) + +(define-function gtk_ctree_new + (c-name "gtk_ctree_new") + (is-constructor-of GtkCTree) + (return-type "GtkWidget*") + (parameters + '("gint" "columns" (default "1")) + '("gint" "tree_column" (default "0")) + ) +) + +(define-method base_nodes + (of-object "GtkCTree") + (c-name "gtk_ctree_base_nodes") + (return-type "GList*") +) + +(define-method insert_node + (of-object "GtkCTree") + (c-name "gtk_ctree_insert_node") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeNode*" "parent") + '("GtkCTreeNode*" "sibling") + '("gchar*[]" "text") + '("guint8" "spacing" (default "5")) + '("GdkPixmap*" "pixmap_closed" (null-ok) (default "NULL")) + '("GdkBitmap*" "mask_closed" (null-ok) (default "NULL")) + '("GdkPixmap*" "pixmap_opened" (null-ok) (default "NULL")) + '("GdkBitmap*" "mask_opened" (null-ok) (default "NULL")) + '("gboolean" "is_leaf" (default "1")) + '("gboolean" "expanded" (default "0")) + ) +) + +(define-method remove_node + (of-object "GtkCTree") + (c-name "gtk_ctree_remove_node") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method insert_gnode + (of-object "GtkCTree") + (c-name "gtk_ctree_insert_gnode") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeNode*" "parent") + '("GtkCTreeNode*" "sibling") + '("GNode*" "gnode") + '("GtkCTreeGNodeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method export_to_gnode + (of-object "GtkCTree") + (c-name "gtk_ctree_export_to_gnode") + (return-type "GNode*") + (parameters + '("GNode*" "parent") + '("GNode*" "sibling") + '("GtkCTreeNode*" "node") + '("GtkCTreeGNodeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method post_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_post_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GtkCTreeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method post_recursive_to_depth + (of-object "GtkCTree") + (c-name "gtk_ctree_post_recursive_to_depth") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "depth") + '("GtkCTreeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method pre_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_pre_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GtkCTreeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method pre_recursive_to_depth + (of-object "GtkCTree") + (c-name "gtk_ctree_pre_recursive_to_depth") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "depth") + '("GtkCTreeFunc" "func") + '("gpointer" "data") + ) +) + +(define-method is_viewable + (of-object "GtkCTree") + (c-name "gtk_ctree_is_viewable") + (return-type "gboolean") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method last + (of-object "GtkCTree") + (c-name "gtk_ctree_last") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method find_node_ptr + (of-object "GtkCTree") + (c-name "gtk_ctree_find_node_ptr") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeRow*" "ctree_row") + ) +) + +(define-method node_nth + (of-object "GtkCTree") + (c-name "gtk_ctree_node_nth") + (return-type "GtkCTreeNode*") + (parameters + '("guint" "row") + ) +) + +(define-method find + (of-object "GtkCTree") + (c-name "gtk_ctree_find") + (return-type "gboolean") + (parameters + '("GtkCTreeNode*" "node") + '("GtkCTreeNode*" "child") + ) +) + +(define-method is_ancestor + (of-object "GtkCTree") + (c-name "gtk_ctree_is_ancestor") + (return-type "gboolean") + (parameters + '("GtkCTreeNode*" "node") + '("GtkCTreeNode*" "child") + ) +) + +(define-method find_by_row_data + (of-object "GtkCTree") + (c-name "gtk_ctree_find_by_row_data") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + ) +) + +(define-method find_all_by_row_data + (of-object "GtkCTree") + (c-name "gtk_ctree_find_all_by_row_data") + (return-type "GList*") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + ) +) + +(define-method find_by_row_data_custom + (of-object "GtkCTree") + (c-name "gtk_ctree_find_by_row_data_custom") + (return-type "GtkCTreeNode*") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method find_all_by_row_data_custom + (of-object "GtkCTree") + (c-name "gtk_ctree_find_all_by_row_data_custom") + (return-type "GList*") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + '("GCompareFunc" "func") + ) +) + +(define-method is_hot_spot + (of-object "GtkCTree") + (c-name "gtk_ctree_is_hot_spot") + (return-type "gboolean") + (parameters + '("gint" "x") + '("gint" "y") + ) +) + +(define-method move + (of-object "GtkCTree") + (c-name "gtk_ctree_move") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GtkCTreeNode*" "new_parent" (null-ok)) + '("GtkCTreeNode*" "new_sibling" (null-ok)) + ) +) + +(define-method expand + (of-object "GtkCTree") + (c-name "gtk_ctree_expand") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method expand_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_expand_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method expand_to_depth + (of-object "GtkCTree") + (c-name "gtk_ctree_expand_to_depth") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "depth") + ) +) + +(define-method collapse + (of-object "GtkCTree") + (c-name "gtk_ctree_collapse") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method collapse_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_collapse_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method collapse_to_depth + (of-object "GtkCTree") + (c-name "gtk_ctree_collapse_to_depth") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "depth") + ) +) + +(define-method toggle_expansion + (of-object "GtkCTree") + (c-name "gtk_ctree_toggle_expansion") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method toggle_expansion_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_toggle_expansion_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method select + (of-object "GtkCTree") + (c-name "gtk_ctree_select") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method select_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_select_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method unselect + (of-object "GtkCTree") + (c-name "gtk_ctree_unselect") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method unselect_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_unselect_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method real_select_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_real_select_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "state") + ) +) + +(define-method node_set_text + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_text") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("const-gchar*" "text") + ) +) + +(define-method node_set_pixmap + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_pixmap") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask" (null-ok)) + ) +) + +(define-method node_set_pixtext + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_pixtext") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("const-gchar*" "text") + '("guint8" "spacing") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask" (null-ok)) + ) +) + +(define-method set_node_info + (of-object "GtkCTree") + (c-name "gtk_ctree_set_node_info") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("const-gchar*" "text") + '("guint8" "spacing") + '("GdkPixmap*" "pixmap_closed" (null-ok)) + '("GdkBitmap*" "mask_closed" (null-ok)) + '("GdkPixmap*" "pixmap_opened" (null-ok)) + '("GdkBitmap*" "mask_opened" (null-ok)) + '("gboolean" "is_leaf") + '("gboolean" "expanded") + ) +) + +(define-method node_set_shift + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_shift") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("gint" "vertical") + '("gint" "horizontal") + ) +) + +(define-method node_set_selectable + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_selectable") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gboolean" "selectable") + ) +) + +(define-method node_get_selectable + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_selectable") + (return-type "gboolean") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method node_get_cell_type + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_cell_type") + (return-type "GtkCellType") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + ) +) + +(define-method node_get_text + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_text") + (return-type "gint") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("gchar**" "text") + ) +) + +(define-method node_get_pixmap + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_pixmap") + (return-type "gint") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("GdkPixmap**" "pixmap") + '("GdkBitmap**" "mask") + ) +) + +(define-method node_get_pixtext + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_pixtext") + (return-type "gint") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("gchar**" "text") + '("guint8*" "spacing") + '("GdkPixmap**" "pixmap") + '("GdkBitmap**" "mask") + ) +) + +(define-method get_node_info + (of-object "GtkCTree") + (c-name "gtk_ctree_get_node_info") + (return-type "gint") + (parameters + '("GtkCTreeNode*" "node") + '("gchar**" "text") + '("guint8*" "spacing") + '("GdkPixmap**" "pixmap_closed") + '("GdkBitmap**" "mask_closed") + '("GdkPixmap**" "pixmap_opened") + '("GdkBitmap**" "mask_opened") + '("gboolean*" "is_leaf") + '("gboolean*" "expanded") + ) +) + +(define-method node_set_row_style + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_row_style") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GtkStyle*" "style") + ) +) + +(define-method node_get_row_style + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_row_style") + (return-type "GtkStyle*") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method node_set_cell_style + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_cell_style") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("GtkStyle*" "style") + ) +) + +(define-method node_get_cell_style + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_cell_style") + (return-type "GtkStyle*") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + ) +) + +(define-method node_set_foreground + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_foreground") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GdkColor*" "color") + ) +) + +(define-method node_set_background + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_background") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("GdkColor*" "color") + ) +) + +(define-method node_set_row_data + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_row_data") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + ) +) + +(define-method node_set_row_data_full + (of-object "GtkCTree") + (c-name "gtk_ctree_node_set_row_data_full") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-method node_get_row_data + (of-object "GtkCTree") + (c-name "gtk_ctree_node_get_row_data") + (return-type "gpointer") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method node_moveto + (of-object "GtkCTree") + (c-name "gtk_ctree_node_moveto") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + '("gint" "column") + '("gfloat" "row_align") + '("gfloat" "col_align") + ) +) + +(define-method node_is_visible + (of-object "GtkCTree") + (c-name "gtk_ctree_node_is_visible") + (return-type "GtkVisibility") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method set_indent + (of-object "GtkCTree") + (c-name "gtk_ctree_set_indent") + (return-type "none") + (parameters + '("gint" "indent") + ) +) + +(define-method set_spacing + (of-object "GtkCTree") + (c-name "gtk_ctree_set_spacing") + (return-type "none") + (parameters + '("gint" "spacing") + ) +) + +(define-method set_show_stub + (of-object "GtkCTree") + (c-name "gtk_ctree_set_show_stub") + (return-type "none") + (parameters + '("gboolean" "show_stub") + ) +) + +(define-method set_line_style + (of-object "GtkCTree") + (c-name "gtk_ctree_set_line_style") + (return-type "none") + (parameters + '("GtkCTreeLineStyle" "line_style") + ) +) + +(define-method set_expander_style + (of-object "GtkCTree") + (c-name "gtk_ctree_set_expander_style") + (return-type "none") + (parameters + '("GtkCTreeExpanderStyle" "expander_style") + ) +) + +(define-method set_drag_compare_func + (of-object "GtkCTree") + (c-name "gtk_ctree_set_drag_compare_func") + (return-type "none") + (parameters + '("GtkCTreeCompareDragFunc" "cmp_func") + ) +) + +(define-method sort_node + (of-object "GtkCTree") + (c-name "gtk_ctree_sort_node") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-method sort_recursive + (of-object "GtkCTree") + (c-name "gtk_ctree_sort_recursive") + (return-type "none") + (parameters + '("GtkCTreeNode*" "node") + ) +) + +(define-function ctree_node_from_cobject + (c-name "gtk_ctree_node_from_cobject") + (return-type "GtkCTreeNode*") + (parameters + '("PyCObject*" "node") + ) +) + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkcurve.h + +(define-function gtk_curve_get_type + (c-name "gtk_curve_get_type") + (return-type "GtkType") +) + +(define-function gtk_curve_new + (c-name "gtk_curve_new") + (is-constructor-of GtkCurve) + (return-type "GtkWidget*") +) + +(define-method reset + (of-object "GtkCurve") + (c-name "gtk_curve_reset") + (return-type "none") +) + +(define-method set_gamma + (of-object "GtkCurve") + (c-name "gtk_curve_set_gamma") + (return-type "none") + (parameters + '("gfloat" "gamma") + ) +) + +(define-method set_range + (of-object "GtkCurve") + (c-name "gtk_curve_set_range") + (return-type "none") + (parameters + '("gfloat" "min_x") + '("gfloat" "max_x") + '("gfloat" "min_y") + '("gfloat" "max_y") + ) +) + +(define-method get_vector + (of-object "GtkCurve") + (c-name "gtk_curve_get_vector") + (return-type "none") + (parameters + '("int" "veclen") + '("gfloat[]" "vector") + ) +) + +(define-method set_vector + (of-object "GtkCurve") + (c-name "gtk_curve_set_vector") + (return-type "none") + (parameters + '("int" "veclen") + '("gfloat[]" "vector") + ) +) + +(define-method set_curve_type + (of-object "GtkCurve") + (c-name "gtk_curve_set_curve_type") + (return-type "none") + (parameters + '("GtkCurveType" "type") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkdebug.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkdialog.h + +(define-function gtk_dialog_get_type + (c-name "gtk_dialog_get_type") + (return-type "GtkType") +) + +(define-function gtk_dialog_new + (c-name "gtk_dialog_new") + (is-constructor-of GtkDialog) + (return-type "GtkWidget*") +) + +(define-function gtk_dialog_new_with_buttons + (c-name "gtk_dialog_new_with_buttons") + (is-constructor-of GtkDialog) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "title" (null-ok) (default "NULL")) + '("GtkWindow*" "parent" (null-ok) (default "NULL")) + '("GtkDialogFlags" "flags" (default "0")) + '("const-gchar*" "first_button_text" (null-ok) (default "NULL")) + ) + (varargs #t) +) + +(define-method add_action_widget + (of-object "GtkDialog") + (c-name "gtk_dialog_add_action_widget") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "response_id") + ) +) + +(define-method add_button + (of-object "GtkDialog") + (c-name "gtk_dialog_add_button") + (return-type "none") + (parameters + '("const-gchar*" "button_text") + '("gint" "response_id") + ) +) + +(define-method add_buttons + (of-object "GtkDialog") + (c-name "gtk_dialog_add_buttons") + (return-type "none") + (parameters + '("const-gchar*" "first_button_text") + ) + (varargs #t) +) + +(define-method set_response_sensitive + (of-object "GtkDialog") + (c-name "gtk_dialog_set_response_sensitive") + (return-type "none") + (parameters + '("gint" "response_id") + '("gboolean" "setting") + ) +) + +(define-method set_default_response + (of-object "GtkDialog") + (c-name "gtk_dialog_set_default_response") + (return-type "none") + (parameters + '("gint" "response_id") + ) +) + +(define-method set_has_separator + (of-object "GtkDialog") + (c-name "gtk_dialog_set_has_separator") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_has_separator + (of-object "GtkDialog") + (c-name "gtk_dialog_get_has_separator") + (return-type "gboolean") +) + +(define-method response + (of-object "GtkDialog") + (c-name "gtk_dialog_response") + (return-type "none") + (parameters + '("gint" "response_id") + ) +) + +(define-method run + (of-object "GtkDialog") + (c-name "gtk_dialog_run") + (return-type "gint") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkdnd.h + +(define-method drag_get_data + (of-object "GtkWidget") + (c-name "gtk_drag_get_data") + (return-type "none") + (parameters + '("GdkDragContext*" "context") + '("GdkAtom" "target") + '("guint32" "time" (default "GDK_CURRENT_TIME")) + ) +) + + +;(define-method finish +; (of-object "GdkDragContext") +; (c-name "gtk_drag_finish") +; (return-type "none") +; (parameters +; '("gboolean" "success") +; '("gboolean" "del") +; '("guint32" "time" (default "GDK_CURRENT_TIME")) +; ) +;) + +;(define-method get_source_widget +; (of-object "GdkDragContext") +; (c-name "gtk_drag_get_source_widget") +; (return-type "GtkWidget*") +;) + +(define-method drag_highlight + (of-object "GtkWidget") + (c-name "gtk_drag_highlight") + (return-type "none") +) + +(define-method drag_unhighlight + (of-object "GtkWidget") + (c-name "gtk_drag_unhighlight") + (return-type "none") +) + +(define-method drag_dest_set + (of-object "GtkWidget") + (c-name "gtk_drag_dest_set") + (return-type "none") + (parameters + '("GtkDestDefaults" "flags") + '("const-GtkTargetEntry*" "targets") + '("gint" "n_targets") + '("GdkDragAction" "actions") + ) +) + +(define-method drag_dest_set_proxy + (of-object "GtkWidget") + (c-name "gtk_drag_dest_set_proxy") + (return-type "none") + (parameters + '("GdkWindow*" "proxy_window") + '("GdkDragProtocol" "protocol") + '("gboolean" "use_coordinates") + ) +) + +(define-method drag_dest_unset + (of-object "GtkWidget") + (c-name "gtk_drag_dest_unset") + (return-type "none") +) + +(define-method drag_dest_find_target + (of-object "GtkWidget") + (c-name "gtk_drag_dest_find_target") + (return-type "GdkAtom") + (parameters + '("GdkDragContext*" "context") + '("GtkTargetList*" "target_list") + ) +) + +(define-method drag_dest_get_target_list + (of-object "GtkWidget") + (c-name "gtk_drag_dest_get_target_list") + (return-type "GtkTargetList*") +) + +(define-method drag_dest_set_target_list + (of-object "GtkWidget") + (c-name "gtk_drag_dest_set_target_list") + (return-type "none") + (parameters + '("GtkTargetList*" "target_list") + ) +) + +(define-method drag_source_set + (of-object "GtkWidget") + (c-name "gtk_drag_source_set") + (return-type "none") + (parameters + '("GdkModifierType" "start_button_mask") + '("const-GtkTargetEntry*" "targets") + '("gint" "n_targets") + '("GdkDragAction" "actions") + ) +) + +(define-method drag_source_unset + (of-object "GtkWidget") + (c-name "gtk_drag_source_unset") + (return-type "none") +) + +(define-method drag_source_set_icon + (of-object "GtkWidget") + (c-name "gtk_drag_source_set_icon") + (return-type "none") + (parameters + '("GdkColormap*" "colormap") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask") + ) +) + +(define-method drag_begin + (of-object "GtkWidget") + (c-name "gtk_drag_begin") + (return-type "GdkDragContext*") + (parameters + '("GtkTargetList*" "targets") + '("GdkDragAction" "actions") + '("gint" "button") + '("GdkEvent*" "event") + ) +) + +;(define-method set_icon_widget +; (of-object "GdkDragContext") +; (c-name "gtk_drag_set_icon_widget") +; (return-type "none") +; (parameters +; '("GtkWidget*" "widget") +; '("gint" "hot_x") +; '("gint" "hot_y") +; ) +;) + +;(define-method set_icon_pixmap +; (of-object "GdkDragContext") +; (c-name "gtk_drag_set_icon_pixmap") +; (return-type "none") +; (parameters +; '("GdkColormap*" "colormap") +; '("GdkPixmap*" "pixmap") +; '("GdkBitmap*" "mask") +; '("gint" "hot_x") +; '("gint" "hot_y") +; ) +;) + +;(define-method set_icon_default +; (of-object "GdkDragContext") +; (c-name "gtk_drag_set_icon_default") +; (return-type "none") +;) + +(define-function drag_set_default_icon + (c-name "gtk_drag_set_default_icon") + (return-type "none") + (parameters + '("GdkColormap*" "colormap") + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask") + '("gint" "hot_x") + '("gint" "hot_y") + ) +) + +(define-method drag_source_handle_event + (of-object "GtkWidget") + (c-name "gtk_drag_source_handle_event") + (return-type "none") + (parameters + '("GdkEvent*" "event") + ) +) + +(define-method drag_dest_handle_event + (of-object "GtkWidget") + (c-name "gtk_drag_dest_handle_event") + (return-type "none") + (parameters + '("GdkEvent*" "event") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkdrawingarea.h + +(define-function gtk_drawing_area_get_type + (c-name "gtk_drawing_area_get_type") + (return-type "GtkType") +) + +(define-function gtk_drawing_area_new + (c-name "gtk_drawing_area_new") + (is-constructor-of GtkDrawingArea) + (return-type "GtkWidget*") +) + +; DEPRECATED +(define-method size + (of-object "GtkDrawingArea") + (c-name "gtk_drawing_area_size") + (return-type "none") + (parameters + '("gint" "width") + '("gint" "height") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkeditable.h + +(define-function gtk_editable_get_type + (c-name "gtk_editable_get_type") + (return-type "GtkType") +) + +(define-method select_region + (of-object "GtkEditable") + (c-name "gtk_editable_select_region") + (return-type "none") + (parameters + '("gint" "start") + '("gint" "end") + ) +) + +(define-method get_selection_bounds + (of-object "GtkEditable") + (c-name "gtk_editable_get_selection_bounds") + (return-type "gboolean") + (parameters + '("gint*" "start") + '("gint*" "end") + ) +) + +(define-method insert_text + (of-object "GtkEditable") + (c-name "gtk_editable_insert_text") + (return-type "none") + (parameters + '("const-gchar*" "new_text") + '("gint" "new_text_length") + '("gint*" "position") + ) +) + +(define-method delete_text + (of-object "GtkEditable") + (c-name "gtk_editable_delete_text") + (return-type "none") + (parameters + '("gint" "start_pos") + '("gint" "end_pos") + ) +) + +(define-method get_chars + (of-object "GtkEditable") + (c-name "gtk_editable_get_chars") + (return-type "gchar*") + (parameters + '("gint" "start_pos") + '("gint" "end_pos") + ) +) + +(define-method cut_clipboard + (of-object "GtkEditable") + (c-name "gtk_editable_cut_clipboard") + (return-type "none") +) + +(define-method copy_clipboard + (of-object "GtkEditable") + (c-name "gtk_editable_copy_clipboard") + (return-type "none") +) + +(define-method paste_clipboard + (of-object "GtkEditable") + (c-name "gtk_editable_paste_clipboard") + (return-type "none") +) + +(define-method delete_selection + (of-object "GtkEditable") + (c-name "gtk_editable_delete_selection") + (return-type "none") +) + +(define-method set_position + (of-object "GtkEditable") + (c-name "gtk_editable_set_position") + (return-type "none") + (parameters + '("gint" "position") + ) +) + +(define-method get_position + (of-object "GtkEditable") + (c-name "gtk_editable_get_position") + (return-type "gint") +) + +(define-method set_editable + (of-object "GtkEditable") + (c-name "gtk_editable_set_editable") + (return-type "none") + (parameters + '("gboolean" "is_editable") + ) +) + +(define-method get_editable + (of-object "GtkEditable") + (c-name "gtk_editable_get_editable") + (return-type "gboolean") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkoldeditable.h + +(define-function gtk_old_editable_get_type + (c-name "gtk_old_editable_get_type") + (return-type "none") +) + +(define-method claim_selection + (of-object "GtkOldEditable") + (c-name "gtk_old_editable_claim_selection") + (return-type "none") + (parameters + '("gboolean" "claim") + '("guint" "time" (default "GDK_CURRENT_TIME")) + ) +) + +(define-method changed + (of-object "GtkOldEditable") + (c-name "gtk_old_editable_changed") + (return-type "none") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkentry.h + +(define-function gtk_entry_get_type + (c-name "gtk_entry_get_type") + (return-type "GtkType") +) + +(define-function gtk_entry_new + (c-name "gtk_entry_new") + (is-constructor-of GtkEntry) + (return-type "GtkWidget*") +) + +; DEPRECATED +(define-function gtk_entry_new_with_max_length + (c-name "gtk_entry_new_with_max_length") + (is-constructor-of GtkEntry) + (return-type "GtkWidget*") + (parameters + '("guint16" "max" (default "0")) + ) +) + +(define-method set_visibility + (of-object "GtkEntry") + (c-name "gtk_entry_set_visibility") + (return-type "none") + (parameters + '("gboolean" "visible") + ) +) + +(define-method get_visibility + (of-object "GtkEntry") + (c-name "gtk_entry_get_visibility") + (return-type "gboolean") +) + +(define-method set_invisible_char + (of-object "GtkEntry") + (c-name "gtk_entry_set_invisible_char") + (return-type "none") + (parameters + '("gunichar" "ch") + ) +) + +(define-method get_invisible_char + (of-object "GtkEntry") + (c-name "gtk_entry_get_invisible_char") + (return-type "gunichar") +) + +(define-method set_editable + (of-object "GtkEntry") + (c-name "gtk_entry_set_editable") + (return-type "none") + (parameters + '("gboolean" "editable") + ) +) + +(define-method set_has_frame + (of-object "GtkEntry") + (c-name "gtk_entry_set_has_frame") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_has_frame + (of-object "GtkEntry") + (c-name "gtk_entry_get_has_frame") + (return-type "gboolean") +) + +(define-method set_max_length + (of-object "GtkEntry") + (c-name "gtk_entry_set_max_length") + (return-type "none") + (parameters + '("gint" "max") + ) +) + +(define-method get_max_length + (of-object "GtkEntry") + (c-name "gtk_entry_get_max_length") + (return-type "gint") +) + +(define-method set_activates_default + (of-object "GtkEntry") + (c-name "gtk_entry_set_activates_default") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_activates_default + (of-object "GtkEntry") + (c-name "gtk_entry_get_activates_default") + (return-type "gboolean") +) + +(define-method set_width_chars + (of-object "GtkEntry") + (c-name "gtk_entry_set_width_chars") + (return-type "none") + (parameters + '("gint" "n_chars") + ) +) + +(define-method get_width_chars + (of-object "GtkEntry") + (c-name "gtk_entry_get_width_chars") + (return-type "gint") +) + +(define-method set_text + (of-object "GtkEntry") + (c-name "gtk_entry_set_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + ) +) + +(define-method get_text + (of-object "GtkEntry") + (c-name "gtk_entry_get_text") + (return-type "const-gchar*") +) + +(define-method get_layout + (of-object "GtkEntry") + (c-name "gtk_entry_get_layout") + (return-type "PangoLayout*") +) + +(define-method get_layout_offsets + (of-object "GtkEntry") + (c-name "gtk_entry_get_layout_offsets") + (return-type "none") + (parameters + '("gint*" "x") + '("gint*" "y") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkenums.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkeventbox.h + +(define-function gtk_event_box_get_type + (c-name "gtk_event_box_get_type") + (return-type "GtkType") +) + +(define-function gtk_event_box_new + (c-name "gtk_event_box_new") + (is-constructor-of GtkEventBox) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkfilesel.h + +(define-function gtk_file_selection_get_type + (c-name "gtk_file_selection_get_type") + (return-type "GtkType") +) + +(define-function gtk_file_selection_new + (c-name "gtk_file_selection_new") + (is-constructor-of GtkFileSelection) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "title" (null-ok) (default "NULL")) + ) +) + +(define-method set_filename + (of-object "GtkFileSelection") + (c-name "gtk_file_selection_set_filename") + (return-type "none") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-method get_filename + (of-object "GtkFileSelection") + (c-name "gtk_file_selection_get_filename") + (return-type "const-gchar*") +) + +(define-method complete + (of-object "GtkFileSelection") + (c-name "gtk_file_selection_complete") + (return-type "none") + (parameters + '("const-gchar*" "pattern") + ) +) + +(define-method show_fileop_buttons + (of-object "GtkFileSelection") + (c-name "gtk_file_selection_show_fileop_buttons") + (return-type "none") +) + +(define-method hide_fileop_buttons + (of-object "GtkFileSelection") + (c-name "gtk_file_selection_hide_fileop_buttons") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkfixed.h + +(define-function gtk_fixed_get_type + (c-name "gtk_fixed_get_type") + (return-type "GtkType") +) + +(define-function gtk_fixed_new + (c-name "gtk_fixed_new") + (is-constructor-of GtkFixed) + (return-type "GtkWidget*") +) + +(define-method put + (of-object "GtkFixed") + (c-name "gtk_fixed_put") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("gint16" "x") + '("gint16" "y") + ) +) + +(define-method move + (of-object "GtkFixed") + (c-name "gtk_fixed_move") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("gint16" "x") + '("gint16" "y") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkfontsel.h + +(define-function gtk_font_selection_get_type + (c-name "gtk_font_selection_get_type") + (return-type "GtkType") +) + +(define-function gtk_font_selection_new + (c-name "gtk_font_selection_new") + (is-constructor-of GtkFontSelection) + (return-type "GtkWidget*") +) + +(define-method get_font_name + (of-object "GtkFontSelection") + (c-name "gtk_font_selection_get_font_name") + (return-type "gchar*") +) + +; DEPRECATED +(define-method get_font + (of-object "GtkFontSelection") + (c-name "gtk_font_selection_get_font") + (return-type "GdkFont*") +) + +(define-method set_font_name + (of-object "GtkFontSelection") + (c-name "gtk_font_selection_set_font_name") + (return-type "gboolean") + (parameters + '("const-gchar*" "fontname") + ) +) + +(define-method get_preview_text + (of-object "GtkFontSelection") + (c-name "gtk_font_selection_get_preview_text") + (return-type "gchar*") +) + +(define-method set_preview_text + (of-object "GtkFontSelection") + (c-name "gtk_font_selection_set_preview_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + ) +) + +(define-function gtk_font_selection_dialog_get_type + (c-name "gtk_font_selection_dialog_get_type") + (return-type "GtkType") +) + +(define-function gtk_font_selection_dialog_new + (c-name "gtk_font_selection_dialog_new") + (is-constructor-of GtkFontSelectionDialog) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "title") + ) +) + +(define-method get_font_name + (of-object "GtkFontSelectionDialog") + (c-name "gtk_font_selection_dialog_get_font_name") + (return-type "gchar*") +) + +; DEPRECATED +(define-method get_font + (of-object "GtkFontSelectionDialog") + (c-name "gtk_font_selection_dialog_get_font") + (return-type "GdkFont*") +) + +(define-method set_font_name + (of-object "GtkFontSelectionDialog") + (c-name "gtk_font_selection_dialog_set_font_name") + (return-type "gboolean") + (parameters + '("const-gchar*" "fontname") + ) +) + +(define-method get_preview_text + (of-object "GtkFontSelectionDialog") + (c-name "gtk_font_selection_dialog_get_preview_text") + (return-type "gchar*") +) + +(define-method set_preview_text + (of-object "GtkFontSelectionDialog") + (c-name "gtk_font_selection_dialog_set_preview_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkframe.h + +(define-function gtk_frame_get_type + (c-name "gtk_frame_get_type") + (return-type "GtkType") +) + +(define-function gtk_frame_new + (c-name "gtk_frame_new") + (is-constructor-of GtkFrame) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label" (null-ok) (default "NULL")) + ) +) + +(define-method set_label + (of-object "GtkFrame") + (c-name "gtk_frame_set_label") + (return-type "none") + (parameters + '("const-gchar*" "label" (null-ok)) + ) +) + +(define-method get_label + (of-object "GtkFrame") + (c-name "gtk_frame_get_label") + (return-type "none") +) + +(define-method set_label_widget + (of-object "GtkFrame") + (c-name "gtk_frame_set_label_widget") + (return-type "none") + (parameters + '("GtkWidget*" "label_widget") + ) +) + +(define-method get_label_widget + (of-object "GtkFrame") + (c-name "gtk_frame_get_label_widget") + (return-type "GtkWidget*") +) + +(define-method set_label_align + (of-object "GtkFrame") + (c-name "gtk_frame_set_label_align") + (return-type "none") + (parameters + '("gfloat" "xalign") + '("gfloat" "yalign") + ) +) + +(define-method get_label_align + (of-object "GtkFrame") + (c-name "gtk_frame_get_label_align") + (return-type "none") + (parameters + '("gfloat*" "xalign") + '("gfloat*" "yalign") + ) +) + +(define-method set_shadow_type + (of-object "GtkFrame") + (c-name "gtk_frame_set_shadow_type") + (return-type "none") + (parameters + '("GtkShadowType" "type") + ) +) + +(define-method get_shadow_type + (of-object "GtkFrame") + (c-name "gtk_frame_get_shadow_type") + (return-type "GtkShadowType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkgamma.h + +(define-function gtk_gamma_curve_get_type + (c-name "gtk_gamma_curve_get_type") + (return-type "GtkType") +) + +(define-function gtk_gamma_curve_new + (c-name "gtk_gamma_curve_new") + (is-constructor-of GtkGammaCurve) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkgc.h + +(define-function gc_get + (c-name "gtk_gc_get") + (return-type "GdkGC*") + (parameters + '("gint" "depth") + '("GdkColormap*" "colormap") + '("GdkGCValues*" "values") + '("GdkValuesMask" "values_mask") + ) +) + +(define-function gc_release + (c-name "gtk_gc_release") + (return-type "none") + (parameters + '("GdkGC*" "gc") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhandlebox.h + +(define-function gtk_handle_box_get_type + (c-name "gtk_handle_box_get_type") + (return-type "GtkType") +) + +(define-function gtk_handle_box_new + (c-name "gtk_handle_box_new") + (is-constructor-of GtkHandleBox) + (return-type "GtkWidget*") +) + +(define-method set_shadow_type + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_set_shadow_type") + (return-type "none") + (parameters + '("GtkShadowType" "type") + ) +) + +(define-method get_shadow_type + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_get_shadow_type") + (return-type "GtkShadowType") +) + +(define-method set_handle_position + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_set_handle_position") + (return-type "none") + (parameters + '("GtkPositionType" "position") + ) +) + +(define-method get_handle_position + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_get_handle_position") + (return-type "GtkPositionType") +) + +(define-method set_snap_edge + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_set_snap_edge") + (return-type "none") + (parameters + '("GtkPositionType" "edge") + ) +) + +(define-method get_snap_edge + (of-object "GtkHandleBox") + (c-name "gtk_handle_box_get_snap_edge") + (return-type "GtkPositionType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhbbox.h + +(define-function gtk_hbutton_box_get_type + (c-name "gtk_hbutton_box_get_type") + (return-type "GtkType") +) + +(define-function gtk_hbutton_box_new + (c-name "gtk_hbutton_box_new") + (is-constructor-of GtkHButtonBox) + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhbox.h + +(define-function gtk_hbox_get_type + (c-name "gtk_hbox_get_type") + (return-type "GtkType") +) + +(define-function gtk_hbox_new + (c-name "gtk_hbox_new") + (is-constructor-of GtkHBox) + (return-type "GtkWidget*") + (parameters + '("gboolean" "homogeneous" (default "FALSE")) + '("gint" "spacing" (default "0")) + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhpaned.h + +(define-function gtk_hpaned_get_type + (c-name "gtk_hpaned_get_type") + (return-type "GtkType") +) + +(define-function gtk_hpaned_new + (c-name "gtk_hpaned_new") + (is-constructor-of GtkHPaned) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhruler.h + +(define-function gtk_hruler_get_type + (c-name "gtk_hruler_get_type") + (return-type "GtkType") +) + +(define-function gtk_hruler_new + (c-name "gtk_hruler_new") + (is-constructor-of GtkHRuler) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhscale.h + +(define-function gtk_hscale_get_type + (c-name "gtk_hscale_get_type") + (return-type "GtkType") +) + +(define-function gtk_hscale_new + (c-name "gtk_hscale_new") + (is-constructor-of GtkHScale) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + ) +) + +(define-function gtk_hscale_new_with_range + (c-name "gtk_hscale_new_with_range") + (is-constructor-of GtkHScale) + (return-type "GtkWidget*") + (parameters + '("gdouble" "min") + '("gdouble" "max") + '("gdouble" "step") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhscrollbar.h + +(define-function gtk_hscrollbar_get_type + (c-name "gtk_hscrollbar_get_type") + (return-type "GtkType") +) + +(define-function gtk_hscrollbar_new + (c-name "gtk_hscrollbar_new") + (is-constructor-of GtkHScrollbar) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkhseparator.h + +(define-function gtk_hseparator_get_type + (c-name "gtk_hseparator_get_type") + (return-type "GtkType") +) + +(define-function gtk_hseparator_new + (c-name "gtk_hseparator_new") + (is-constructor-of GtkHSeparator) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkiconfactory.h + +(define-function gtk_icon_factory_get_type + (c-name "gtk_icon_factory_get_type") + (return-type "GType") +) + +(define-function gtk_icon_factory_new + (c-name "gtk_icon_factory_new") + (is-constructor-of GtkIconFactory) + (return-type "GtkIconFactory*") +) + +(define-method add + (of-object "GtkIconFactory") + (c-name "gtk_icon_factory_add") + (return-type "none") + (parameters + '("const-gchar*" "stock_id") + '("GtkIconSet*" "icon_set") + ) +) + +(define-method lookup + (of-object "GtkIconFactory") + (c-name "gtk_icon_factory_lookup") + (return-type "GtkIconSet*") + (parameters + '("const-gchar*" "stock_id") + ) +) + +(define-method add_default + (of-object "GtkIconFactory") + (c-name "gtk_icon_factory_add_default") + (return-type "none") +) + +(define-method remove_default + (of-object "GtkIconFactory") + (c-name "gtk_icon_factory_remove_default") + (return-type "none") +) + +(define-function icon_factory_lookup_default + (c-name "gtk_icon_factory_lookup_default") + (return-type "GtkIconSet*") + (parameters + '("const-gchar*" "stock_id") + ) +) + +(define-function icon_size_lookup + (c-name "gtk_icon_size_lookup") + (return-type "gboolean") + (parameters + '("GtkIconSize" "size") + '("gint*" "width") + '("gint*" "height") + ) +) + +(define-function icon_size_register + (c-name "gtk_icon_size_register") + (return-type "GtkIconSize") + (parameters + '("const-gchar*" "alias") + '("gint" "width") + '("gint" "height") + ) +) + +(define-function icon_size_register_alias + (c-name "gtk_icon_size_register_alias") + (return-type "none") + (parameters + '("const-gchar*" "alias") + '("GtkIconSize" "target") + ) +) + +(define-function icon_size_from_name + (c-name "gtk_icon_size_from_name") + (return-type "GtkIconSize") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function icon_size_get_name + (c-name "gtk_icon_size_get_name") + (return-type "const-gchar*") + (parameters + '("GtkIconSize" "size") + ) +) + +(define-function icon_set_new + (c-name "gtk_icon_set_new") + (return-type "GtkIconSet*") +) + +(define-function icon_set_new_from_pixbuf + (c-name "gtk_icon_set_new_from_pixbuf") + (return-type "GtkIconSet*") + (parameters + '("GdkPixbuf*" "pixbuf") + ) +) + +(define-method ref + (of-object "GtkIconSet") + (c-name "gtk_icon_set_ref") + (return-type "GtkIconSet*") +) + +(define-method unref + (of-object "GtkIconSet") + (c-name "gtk_icon_set_unref") + (return-type "none") +) + +(define-method copy + (of-object "GtkIconSet") + (c-name "gtk_icon_set_copy") + (return-type "GtkIconSet*") +) + +(define-method render_icon + (of-object "GtkIconSet") + (c-name "gtk_icon_set_render_icon") + (return-type "GdkPixbuf*") + (parameters + '("GtkStyle*" "style") + '("GtkTextDirection" "direction") + '("GtkStateType" "state") + '("const-gchar*" "size") + '("GtkWidget*" "widget") + '("const-char*" "detail") + ) +) + +(define-method add_source + (of-object "GtkIconSet") + (c-name "gtk_icon_set_add_source") + (return-type "none") + (parameters + '("const-GtkIconSource*" "source") + ) +) + +(define-method get_sizes + (of-object "GtkIconSet") + (c-name "gtk_icon_set_get_sizes") + (return-type "none") + (parameters + '("GtkIconSize**" "sizes") + '("gint*" "n_sizes") + ) +) + +(define-function icon_source_new + (c-name "gtk_icon_source_new") + (return-type "GtkIconSource*") +) + +(define-method copy + (of-object "GtkIconSource") + (c-name "gtk_icon_source_copy") + (return-type "GtkIconSource*") +) + +(define-method free + (of-object "GtkIconSource") + (c-name "gtk_icon_source_free") + (return-type "none") +) + +(define-method set_filename + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_filename") + (return-type "none") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-method set_pixbuf + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_pixbuf") + (return-type "none") + (parameters + '("GdkPixbuf*" "pixbuf") + ) +) + +(define-method get_filename + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_filename") + (return-type "const-gchar*") +) + +(define-method get_pixbuf + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_pixbuf") + (return-type "GdkPixbuf*") +) + +(define-method set_direction_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_direction_wildcarded") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method set_state_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_state_wildcarded") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method set_size_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_size_wildcarded") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_size_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_size_wildcarded") + (return-type "gboolean") +) + +(define-method get_state_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_state_wildcarded") + (return-type "gboolean") +) + +(define-method get_direction_wildcarded + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_direction_wildcarded") + (return-type "gboolean") +) + +(define-method set_direction + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_direction") + (return-type "none") + (parameters + '("GtkTextDirection" "direction") + ) +) + +(define-method set_state + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_state") + (return-type "none") + (parameters + '("GtkStateType" "state") + ) +) + +(define-method set_size + (of-object "GtkIconSource") + (c-name "gtk_icon_source_set_size") + (return-type "none") + (parameters + '("GtkIconSize" "size") + ) +) + +(define-method get_direction + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_direction") + (return-type "GtkTextDirection") +) + +(define-method get_state + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_state") + (return-type "GtkStateType") +) + +(define-method get_size + (of-object "GtkIconSource") + (c-name "gtk_icon_source_get_size") + (return-type "GtkIconSize") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkimage.h + +(define-function gtk_image_get_type + (c-name "gtk_image_get_type") + (return-type "GtkType") +) + +(define-function gtk_image_new + (c-name "gtk_image_new") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") +) + +(define-function gtk_image_new_from_pixmap + (c-name "gtk_image_new_from_pixmap") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask") + ) +) + +(define-function gtk_image_new_from_image + (c-name "gtk_image_new_from_image") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("GdkImage*" "image") + '("GdkBitmap*" "mask") + ) +) + +(define-function gtk_image_new_from_file + (c-name "gtk_image_new_from_file") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function gtk_image_new_from_pixbuf + (c-name "gtk_image_new_from_pixbuf") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("GdkPixbuf*" "pixbuf") + ) +) + +(define-function gtk_image_new_from_stock + (c-name "gtk_image_new_from_stock") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "stock_id") + '("const-gchar*" "size") + ) +) + +(define-function gtk_image_new_from_icon_set + (c-name "gtk_image_new_from_icon_set") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("GtkIconSet*" "icon_set") + '("const-gchar*" "size") + ) +) + +(define-function gtk_image_new_from_animation + (c-name "gtk_image_new_from_animation") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") + (parameters + '("GdkPixbufAnimation*" "animation") + ) +) + +(define-function construct + (c-name "gtk_image_new") + (is-constructor-of GtkImage) + (return-type "GtkWidget*") +) + +(define-method set_from_pixmap + (of-object "GtkImage") + (c-name "gtk_image_set_from_pixmap") + (return-type "none") + (parameters + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask") + ) +) + +(define-method set_from_image + (of-object "GtkImage") + (c-name "gtk_image_set_from_image") + (return-type "none") + (parameters + '("GdkImage*" "gdk_image") + '("GdkBitmap*" "mask") + ) +) + +(define-method set_from_file + (of-object "GtkImage") + (c-name "gtk_image_set_from_file") + (return-type "none") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-method set_from_pixbuf + (of-object "GtkImage") + (c-name "gtk_image_set_from_pixbuf") + (return-type "none") + (parameters + '("GdkPixbuf*" "pixbuf") + ) +) + +(define-method set_from_stock + (of-object "GtkImage") + (c-name "gtk_image_set_from_stock") + (return-type "none") + (parameters + '("const-gchar*" "stock_id") + '("GtkIconSize" "size") + ) +) + +(define-method set_from_icon_set + (of-object "GtkImage") + (c-name "gtk_image_set_from_icon_set") + (return-type "none") + (parameters + '("GtkIconSet*" "icon_set") + '("const-gchar*" "size") + ) +) + +(define-method set_from_animation + (of-object "GtkImage") + (c-name "gtk_image_set_from_animation") + (return-type "none") + (parameters + '("GdkPixbufAnimation*" "animation") + ) +) + +(define-method get_storage_type + (of-object "GtkImage") + (c-name "gtk_image_get_storage_type") + (return-type "GtkImageType") +) + +(define-method get_pixmap + (of-object "GtkImage") + (c-name "gtk_image_get_pixmap") + (return-type "none") + (parameters + '("GdkPixmap**" "pixmap") + '("GdkBitmap**" "mask") + ) +) + +(define-method get_image + (of-object "GtkImage") + (c-name "gtk_image_get_image") + (return-type "none") + (parameters + '("GdkImage**" "gdk_image") + '("GdkBitmap**" "mask") + ) +) + +(define-method get_pixbuf + (of-object "GtkImage") + (c-name "gtk_image_get_pixbuf") + (return-type "GdkPixbuf*") +) + +(define-method get_stock + (of-object "GtkImage") + (c-name "gtk_image_get_stock") + (return-type "none") + (parameters + '("gchar**" "stock_id") + '("gchar**" "size") + ) +) + +(define-method get_icon_set + (of-object "GtkImage") + (c-name "gtk_image_get_icon_set") + (return-type "none") + (parameters + '("GtkIconSet**" "icon_set") + '("gchar**" "size") + ) +) + +(define-method get_animation + (of-object "GtkImage") + (c-name "gtk_image_get_animation") + (return-type "GdkPixbufAnimation*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkimagemenuitem.h + +(define-function gtk_image_menu_item_get_type + (c-name "gtk_image_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_image_menu_item_new + (c-name "gtk_image_menu_item_new") + (is-constructor-of GtkImageMenuItem) + (return-type "GtkWidget*") +) + +(define-function gtk_image_menu_item_new_with_label + (c-name "gtk_image_menu_item_new_with_label") + (is-constructor-of GtkImageMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_image_menu_item_new_with_mnemonic + (c-name "gtk_image_menu_item_new_with_mnemonic") + (is-constructor-of GtkImageMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_image_menu_item_new_from_stock + (c-name "gtk_image_menu_item_new_from_stock") + (is-constructor-of GtkImageMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "stock_id") + '("GtkAccelGroup*" "accel_group") + ) +) + +(define-method set_image + (of-object "GtkImageMenuItem") + (c-name "gtk_image_menu_item_set_image") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method get_image + (of-object "GtkImageMenuItem") + (c-name "gtk_image_menu_item_get_image") + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkimcontext.h + +(define-function gtk_im_context_get_type + (c-name "gtk_im_context_get_type") + (return-type "GtkType") +) + +(define-method set_client_window + (of-object "GtkIMContext") + (c-name "gtk_im_context_set_client_window") + (return-type "none") + (parameters + '("GdkWindow*" "window") + ) +) + +(define-method get_preedit_string + (of-object "GtkIMContext") + (c-name "gtk_im_context_get_preedit_string") + (return-type "none") + (parameters + '("char**" "str") + '("PangoAttrList**" "attrs") + ) +) + +(define-method filter_keypress + (of-object "GtkIMContext") + (c-name "gtk_im_context_filter_keypress") + (return-type "gboolean") + (parameters + '("GdkEventKey*" "event") + ) +) + +(define-method focus_in + (of-object "GtkIMContext") + (c-name "gtk_im_context_focus_in") + (return-type "none") +) + +(define-method focus_out + (of-object "GtkIMContext") + (c-name "gtk_im_context_focus_out") + (return-type "none") +) + +(define-method reset + (of-object "GtkIMContext") + (c-name "gtk_im_context_reset") + (return-type "none") +) + +(define-method set_cursor_location + (of-object "GtkIMContext") + (c-name "gtk_im_context_set_cursor_location") + (return-type "none") + (parameters + '("GdkRectangle*" "area") + ) +) + +(define-method set_use_preedit + (of-object "GtkIMContext") + (c-name "gtk_im_context_set_use_preedit") + (return-type "none") + (parameters + '("gboolean" "use_preedit") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkimmulticontext.h + +(define-function gtk_im_multicontext_get_type + (c-name "gtk_im_multicontext_get_type") + (return-type "GtkType") +) + +(define-function gtk_im_multicontext_new + (c-name "gtk_im_multicontext_new") + (is-constructor-of GtkIMMulticontext) + (return-type "GtkIMContext*") +) + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkinputdialog.h + +(define-function gtk_input_dialog_get_type + (c-name "gtk_input_dialog_get_type") + (return-type "GtkType") +) + +(define-function gtk_input_dialog_new + (c-name "gtk_input_dialog_new") + (is-constructor-of GtkInputDialog) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkinvisible.h + +(define-function gtk_invisible_get_type + (c-name "gtk_invisible_get_type") + (return-type "GtkType") +) + +(define-function gtk_invisible_new + (c-name "gtk_invisible_new") + (is-constructor-of GtkInvisible) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkitem.h + +(define-function gtk_item_get_type + (c-name "gtk_item_get_type") + (return-type "GtkType") +) + +(define-method select + (of-object "GtkItem") + (c-name "gtk_item_select") + (return-type "none") +) + +(define-method deselect + (of-object "GtkItem") + (c-name "gtk_item_deselect") + (return-type "none") +) + +(define-method toggle + (of-object "GtkItem") + (c-name "gtk_item_toggle") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkitemfactory.h + +(define-function gtk_item_factory_get_type + (c-name "gtk_item_factory_get_type") + (return-type "GtkType") +) + +(define-function gtk_item_factory_new + (c-name "gtk_item_factory_new") + (is-constructor-of GtkItemFactory) + (return-type "GtkItemFactory*") + (parameters + '("GtkType" "container_type") + '("const-gchar*" "path") + '("GtkAccelGroup*" "accel_group" (null-ok) (default "NULL")) + ) +) + +(define-method construct + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_construct") + (return-type "none") + (parameters + '("GtkType" "container_type") + '("const-gchar*" "path") + '("GtkAccelGroup*" "accel_group") + ) +) + +(define-function item_factory_parse_rc + (c-name "gtk_item_factory_parse_rc") + (return-type "none") + (parameters + '("const-gchar*" "file_name") + ) +) + +(define-function item_factory_parse_rc_string + (c-name "gtk_item_factory_parse_rc_string") + (return-type "none") + (parameters + '("const-gchar*" "rc_string") + ) +) + +(define-function item_factory_parse_rc_scanner + (c-name "gtk_item_factory_parse_rc_scanner") + (return-type "none") + (parameters + '("GScanner*" "scanner") + ) +) + +(define-function item_factory_add_foreign + (c-name "gtk_item_factory_add_foreign") + (return-type "none") + (parameters + '("GtkWidget*" "accel_widget") + '("const-gchar*" "full_path") + '("GtkAccelGroup*" "accel_group") + '("guint" "keyval") + '("GdkModifierType" "modifiers") + ) +) + +(define-function item_factory_from_widget + (c-name "gtk_item_factory_from_widget") + (return-type "GtkItemFactory*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-function item_factory_path_from_widget + (c-name "gtk_item_factory_path_from_widget") + (return-type "gchar*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method get_item + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_get_item") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_widget + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_get_widget") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_widget_by_action + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_get_widget_by_action") + (return-type "GtkWidget*") + (parameters + '("guint" "action") + ) +) + +(define-method get_item_by_action + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_get_item_by_action") + (return-type "GtkWidget*") + (parameters + '("guint" "action") + ) +) + +(define-function item_factory_dump_items + (c-name "gtk_item_factory_dump_items") + (return-type "none") + (parameters + '("GtkPatternSpec*" "path_pspec") + '("gboolean" "modified_only") + '("GtkPrintFunc" "print_func") + '("gpointer" "func_data") + ) +) + +(define-function item_factory_dump_rc + (c-name "gtk_item_factory_dump_rc") + (return-type "none") + (parameters + '("const-gchar*" "file_name") + '("GtkPatternSpec*" "path_pspec") + '("gboolean" "modified_only") + ) +) + +(define-function item_factory_print_func + (c-name "gtk_item_factory_print_func") + (return-type "none") + (parameters + '("gpointer" "FILE_pointer") + '("const-gchar*" "string") + ) +) + +(define-method create_item + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_create_item") + (return-type "none") + (parameters + '("GtkItemFactoryEntry*" "entry") + '("gpointer" "callback_data") + '("guint" "callback_type") + ) +) + +(define-method create_items + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_create_items") + (return-type "none") + (parameters + '("guint" "n_entries") + '("GtkItemFactoryEntry*" "entries") + '("gpointer" "callback_data") + ) +) + +(define-method delete_item + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_delete_item") + (return-type "none") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method delete_entry + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_delete_entry") + (return-type "none") + (parameters + '("GtkItemFactoryEntry*" "entry") + ) +) + +(define-method delete_entries + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_delete_entries") + (return-type "none") + (parameters + '("guint" "n_entries") + '("GtkItemFactoryEntry*" "entries") + ) +) + +(define-method popup + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_popup") + (return-type "none") + (parameters + '("guint" "x") + '("guint" "y") + '("guint" "mouse_button") + '("guint32" "time" (default "GDK_CURRENT_TIME")) + ) +) + +(define-method popup_with_data + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_popup_with_data") + (return-type "none") + (parameters + '("gpointer" "popup_data") + '("GtkDestroyNotify" "destroy") + '("guint" "x") + '("guint" "y") + '("guint" "mouse_button") + '("guint32" "time" (default "GDK_CURRENT_TIME")) + ) +) + +(define-method popup_data + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_popup_data") + (return-type "gpointer") +) + +(define-function item_factory_popup_data_from_widget + (c-name "gtk_item_factory_popup_data_from_widget") + (return-type "gpointer") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method set_translate_func + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_set_translate_func") + (return-type "none") + (parameters + '("GtkTranslateFunc" "func") + '("gpointer" "data") + '("GtkDestroyNotify" "notify") + ) +) + +(define-function item_factory_from_path + (c-name "gtk_item_factory_from_path") + (return-type "GtkItemFactory*") + (parameters + '("const-gchar*" "path") + ) +) + +(define-function item_factory_create_menu_entries + (c-name "gtk_item_factory_create_menu_entries") + (return-type "none") + (parameters + '("guint" "n_entries") + '("GtkMenuEntry*" "entries") + ) +) + +(define-function item_factories_path_delete + (c-name "gtk_item_factories_path_delete") + (return-type "none") + (parameters + '("const-gchar*" "ifactory_path") + '("const-gchar*" "path") + ) +) + +(define-method create_items_ac + (of-object "GtkItemFactory") + (c-name "gtk_item_factory_create_items_ac") + (return-type "none") + (parameters + '("guint" "n_entries") + '("GtkItemFactoryEntry*" "entries") + '("gpointer" "callback_data") + '("guint" "callback_type") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtklabel.h + +(define-function gtk_label_get_type + (c-name "gtk_label_get_type") + (return-type "GtkType") +) + +(define-function gtk_label_new + (c-name "gtk_label_new") + (is-constructor-of GtkLabel) + (return-type "GtkWidget*") + (parameters + '("const-char*" "str") + ) +) + +(define-function gtk_label_new_with_mnemonic + (c-name "gtk_label_new_with_mnemonic") + (is-constructor-of GtkLabel) + (return-type "GtkWidget*") + (parameters + '("const-char*" "str") + ) +) + +(define-method set_text + (of-object "GtkLabel") + (c-name "gtk_label_set_text") + (return-type "none") + (parameters + '("const-char*" "str") + ) +) + +(define-method get_text + (of-object "GtkLabel") + (c-name "gtk_label_get_text") + (return-type "const-gchar*") +) + +(define-method set_attributes + (of-object "GtkLabel") + (c-name "gtk_label_set_attributes") + (return-type "none") + (parameters + '("PangoAttrList*" "attrs") + ) +) + +(define-method get_attributes + (of-object "GtkLabel") + (c-name "gtk_label_get_attributes") + (return-type "PangoAttrList*") +) + +(define-method set_label + (of-object "GtkLabel") + (c-name "gtk_label_set_label") + (return-type "none") + (parameters + '("const-char*" "label") + ) +) + +(define-method get_label + (of-object "GtkLabel") + (c-name "gtk_label_get_label") + (return-type "const-gchar*") +) + +(define-method set_markup + (of-object "GtkLabel") + (c-name "gtk_label_set_markup") + (return-type "none") + (parameters + '("const-gchar*" "str") + ) +) + +(define-method set_use_markup + (of-object "GtkLabel") + (c-name "gtk_label_set_use_markup") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_use_markup + (of-object "GtkLabel") + (c-name "gtk_label_get_use_markup") + (return-type "gboolean") +) + +(define-method set_use_underline + (of-object "GtkLabel") + (c-name "gtk_label_set_use_underline") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_use_underline + (of-object "GtkLabel") + (c-name "gtk_label_get_use_underline") + (return-type "gboolean") +) + +(define-method set_markup_with_mnemonic + (of-object "GtkLabel") + (c-name "gtk_label_set_markup_with_mnemonic") + (return-type "none") + (parameters + '("const-gchar*" "str") + ) +) + +(define-method get_mnemonic_keyval + (of-object "GtkLabel") + (c-name "gtk_label_get_mnemonic_keyval") + (return-type "guint") +) + +(define-method set_mnemonic_widget + (of-object "GtkLabel") + (c-name "gtk_label_set_mnemonic_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method set_text_with_mnemonic + (of-object "GtkLabel") + (c-name "gtk_label_set_text_with_mnemonic") + (return-type "none") + (parameters + '("const-gchar*" "str") + ) +) + +(define-method set_justify + (of-object "GtkLabel") + (c-name "gtk_label_set_justify") + (return-type "none") + (parameters + '("GtkJustification" "jtype") + ) +) + +(define-method get_justify + (of-object "GtkLabel") + (c-name "gtk_label_get_justify") + (return-type "GtkJustification") +) + +(define-method set_pattern + (of-object "GtkLabel") + (c-name "gtk_label_set_pattern") + (return-type "none") + (parameters + '("const-gchar*" "pattern") + ) +) + +(define-method set_line_wrap + (of-object "GtkLabel") + (c-name "gtk_label_set_line_wrap") + (return-type "none") + (parameters + '("gboolean" "wrap") + ) +) + +(define-method set_selectable + (of-object "GtkLabel") + (c-name "gtk_label_set_selectable") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_selectable + (of-object "GtkLabel") + (c-name "gtk_label_get_selectable") + (return-type "gboolean") +) + +(define-method select_region + (of-object "GtkLabel") + (c-name "gtk_label_select_region") + (return-type "none") + (parameters + '("gint" "start_offset") + '("gint" "end_offset") + ) +) + +(define-method get_selection_bounds + (of-object "GtkLabel") + (c-name "gtk_label_get_selection_bounds") + (return-type "gboolean") + (parameters + '("gint*" "start") + '("gint*" "end") + ) +) + +(define-method get_layout + (of-object "GtkLabel") + (c-name "gtk_label_get_layout") + (return-type "PangoLayout*") +) + +(define-method get_layout_offsets + (of-object "GtkLabel") + (c-name "gtk_label_get_layout_offsets") + (return-type "none") + (parameters + '("gint*" "x") + '("gint*" "y") + ) +) + +; DEPRECATED +(define-method get + (of-object "GtkLabel") + (c-name "gtk_label_get") + (return-type "none") + (parameters + '("char**" "str") + ) +) + +; DEPRECATED +(define-method parse_uline + (of-object "GtkLabel") + (c-name "gtk_label_parse_uline") + (return-type "guint") + (parameters + '("const-gchar*" "string") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtklayout.h + +(define-function gtk_layout_get_type + (c-name "gtk_layout_get_type") + (return-type "GtkType") +) + +(define-function gtk_layout_new + (c-name "gtk_layout_new") + (is-constructor-of GtkLayout) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "hadjustment" (null-ok) (default "NULL")) + '("GtkAdjustment*" "vadjustment" (null-ok) (default "NULL")) + ) +) + +(define-method put + (of-object "GtkLayout") + (c-name "gtk_layout_put") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("gint" "x") + '("gint" "y") + ) +) + +(define-method move + (of-object "GtkLayout") + (c-name "gtk_layout_move") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("gint" "x") + '("gint" "y") + ) +) + +(define-method set_size + (of-object "GtkLayout") + (c-name "gtk_layout_set_size") + (return-type "none") + (parameters + '("guint" "width") + '("guint" "height") + ) +) + +(define-method get_hadjustment + (of-object "GtkLayout") + (c-name "gtk_layout_get_hadjustment") + (return-type "GtkAdjustment*") +) + +(define-method get_vadjustment + (of-object "GtkLayout") + (c-name "gtk_layout_get_vadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_hadjustment + (of-object "GtkLayout") + (c-name "gtk_layout_set_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok)) + ) +) + +(define-method set_vadjustment + (of-object "GtkLayout") + (c-name "gtk_layout_set_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok)) + ) +) + +; DEPRECATED +(define-method freeze + (of-object "GtkLayout") + (c-name "gtk_layout_freeze") + (return-type "none") +) + +; DEPRECATED +(define-method thaw + (of-object "GtkLayout") + (c-name "gtk_layout_thaw") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtklist.h + +(define-function gtk_list_get_type + (c-name "gtk_list_get_type") + (return-type "GtkType") +) + +(define-function gtk_list_new + (c-name "gtk_list_new") + (is-constructor-of GtkList) + (return-type "GtkWidget*") +) + +(define-method insert_items + (of-object "GtkList") + (c-name "gtk_list_insert_items") + (return-type "none") + (parameters + '("GList*" "items") + '("gint" "position") + ) +) + +(define-method append_items + (of-object "GtkList") + (c-name "gtk_list_append_items") + (return-type "none") + (parameters + '("GList*" "items") + ) +) + +(define-method prepend_items + (of-object "GtkList") + (c-name "gtk_list_prepend_items") + (return-type "none") + (parameters + '("GList*" "items") + ) +) + +(define-method remove_items + (of-object "GtkList") + (c-name "gtk_list_remove_items") + (return-type "none") + (parameters + '("GList*" "items") + ) +) + +(define-method remove_items_no_unref + (of-object "GtkList") + (c-name "gtk_list_remove_items_no_unref") + (return-type "none") + (parameters + '("GList*" "items") + ) +) + +(define-method clear_items + (of-object "GtkList") + (c-name "gtk_list_clear_items") + (return-type "none") + (parameters + '("gint" "start") + '("gint" "end") + ) +) + +(define-method select_item + (of-object "GtkList") + (c-name "gtk_list_select_item") + (return-type "none") + (parameters + '("gint" "item") + ) +) + +(define-method unselect_item + (of-object "GtkList") + (c-name "gtk_list_unselect_item") + (return-type "none") + (parameters + '("gint" "item") + ) +) + +(define-method select_child + (of-object "GtkList") + (c-name "gtk_list_select_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method unselect_child + (of-object "GtkList") + (c-name "gtk_list_unselect_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method child_position + (of-object "GtkList") + (c-name "gtk_list_child_position") + (return-type "gint") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method set_selection_mode + (of-object "GtkList") + (c-name "gtk_list_set_selection_mode") + (return-type "none") + (parameters + '("GtkSelectionMode" "mode") + ) +) + +(define-method extend_selection + (of-object "GtkList") + (c-name "gtk_list_extend_selection") + (return-type "none") + (parameters + '("GtkScrollType" "scroll_type") + '("gfloat" "position") + '("gboolean" "auto_start_selection") + ) +) + +(define-method start_selection + (of-object "GtkList") + (c-name "gtk_list_start_selection") + (return-type "none") +) + +(define-method end_selection + (of-object "GtkList") + (c-name "gtk_list_end_selection") + (return-type "none") +) + +(define-method select_all + (of-object "GtkList") + (c-name "gtk_list_select_all") + (return-type "none") +) + +(define-method unselect_all + (of-object "GtkList") + (c-name "gtk_list_unselect_all") + (return-type "none") +) + +(define-method scroll_horizontal + (of-object "GtkList") + (c-name "gtk_list_scroll_horizontal") + (return-type "none") + (parameters + '("GtkScrollType" "scroll_type") + '("gfloat" "position") + ) +) + +(define-method scroll_vertical + (of-object "GtkList") + (c-name "gtk_list_scroll_vertical") + (return-type "none") + (parameters + '("GtkScrollType" "scroll_type") + '("gfloat" "position") + ) +) + +(define-method toggle_add_mode + (of-object "GtkList") + (c-name "gtk_list_toggle_add_mode") + (return-type "none") +) + +(define-method toggle_focus_row + (of-object "GtkList") + (c-name "gtk_list_toggle_focus_row") + (return-type "none") +) + +(define-method toggle_row + (of-object "GtkList") + (c-name "gtk_list_toggle_row") + (return-type "none") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method undo_selection + (of-object "GtkList") + (c-name "gtk_list_undo_selection") + (return-type "none") +) + +(define-method end_drag_selection + (of-object "GtkList") + (c-name "gtk_list_end_drag_selection") + (return-type "none") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtklistitem.h + +(define-function gtk_list_item_get_type + (c-name "gtk_list_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_list_item_new + (c-name "gtk_list_item_new") + (is-constructor-of GtkListItem) + (return-type "GtkWidget*") +) + +(define-function gtk_list_item_new_with_label + (c-name "gtk_list_item_new_with_label") + (is-constructor-of GtkListItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method select + (of-object "GtkListItem") + (c-name "gtk_list_item_select") + (return-type "none") +) + +(define-method deselect + (of-object "GtkListItem") + (c-name "gtk_list_item_deselect") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkliststore.h + +(define-function gtk_list_store_get_type + (c-name "gtk_list_store_get_type") + (return-type "GtkType") +) + +(define-function gtk_list_store_new + (c-name "gtk_list_store_new") + (is-constructor-of GtkListStore) + (return-type "GtkListStore*") + (parameters + '("gint" "n_columns") + ) + (varargs #t) +) + +(define-function gtk_list_store_newv + (c-name "gtk_list_store_newv") + (is-constructor-of GtkListStore) + (return-type "GtkListStore*") + (parameters + '("gint" "n_columns") + '("GType*" "value") + ) +) + +(define-method set_value + (of-object "GtkListStore") + (c-name "gtk_list_store_set_value") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("gint" "column") + '("GValue*" "value") + ) +) + +(define-method set + (of-object "GtkListStore") + (c-name "gtk_list_store_set") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) + (varargs #t) +) + +(define-method remove + (of-object "GtkListStore") + (c-name "gtk_list_store_remove") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method insert + (of-object "GtkListStore") + (c-name "gtk_list_store_insert") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("gint" "position") + ) +) + +(define-method insert_before + (of-object "GtkListStore") + (c-name "gtk_list_store_insert_before") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "sibling") + ) +) + +(define-method insert_after + (of-object "GtkListStore") + (c-name "gtk_list_store_insert_after") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "sibling") + ) +) + +(define-method prepend + (of-object "GtkListStore") + (c-name "gtk_list_store_prepend") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method append + (of-object "GtkListStore") + (c-name "gtk_list_store_append") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method clear + (of-object "GtkListStore") + (c-name "gtk_list_store_clear") + (return-type "none") +) + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmain.h + + +(define-function check_version + (c-name "gtk_check_version") + (return-type "gchar*") + (parameters + '("guint" "required_major") + '("guint" "required_minor") + '("guint" "required_micro") + ) +) + +(define-function init + (c-name "gtk_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char***" "argv") + ) +) + +(define-function init_check + (c-name "gtk_init_check") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char***" "argv") + ) +) + +(define-function set_locale + (c-name "gtk_set_locale") + (return-type "gchar*") +) + +(define-function get_default_language + (c-name "gtk_get_default_language") + (return-type "PangoLanguage*") +) + +(define-function events_pending + (c-name "gtk_events_pending") + (return-type "gint") +) + +(define-function main_do_event + (c-name "gtk_main_do_event") + (return-type "none") + (parameters + '("GdkEvent*" "event") + ) +) + +(define-function main + (c-name "gtk_main") + (return-type "none") +) + +(define-function main_level + (c-name "gtk_main_level") + (return-type "guint") +) + +(define-function main_quit + (c-name "gtk_main_quit") + (return-type "none") +) + +(define-function main_iteration + (c-name "gtk_main_iteration") + (return-type "gint") +) + +(define-function main_iteration_do + (c-name "gtk_main_iteration_do") + (return-type "gint") + (parameters + '("gboolean" "blocking" (default "TRUE")) + ) +) + +(define-function true + (c-name "gtk_true") + (return-type "gint") +) + +(define-function false + (c-name "gtk_false") + (return-type "gint") +) + +(define-method grab_add + (of-object "GtkWidget") + (c-name "gtk_grab_add") + (return-type "none") +) + +(define-function grab_get_current + (c-name "gtk_grab_get_current") + (return-type "GtkWidget*") +) + +(define-method grab_remove + (of-object "GtkWidget") + (c-name "gtk_grab_remove") + (return-type "none") +) + +(define-function init_add + (c-name "gtk_init_add") + (return-type "none") + (parameters + '("GtkFunction" "function") + '("gpointer" "data") + ) +) + +(define-function quit_add_destroy + (c-name "gtk_quit_add_destroy") + (return-type "none") + (parameters + '("guint" "main_level") + '("GtkObject*" "object") + ) +) + +(define-function quit_add + (c-name "gtk_quit_add") + (return-type "guint") + (parameters + '("guint" "main_level") + '("GtkFunction" "function") + '("gpointer" "data") + ) +) + +(define-function quit_add_full + (c-name "gtk_quit_add_full") + (return-type "guint") + (parameters + '("guint" "main_level") + '("GtkFunction" "function") + '("GtkCallbackMarshal" "marshal") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-function quit_remove + (c-name "gtk_quit_remove") + (return-type "none") + (parameters + '("guint" "quit_handler_id") + ) +) + +(define-function quit_remove_by_data + (c-name "gtk_quit_remove_by_data") + (return-type "none") + (parameters + '("gpointer" "data") + ) +) + +(define-function timeout_add + (c-name "gtk_timeout_add") + (return-type "guint") + (parameters + '("guint32" "interval") + '("GtkFunction" "function") + '("gpointer" "data") + ) +) + +(define-function timeout_add_full + (c-name "gtk_timeout_add_full") + (return-type "guint") + (parameters + '("guint32" "interval") + '("GtkFunction" "function") + '("GtkCallbackMarshal" "marshal") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-function timeout_remove + (c-name "gtk_timeout_remove") + (return-type "none") + (parameters + '("guint" "timeout_handler_id") + ) +) + +(define-function idle_add + (c-name "gtk_idle_add") + (return-type "guint") + (parameters + '("GtkFunction" "function") + '("gpointer" "data") + ) +) + +(define-function idle_add_priority + (c-name "gtk_idle_add_priority") + (return-type "guint") + (parameters + '("gint" "priority") + '("GtkFunction" "function") + '("gpointer" "data") + ) +) + +(define-function idle_add_full + (c-name "gtk_idle_add_full") + (return-type "guint") + (parameters + '("gint" "priority") + '("GtkFunction" "function") + '("GtkCallbackMarshal" "marshal") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-function idle_remove + (c-name "gtk_idle_remove") + (return-type "none") + (parameters + '("guint" "idle_handler_id") + ) +) + +(define-function idle_remove_by_data + (c-name "gtk_idle_remove_by_data") + (return-type "none") + (parameters + '("gpointer" "data") + ) +) + +(define-function input_add_full + (c-name "gtk_input_add_full") + (return-type "guint") + (parameters + '("gint" "source") + '("GdkInputCondition" "condition") + '("GdkInputFunction" "function") + '("GtkCallbackMarshal" "marshal") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-function input_remove + (c-name "gtk_input_remove") + (return-type "none") + (parameters + '("guint" "input_handler_id") + ) +) + +(define-function key_snooper_install + (c-name "gtk_key_snooper_install") + (return-type "guint") + (parameters + '("GtkKeySnoopFunc" "snooper") + '("gpointer" "func_data") + ) +) + +(define-function key_snooper_remove + (c-name "gtk_key_snooper_remove") + (return-type "none") + (parameters + '("guint" "snooper_handler_id") + ) +) + +(define-function get_current_event + (c-name "gtk_get_current_event") + (return-type "GdkEvent*") +) + +(define-function get_current_event_time + (c-name "gtk_get_current_event_time") + (return-type "guint32") +) + +(define-function get_current_event_state + (c-name "gtk_get_current_event_state") + (return-type "gboolean") + (parameters + '("GdkModifierType*", "state") + ) +) + +(define-function get_event_widget + (c-name "gtk_get_event_widget") + (return-type "GtkWidget*") + (parameters + '("GdkEvent*" "event") + ) +) + +(define-method propagate_event + (of-object "GtkWidget") + (c-name "gtk_propagate_event") + (return-type "none") + (parameters + '("GdkEvent*" "event") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmenu.h + +(define-function gtk_menu_get_type + (c-name "gtk_menu_get_type") + (return-type "GtkType") +) + +(define-function gtk_menu_new + (c-name "gtk_menu_new") + (is-constructor-of GtkMenu) + (return-type "GtkWidget*") +) + +(define-method popup + (of-object "GtkMenu") + (c-name "gtk_menu_popup") + (return-type "none") + (parameters + '("GtkWidget*" "parent_menu_shell") + '("GtkWidget*" "parent_menu_item") + '("GtkMenuPositionFunc" "func") + '("gpointer" "data") + '("guint" "button") + '("guint32" "activate_time") + ) +) + +(define-method reposition + (of-object "GtkMenu") + (c-name "gtk_menu_reposition") + (return-type "none") +) + +(define-method popdown + (of-object "GtkMenu") + (c-name "gtk_menu_popdown") + (return-type "none") +) + +(define-method get_active + (of-object "GtkMenu") + (c-name "gtk_menu_get_active") + (return-type "GtkWidget*") +) + +(define-method set_active + (of-object "GtkMenu") + (c-name "gtk_menu_set_active") + (return-type "none") + (parameters + '("guint" "index") + ) +) + +(define-method set_accel_group + (of-object "GtkMenu") + (c-name "gtk_menu_set_accel_group") + (return-type "none") + (parameters + '("GtkAccelGroup*" "accel_group") + ) +) + +(define-method get_accel_group + (of-object "GtkMenu") + (c-name "gtk_menu_get_accel_group") + (return-type "GtkAccelGroup*") +) + +(define-method attach_to_widget + (of-object "GtkMenu") + (c-name "gtk_menu_attach_to_widget") + (return-type "none") + (parameters + '("GtkWidget*" "attach_widget") + '("GtkMenuDetachFunc" "detacher") + ) +) + +(define-method detach + (of-object "GtkMenu") + (c-name "gtk_menu_detach") + (return-type "none") +) + +(define-method get_attach_widget + (of-object "GtkMenu") + (c-name "gtk_menu_get_attach_widget") + (return-type "GtkWidget*") +) + +(define-method set_tearoff_state + (of-object "GtkMenu") + (c-name "gtk_menu_set_tearoff_state") + (return-type "none") + (parameters + '("gboolean" "torn_off") + ) +) + +(define-method get_tearoff_state + (of-object "GtkMenu") + (c-name "gtk_menu_get_tearoff_state") + (return-type "gboolean") +) + +(define-method set_title + (of-object "GtkMenu") + (c-name "gtk_menu_set_title") + (return-type "none") + (parameters + '("const-gchar*" "title") + ) +) + +(define-method get_title + (of-object "GtkMenu") + (c-name "gtk_menu_get_title") + (return-type "const-gchar*") +) + +(define-method reorder_child + (of-object "GtkMenu") + (c-name "gtk_menu_reorder_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "position") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmenubar.h + +(define-function gtk_menu_bar_get_type + (c-name "gtk_menu_bar_get_type") + (return-type "GtkType") +) + +(define-function gtk_menu_bar_new + (c-name "gtk_menu_bar_new") + (is-constructor-of GtkMenuBar) + (return-type "GtkWidget*") +) + +(define-method append + (of-object "GtkMenuBar") + (c-name "gtk_menu_bar_append") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method prepend + (of-object "GtkMenuBar") + (c-name "gtk_menu_bar_prepend") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method insert + (of-object "GtkMenuBar") + (c-name "gtk_menu_bar_insert") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "position") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmenuitem.h + +(define-function gtk_menu_item_get_type + (c-name "gtk_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_menu_item_new + (c-name "gtk_menu_item_new") + (is-constructor-of GtkMenuItem) + (return-type "GtkWidget*") +) + +(define-function gtk_menu_item_new_with_label + (c-name "gtk_menu_item_new_with_label") + (is-constructor-of GtkMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_menu_item_new_with_mnemonic + (c-name "gtk_menu_item_new_with_mnemonic") + (is-constructor-of GtkMenuItem) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method set_submenu + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_set_submenu") + (return-type "none") + (parameters + '("GtkWidget*" "submenu") + ) +) + +(define-method remove_submenu + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_remove_submenu") + (return-type "none") +) + +(define-method select + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_select") + (return-type "none") +) + +(define-method deselect + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_deselect") + (return-type "none") +) + +(define-method activate + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_activate") + (return-type "none") +) + +(define-method toggle_size_request + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_toggle_size_request") + (return-type "none") + (parameters + '("gint*" "requisition") + ) +) + +(define-method toggle_size_allocate + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_toggle_size_allocate") + (return-type "none") + (parameters + '("gint" "allocation") + ) +) + +(define-method right_justify + (of-object "GtkMenuItem") + (c-name "gtk_menu_item_right_justify") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmenushell.h + +(define-function gtk_menu_shell_get_type + (c-name "gtk_menu_shell_get_type") + (return-type "GtkType") +) + +(define-method append + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_append") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method prepend + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_prepend") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method insert + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_insert") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "position") + ) +) + +(define-method deactivate + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_deactivate") + (return-type "none") +) + +(define-method select_item + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_select_item") + (return-type "none") + (parameters + '("GtkWidget*" "menu_item") + ) +) + +(define-method deselect + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_deselect") + (return-type "none") +) + +(define-method activate_item + (of-object "GtkMenuShell") + (c-name "gtk_menu_shell_activate_item") + (return-type "none") + (parameters + '("GtkWidget*" "menu_item") + '("gboolean" "force_deactivate") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmessagedialog.h + +(define-function gtk_message_dialog_get_type + (c-name "gtk_message_dialog_get_type") + (return-type "GtkType") +) + +(define-function gtk_message_dialog_new + (c-name "gtk_message_dialog_new") + (is-constructor-of GtkMessageDialog) + (return-type "GtkWidget*") + (parameters + '("GtkWindow*" "parent" (null-ok) (default "NULL")) + '("GtkDialogFlags" "flags" (default "0")) + '("GtkMessageType" "type" (default "GTK_MESSAGE_INFO")) + '("GtkButtonsType" "buttons" (default "GTK_BUTTONS_NONE")) + '("const-gchar*" "message_format" (null-ok) (default "NULL")) + ) + (varargs #t) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkmisc.h + +(define-function gtk_misc_get_type + (c-name "gtk_misc_get_type") + (return-type "GtkType") +) + +(define-method set_alignment + (of-object "GtkMisc") + (c-name "gtk_misc_set_alignment") + (return-type "none") + (parameters + '("gfloat" "xalign") + '("gfloat" "yalign") + ) +) + +(define-method set_padding + (of-object "GtkMisc") + (c-name "gtk_misc_set_padding") + (return-type "none") + (parameters + '("gint" "xpad") + '("gint" "ypad") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtknotebook.h + +(define-function gtk_notebook_get_type + (c-name "gtk_notebook_get_type") + (return-type "GtkType") +) + +(define-function gtk_notebook_new + (c-name "gtk_notebook_new") + (is-constructor-of GtkNotebook) + (return-type "GtkWidget*") +) + +(define-method append_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_append_page") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + ) +) + +(define-method append_page_menu + (of-object "GtkNotebook") + (c-name "gtk_notebook_append_page_menu") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + '("GtkWidget*" "menu_label") + ) +) + +(define-method prepend_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_prepend_page") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + ) +) + +(define-method prepend_page_menu + (of-object "GtkNotebook") + (c-name "gtk_notebook_prepend_page_menu") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + '("GtkWidget*" "menu_label") + ) +) + +(define-method insert_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_insert_page") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + '("gint" "position") + ) +) + +(define-method insert_page_menu + (of-object "GtkNotebook") + (c-name "gtk_notebook_insert_page_menu") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + '("GtkWidget*" "menu_label") + '("gint" "position") + ) +) + +(define-method remove_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_remove_page") + (return-type "none") + (parameters + '("gint" "page_num") + ) +) + +(define-method get_current_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_get_current_page") + (return-type "gint") +) + +(define-method get_nth_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_get_nth_page") + (return-type "GtkWidget*") + (parameters + '("gint" "page_num") + ) +) + +(define-method page_num + (of-object "GtkNotebook") + (c-name "gtk_notebook_page_num") + (return-type "gint") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method set_current_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_current_page") + (return-type "none") + (parameters + '("gint" "page_num") + ) +) + +(define-method next_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_next_page") + (return-type "none") +) + +(define-method prev_page + (of-object "GtkNotebook") + (c-name "gtk_notebook_prev_page") + (return-type "none") +) + +(define-method set_show_border + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_show_border") + (return-type "none") + (parameters + '("gboolean" "show_border") + ) +) + +(define-method set_show_tabs + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_show_tabs") + (return-type "none") + (parameters + '("gboolean" "show_tabs") + ) +) + +(define-method set_tab_pos + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_pos") + (return-type "none") + (parameters + '("GtkPositionType" "pos") + ) +) + +(define-method set_homogeneous_tabs + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_homogeneous_tabs") + (return-type "none") + (parameters + '("gboolean" "homogeneous") + ) +) + +(define-method set_tab_border + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_border") + (return-type "none") + (parameters + '("guint" "border_width") + ) +) + +(define-method set_tab_hborder + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_hborder") + (return-type "none") + (parameters + '("guint" "tab_hborder") + ) +) + +(define-method set_tab_vborder + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_vborder") + (return-type "none") + (parameters + '("guint" "tab_vborder") + ) +) + +(define-method set_scrollable + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_scrollable") + (return-type "none") + (parameters + '("gboolean" "scrollable") + ) +) + +(define-method popup_enable + (of-object "GtkNotebook") + (c-name "gtk_notebook_popup_enable") + (return-type "none") +) + +(define-method popup_disable + (of-object "GtkNotebook") + (c-name "gtk_notebook_popup_disable") + (return-type "none") +) + +(define-method get_tab_label + (of-object "GtkNotebook") + (c-name "gtk_notebook_get_tab_label") + (return-type "GtkWidget*") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method set_tab_label + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_label") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "tab_label") + ) +) + +(define-method set_tab_label_text + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_label_text") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("const-gchar*" "tab_text") + ) +) + +(define-method get_menu_label + (of-object "GtkNotebook") + (c-name "gtk_notebook_get_menu_label") + (return-type "GtkWidget*") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method set_menu_label + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_menu_label") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkWidget*" "menu_label") + ) +) + +(define-method set_menu_label_text + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_menu_label_text") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("const-gchar*" "menu_text") + ) +) + +(define-method query_tab_label_packing + (of-object "GtkNotebook") + (c-name "gtk_notebook_query_tab_label_packing") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean*" "expand") + '("gboolean*" "fill") + '("GtkPackType*" "pack_type") + ) +) + +(define-method set_tab_label_packing + (of-object "GtkNotebook") + (c-name "gtk_notebook_set_tab_label_packing") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "expand") + '("gboolean" "fill") + '("GtkPackType" "pack_type") + ) +) + +(define-method reorder_child + (of-object "GtkNotebook") + (c-name "gtk_notebook_reorder_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "position") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkobject.h + +(define-function gtk_object_get_type + (c-name "gtk_object_get_type") + (return-type "GtkType") +) + +(define-function object_new + (c-name "gtk_object_new") + (return-type "GtkObject*") + (parameters + '("GtkType" "type") + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-function object_newv + (c-name "gtk_object_newv") + (return-type "GtkObject*") + (parameters + '("GtkType" "object_type") + '("guint" "n_args") + '("GtkArg*" "args") + ) +) + +(define-method ref + (of-object "GtkObject") + (c-name "gtk_object_ref") + (return-type "GtkObject*") +) + +(define-method unref + (of-object "GtkObject") + (c-name "gtk_object_unref") + (return-type "none") +) + +(define-method sink + (of-object "GtkObject") + (c-name "gtk_object_sink") + (return-type "none") +) + +(define-method weakref + (of-object "GtkObject") + (c-name "gtk_object_weakref") + (return-type "none") + (parameters + '("GtkDestroyNotify" "notify") + '("gpointer" "data") + ) +) + +(define-method weakunref + (of-object "GtkObject") + (c-name "gtk_object_weakunref") + (return-type "none") + (parameters + '("GtkDestroyNotify" "notify") + '("gpointer" "data") + ) +) + +(define-method destroy + (of-object "GtkObject") + (c-name "gtk_object_destroy") + (return-type "none") +) + +(define-method set_data + (of-object "GtkObject") + (c-name "gtk_object_set_data") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("gpointer" "data") + ) +) + +(define-method set_data_full + (of-object "GtkObject") + (c-name "gtk_object_set_data_full") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-method remove_data + (of-object "GtkObject") + (c-name "gtk_object_remove_data") + (return-type "none") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method get_data + (of-object "GtkObject") + (c-name "gtk_object_get_data") + (return-type "gpointer") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method remove_no_notify + (of-object "GtkObject") + (c-name "gtk_object_remove_no_notify") + (return-type "none") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method set_user_data + (of-object "GtkObject") + (c-name "gtk_object_set_user_data") + (return-type "none") + (parameters + '("gpointer" "data") + ) +) + +(define-method get_user_data + (of-object "GtkObject") + (c-name "gtk_object_get_user_data") + (return-type "gpointer") +) + +(define-method set_data_by_id + (of-object "GtkObject") + (c-name "gtk_object_set_data_by_id") + (return-type "none") + (parameters + '("GQuark" "data_id") + '("gpointer" "data") + ) +) + +(define-method set_data_by_id_full + (of-object "GtkObject") + (c-name "gtk_object_set_data_by_id_full") + (return-type "none") + (parameters + '("GQuark" "data_id") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-method get_data_by_id + (of-object "GtkObject") + (c-name "gtk_object_get_data_by_id") + (return-type "gpointer") + (parameters + '("GQuark" "data_id") + ) +) + +(define-method remove_data_by_id + (of-object "GtkObject") + (c-name "gtk_object_remove_data_by_id") + (return-type "none") + (parameters + '("GQuark" "data_id") + ) +) + +(define-method remove_no_notify_by_id + (of-object "GtkObject") + (c-name "gtk_object_remove_no_notify_by_id") + (return-type "none") + (parameters + '("GQuark" "key_id") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkoptionmenu.h + +(define-function gtk_option_menu_get_type + (c-name "gtk_option_menu_get_type") + (return-type "GtkType") +) + +(define-function gtk_option_menu_new + (c-name "gtk_option_menu_new") + (is-constructor-of GtkOptionMenu) + (return-type "GtkWidget*") +) + +(define-method get_menu + (of-object "GtkOptionMenu") + (c-name "gtk_option_menu_get_menu") + (return-type "GtkWidget*") +) + +(define-method set_menu + (of-object "GtkOptionMenu") + (c-name "gtk_option_menu_set_menu") + (return-type "none") + (parameters + '("GtkWidget*" "menu") + ) +) + +(define-method remove_menu + (of-object "GtkOptionMenu") + (c-name "gtk_option_menu_remove_menu") + (return-type "none") +) + +(define-method get_history + (of-object "GtkOptionMenu") + (c-name "gtk_option_menu_get_history") + (return-type "gint") +) + +(define-method set_history + (of-object "GtkOptionMenu") + (c-name "gtk_option_menu_set_history") + (return-type "none") + (parameters + '("guint" "index") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkpaned.h + +(define-function gtk_paned_get_type + (c-name "gtk_paned_get_type") + (return-type "GtkType") +) + +(define-method add1 + (of-object "GtkPaned") + (c-name "gtk_paned_add1") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method add2 + (of-object "GtkPaned") + (c-name "gtk_paned_add2") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + +(define-method pack1 + (of-object "GtkPaned") + (c-name "gtk_paned_pack1") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "resize" (default "FALSE")) + '("gboolean" "shrink" (default "TRUE")) + ) +) + +(define-method pack2 + (of-object "GtkPaned") + (c-name "gtk_paned_pack2") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gboolean" "resize" (default "TRUE")) + '("gboolean" "shrink" (default "TRUE")) + ) +) + +(define-method get_position + (of-object "GtkPaned") + (c-name "gtk_paned_get_position") + (return-type "gint") +) + +(define-method set_position + (of-object "GtkPaned") + (c-name "gtk_paned_set_position") + (return-type "none") + (parameters + '("gint" "position") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkpixmap.h + +(define-function gtk_pixmap_get_type + (c-name "gtk_pixmap_get_type") + (return-type "GtkType") +) + +(define-function gtk_pixmap_new + (c-name "gtk_pixmap_new") + (is-constructor-of GtkPixmap) + (return-type "GtkWidget*") + (parameters + '("GdkPixmap*" "pixmap") + '("GdkBitmap*" "mask" (null-ok)) + ) +) + +(define-method set + (of-object "GtkPixmap") + (c-name "gtk_pixmap_set") + (return-type "none") + (parameters + '("GdkPixmap*" "val") + '("GdkBitmap*" "mask" (null-ok)) + ) +) + +(define-method get + (of-object "GtkPixmap") + (c-name "gtk_pixmap_get") + (return-type "none") + (parameters + '("GdkPixmap**" "val") + '("GdkBitmap**" "mask") + ) +) + +(define-method set_build_insensitive + (of-object "GtkPixmap") + (c-name "gtk_pixmap_set_build_insensitive") + (return-type "none") + (parameters + '("guint" "build") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkplug.h + +(define-function gtk_plug_get_type + (c-name "gtk_plug_get_type") + (return-type "GtkType") +) + +(define-method construct + (of-object "GtkPlug") + (c-name "gtk_plug_construct") + (return-type "none") + (parameters + '("GdkNativeWindow" "socket_id") + ) +) + +(define-function gtk_plug_new + (c-name "gtk_plug_new") + (is-constructor-of GtkPlug) + (return-type "GtkWidget*") + (parameters + '("GdkNativeWindow" "socket_id") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkpreview.h + +(define-function gtk_preview_get_type + (c-name "gtk_preview_get_type") + (return-type "GtkType") +) + +(define-function preview_uninit + (c-name "gtk_preview_uninit") + (return-type "none") +) + +(define-function gtk_preview_new + (c-name "gtk_preview_new") + (is-constructor-of GtkPreview) + (return-type "GtkWidget*") + (parameters + '("GtkPreviewType" "type") + ) +) + +(define-method size + (of-object "GtkPreview") + (c-name "gtk_preview_size") + (return-type "none") + (parameters + '("gint" "width") + '("gint" "height") + ) +) + +(define-method put + (of-object "GtkPreview") + (c-name "gtk_preview_put") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GdkGC*" "gc") + '("gint" "srcx") + '("gint" "srcy") + '("gint" "destx") + '("gint" "desty") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_row + (of-object "GtkPreview") + (c-name "gtk_preview_draw_row") + (return-type "none") + (parameters + '("guchar*" "data") + '("gint" "x") + '("gint" "y") + '("gint" "w") + ) +) + +(define-method set_expand + (of-object "GtkPreview") + (c-name "gtk_preview_set_expand") + (return-type "none") + (parameters + '("gboolean" "expand") + ) +) + +(define-function preview_set_gamma + (c-name "gtk_preview_set_gamma") + (return-type "none") + (parameters + '("double" "gamma") + ) +) + +(define-function preview_set_color_cube + (c-name "gtk_preview_set_color_cube") + (return-type "none") + (parameters + '("guint" "nred_shades") + '("guint" "ngreen_shades") + '("guint" "nblue_shades") + '("guint" "ngray_shades") + ) +) + +(define-function preview_set_install_cmap + (c-name "gtk_preview_set_install_cmap") + (return-type "none") + (parameters + '("gint" "install_cmap") + ) +) + +(define-function preview_set_reserved + (c-name "gtk_preview_set_reserved") + (return-type "none") + (parameters + '("gint" "nreserved") + ) +) + +(define-method set_dither + (of-object "GtkPreview") + (c-name "gtk_preview_set_dither") + (return-type "none") + (parameters + '("GdkRgbDither" "dither") + ) +) + +(define-function preview_get_visual + (c-name "gtk_preview_get_visual") + (return-type "GdkVisual*") +) + +(define-function preview_get_cmap + (c-name "gtk_preview_get_cmap") + (return-type "GdkColormap*") +) + +(define-function gtk_preview_get_info + (c-name "gtk_preview_get_info") + (return-type "GtkPreviewInfo*") +) + +(define-function preview_reset + (c-name "gtk_preview_reset") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkprivate.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkprogress.h + +(define-function gtk_progress_get_type + (c-name "gtk_progress_get_type") + (return-type "GtkType") +) + +(define-method set_show_text + (of-object "GtkProgress") + (c-name "gtk_progress_set_show_text") + (return-type "none") + (parameters + '("gint" "show_text") + ) +) + +(define-method set_text_alignment + (of-object "GtkProgress") + (c-name "gtk_progress_set_text_alignment") + (return-type "none") + (parameters + '("gfloat" "x_align") + '("gfloat" "y_align") + ) +) + +(define-method set_format_string + (of-object "GtkProgress") + (c-name "gtk_progress_set_format_string") + (return-type "none") + (parameters + '("const-gchar*" "format") + ) +) + +(define-method set_adjustment + (of-object "GtkProgress") + (c-name "gtk_progress_set_adjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method configure + (of-object "GtkProgress") + (c-name "gtk_progress_configure") + (return-type "none") + (parameters + '("gfloat" "value") + '("gfloat" "min") + '("gfloat" "max") + ) +) + +(define-method set_percentage + (of-object "GtkProgress") + (c-name "gtk_progress_set_percentage") + (return-type "none") + (parameters + '("gfloat" "percentage") + ) +) + +(define-method set_value + (of-object "GtkProgress") + (c-name "gtk_progress_set_value") + (return-type "none") + (parameters + '("gfloat" "value") + ) +) + +(define-method get_value + (of-object "GtkProgress") + (c-name "gtk_progress_get_value") + (return-type "gfloat") +) + +(define-method set_activity_mode + (of-object "GtkProgress") + (c-name "gtk_progress_set_activity_mode") + (return-type "none") + (parameters + '("guint" "activity_mode") + ) +) + +(define-method get_current_text + (of-object "GtkProgress") + (c-name "gtk_progress_get_current_text") + (return-type "gchar*") +) + +(define-method get_text_from_value + (of-object "GtkProgress") + (c-name "gtk_progress_get_text_from_value") + (return-type "gchar*") + (parameters + '("gfloat" "value") + ) +) + +(define-method get_current_percentage + (of-object "GtkProgress") + (c-name "gtk_progress_get_current_percentage") + (return-type "gfloat") +) + +(define-method get_percentage_from_value + (of-object "GtkProgress") + (c-name "gtk_progress_get_percentage_from_value") + (return-type "gfloat") + (parameters + '("gfloat" "value") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkprogressbar.h + +(define-function gtk_progress_bar_get_type + (c-name "gtk_progress_bar_get_type") + (return-type "GtkType") +) + +(define-function gtk_progress_bar_new + (c-name "gtk_progress_bar_new") + (is-constructor-of GtkProgressBar) + (return-type "GtkWidget*") +) + +(define-method pulse + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_pulse") + (return-type "none") +) + +(define-method set_text + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + ) +) + +(define-method set_fraction + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_fraction") + (return-type "none") + (parameters + '("gfloat" "fraction") + ) +) + +(define-method set_pulse_step + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_pulse_step") + (return-type "none") + (parameters + '("gfloat" "fraction") + ) +) + +(define-method set_orientation + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_orientation") + (return-type "none") + (parameters + '("GtkProgressBarOrientation" "orientation") + ) +) + +(define-method get_text + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_get_text") + (return-type "const-gchar*") +) + +(define-method get_fraction + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_get_fraction") + (return-type "gdouble") +) + +(define-method get_pulse_step + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_get_pulse_step") + (return-type "gdouble") +) + +(define-method get_orientation + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_get_orientation") + (return-type "GtkProgressBarOrientation") +) + +(define-function gtk_progress_bar_new_with_adjustment + (c-name "gtk_progress_bar_new_with_adjustment") + (is-constructor-of GtkProgressBar) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + ) +) + +(define-method set_bar_style + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_bar_style") + (return-type "none") + (parameters + '("GtkProgressBarStyle" "style") + ) +) + +(define-method set_discrete_blocks + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_discrete_blocks") + (return-type "none") + (parameters + '("guint" "blocks") + ) +) + +(define-method set_activity_step + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_activity_step") + (return-type "none") + (parameters + '("guint" "step") + ) +) + +(define-method set_activity_blocks + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_set_activity_blocks") + (return-type "none") + (parameters + '("guint" "blocks") + ) +) + +(define-method update + (of-object "GtkProgressBar") + (c-name "gtk_progress_bar_update") + (return-type "none") + (parameters + '("gfloat" "percentage") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkradiobutton.h + +(define-function gtk_radio_button_get_type + (c-name "gtk_radio_button_get_type") + (return-type "GtkType") +) + +(define-function gtk_radio_button_new + (c-name "gtk_radio_button_new") + (is-constructor-of GtkRadioButton) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + ) +) + +(define-function radio_button_new_from_widget + (is-constructor-of GtkRadioButton) + (c-name "gtk_radio_button_new_from_widget") + (return-type "GtkWidget*") + (parameters + '("GtkRadioButton*" "group") + ) +) + +(define-function radio_button_new_with_label + (c-name "gtk_radio_button_new_with_label") + (is-constructor-of GtkRadioButton) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + '("const-gchar*" "label") + ) +) + +(define-function radio_button_new_with_label_from_widget + (of-object "GtkRadioButton") + (is-constructor-of GtkRadioButton) + (c-name "gtk_radio_button_new_with_label_from_widget") + (return-type "GtkWidget*") + (parameters + '("GtkRadioButton" "*group") + '("const-gchar*" "label") + ) +) + +(define-function radio_button_new_with_mnemonic + (c-name "gtk_radio_button_new_with_mnemonic") + (is-constructor-of GtkRadioButton) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + '("const-gchar*" "label") + ) +) + +(define-function radio_button_new_with_mnemonic_from_widget + (of-object "GtkRadioButton") + (is-constructor-of GtkRadioButton) + (c-name "gtk_radio_button_new_with_mnemonic_from_widget") + (return-type "GtkWidget*") + (parameters + '("GtkRadioButton" "*group") + '("const-gchar*" "label") + ) +) + +(define-method get_group + (of-object "GtkRadioButton") + (c-name "gtk_radio_button_get_group") + (return-type "GSList*") +) + +(define-method set_group + (of-object "GtkRadioButton") + (c-name "gtk_radio_button_set_group") + (return-type "none") + (parameters + '("GSList*" "group") + ) +) + +; DEPRECATED +(define-method group + (of-object "GtkRadioButton") + (c-name "gtk_radio_button_group") + (return-type "GSList*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkradiomenuitem.h + +(define-function gtk_radio_menu_item_get_type + (c-name "gtk_radio_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_radio_menu_item_new + (c-name "gtk_radio_menu_item_new") + (is-constructor-of GtkRadioMenuItem) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + ) +) + +(define-function gtk_radio_menu_item_new_with_label + (c-name "gtk_radio_menu_item_new_with_label") + (is-constructor-of GtkRadioMenuItem) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + '("const-gchar*" "label") + ) +) + +(define-function gtk_radio_menu_item_new_with_mnemonic + (c-name "gtk_radio_menu_item_new_with_mnemonic") + (is-constructor-of GtkRadioMenuItem) + (return-type "GtkWidget*") + (parameters + '("GSList*" "group") + '("const-gchar*" "label") + ) +) + +(define-method group + (of-object "GtkRadioMenuItem") + (c-name "gtk_radio_menu_item_group") + (return-type "GSList*") +) + +(define-method set_group + (of-object "GtkRadioMenuItem") + (c-name "gtk_radio_menu_item_set_group") + (return-type "none") + (parameters + '("GSList*" "group") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkrange.h + +(define-function gtk_range_get_type + (c-name "gtk_range_get_type") + (return-type "GtkType") +) + +(define-method set_update_policy + (of-object "GtkRange") + (c-name "gtk_range_set_update_policy") + (return-type "none") + (parameters + '("GtkUpdateType" "policy") + ) +) + +(define-method set_adjustment + (of-object "GtkRange") + (c-name "gtk_range_set_adjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_adjustment + (of-object "GtkRange") + (c-name "gtk_range_get_adjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_inverted + (of-object "GtkRange") + (c-name "gtk_range_set_inverted") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_inverted + (of-object "GtkRange") + (c-name "gtk_range_get_inverted") + (return-type "gboolean") +) + +(define-method set_increments + (of-object "GtkRange") + (c-name "gtk_range_set_increments") + (return-type "none") + (parameters + '("gdouble" "step") + '("gdouble" "page") + ) +) + +(define-method set_range + (of-object "GtkRange") + (c-name "gtk_range_set_range") + (return-type "none") + (parameters + '("gdouble" "min") + '("gdouble" "max") + ) +) + +(define-method set_value + (of-object "GtkRange") + (c-name "gtk_range_set_value") + (return-type "none") + (parameters + '("gdouble" "value") + ) +) + +(define-method get_value + (of-object "GtkRange") + (c-name "gtk_range_get_value") + (return-type "gdouble") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkrc.h + +(define-function rc_add_default_file + (c-name "gtk_rc_add_default_file") + (return-type "none") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function rc_set_default_files + (c-name "gtk_rc_set_default_files") + (return-type "none") + (parameters + '("gchar**" "filenames") + ) +) + +(define-function rc_get_default_files + (c-name "gtk_rc_get_default_files") + (return-type "gchar**") +) + +(define-function rc_parse + (c-name "gtk_rc_parse") + (return-type "none") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-function rc_parse_string + (c-name "gtk_rc_parse_string") + (return-type "none") + (parameters + '("const-gchar*" "rc_string") + ) +) + +(define-function rc_reparse_all + (c-name "gtk_rc_reparse_all") + (return-type "gboolean") +) + +(define-method rc_get_style + (of-object "GtkWidget") + (c-name "gtk_rc_get_style") + (return-type "GtkStyle*") +) + +(define-function rc_add_widget_name_style + (c-name "gtk_rc_add_widget_name_style") + (return-type "none") + (parameters + '("GtkRcStyle*" "rc_style") + '("const-gchar*" "pattern") + ) +) + +(define-function rc_add_widget_class_style + (c-name "gtk_rc_add_widget_class_style") + (return-type "none") + (parameters + '("GtkRcStyle*" "rc_style") + '("const-gchar*" "pattern") + ) +) + +(define-function rc_add_class_style + (c-name "gtk_rc_add_class_style") + (return-type "none") + (parameters + '("GtkRcStyle*" "rc_style") + '("const-gchar*" "pattern") + ) +) + +(define-function rc_style_get_type + (c-name "gtk_rc_style_get_type") + (return-type "GType") +) + +(define-function gtk_rc_style_new + (c-name "gtk_rc_style_new") + (is-constructor-of GtkRCStyle) + (return-type "GtkRcStyle*") +) + +(define-method copy + (of-object "GtkRcStyle") + (c-name "gtk_rc_style_copy") + (return-type "GtkRcStyle*") +) + +(define-method ref + (of-object "GtkRcStyle") + (c-name "gtk_rc_style_ref") + (return-type "none") +) + +(define-method unref + (of-object "GtkRcStyle") + (c-name "gtk_rc_style_unref") + (return-type "none") +) + +(define-function rc_set_image_loader + (c-name "gtk_rc_set_image_loader") + (return-type "none") + (parameters + '("GtkImageLoader" "loader") + ) +) + +(define-function rc_find_pixmap_in_path + (c-name "gtk_rc_find_pixmap_in_path") + (return-type "gchar*") + (parameters + '("GScanner*" "scanner") + '("const-gchar*" "pixmap_file") + ) +) + +(define-function rc_find_module_in_path + (c-name "gtk_rc_find_module_in_path") + (return-type "gchar*") + (parameters + '("const-gchar*" "module_file") + ) +) + +(define-function rc_get_theme_dir + (c-name "gtk_rc_get_theme_dir") + (return-type "gchar*") +) + +(define-function rc_get_module_dir + (c-name "gtk_rc_get_module_dir") + (return-type "gchar*") +) + +(define-function rc_parse_color + (c-name "gtk_rc_parse_color") + (return-type "guint") + (parameters + '("GScanner*" "scanner") + '("GdkColor*" "color") + ) +) + +(define-function rc_parse_state + (c-name "gtk_rc_parse_state") + (return-type "guint") + (parameters + '("GScanner*" "scanner") + '("GtkStateType*" "state") + ) +) + +(define-function rc_parse_priority + (c-name "gtk_rc_parse_priority") + (return-type "guint") + (parameters + '("GScanner*" "scanner") + '("GtkPathPriorityType*" "priority") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkruler.h + +(define-function gtk_ruler_get_type + (c-name "gtk_ruler_get_type") + (return-type "GtkType") +) + +(define-method set_metric + (of-object "GtkRuler") + (c-name "gtk_ruler_set_metric") + (return-type "none") + (parameters + '("GtkMetricType" "metric") + ) +) + +(define-method set_range + (of-object "GtkRuler") + (c-name "gtk_ruler_set_range") + (return-type "none") + (parameters + '("gfloat" "lower") + '("gfloat" "upper") + '("gfloat" "position") + '("gfloat" "max_size") + ) +) + +(define-method draw_ticks + (of-object "GtkRuler") + (c-name "gtk_ruler_draw_ticks") + (return-type "none") +) + +(define-method draw_pos + (of-object "GtkRuler") + (c-name "gtk_ruler_draw_pos") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkscale.h + +(define-function gtk_scale_get_type + (c-name "gtk_scale_get_type") + (return-type "GtkType") +) + +(define-method set_digits + (of-object "GtkScale") + (c-name "gtk_scale_set_digits") + (return-type "none") + (parameters + '("gint" "digits") + ) +) + +(define-method get_digits + (of-object "GtkScale") + (c-name "gtk_scale_get_digits") + (return-type "gint") +) + +(define-method set_draw_value + (of-object "GtkScale") + (c-name "gtk_scale_set_draw_value") + (return-type "none") + (parameters + '("gboolean" "draw_value") + ) +) + +(define-method get_draw_value + (of-object "GtkScale") + (c-name "gtk_scale_get_draw_value") + (return-type "gboolean") +) + +(define-method set_value_pos + (of-object "GtkScale") + (c-name "gtk_scale_set_value_pos") + (return-type "none") + (parameters + '("GtkPositionType" "pos") + ) +) + +(define-method get_value_pos + (of-object "GtkScale") + (c-name "gtk_scale_get_value_pos") + (return-type "GtkPositionType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkscrollbar.h + +(define-function gtk_scrollbar_get_type + (c-name "gtk_scrollbar_get_type") + (return-type "GtkType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkscrolledwindow.h + +(define-function gtk_scrolled_window_get_type + (c-name "gtk_scrolled_window_get_type") + (return-type "GtkType") +) + +(define-function gtk_scrolled_window_new + (c-name "gtk_scrolled_window_new") + (is-constructor-of GtkScrolledWindow) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "hadjustment" (null-ok) (default "NULL")) + '("GtkAdjustment*" "vadjustment" (null-ok) (default "NULL")) + ) +) + +(define-method set_hadjustment + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_set_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "hadjustment") + ) +) + +(define-method set_vadjustment + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_set_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "hadjustment") + ) +) + +(define-method get_hadjustment + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_get_hadjustment") + (return-type "GtkAdjustment*") +) + +(define-method get_vadjustment + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_get_vadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_policy + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_set_policy") + (return-type "none") + (parameters + '("GtkPolicyType" "hscrollbar_policy") + '("GtkPolicyType" "vscrollbar_policy") + ) +) + +(define-method set_placement + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_set_placement") + (return-type "none") + (parameters + '("GtkCornerType" "window_placement") + ) +) + +(define-method set_shadow_type + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_set_shadow_type") + (return-type "none") + (parameters + '("GtkShadowType" "type") + ) +) + +(define-method add_with_viewport + (of-object "GtkScrolledWindow") + (c-name "gtk_scrolled_window_add_with_viewport") + (return-type "none") + (parameters + '("GtkWidget*" "child") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkselection.h + +(define-function gtk_target_list_new + (c-name "gtk_target_list_new") + (return-type "GtkTargetList*") + (parameters + '("const-GtkTargetEntry*" "targets") + '("guint" "ntargets") + ) +) + +(define-method ref + (of-object "GtkTargetList") + (c-name "gtk_target_list_ref") + (return-type "none") +) + +(define-method unref + (of-object "GtkTargetList") + (c-name "gtk_target_list_unref") + (return-type "none") +) + +(define-method add + (of-object "GtkTargetList") + (c-name "gtk_target_list_add") + (return-type "none") + (parameters + '("GdkAtom" "target") + '("guint" "flags") + '("guint" "info") + ) +) + +(define-method add_table + (of-object "GtkTargetList") + (c-name "gtk_target_list_add_table") + (return-type "none") + (parameters + '("const-GtkTargetEntry*" "targets") + '("guint" "ntargets") + ) +) + +(define-method remove + (of-object "GtkTargetList") + (c-name "gtk_target_list_remove") + (return-type "none") + (parameters + '("GdkAtom" "target") + ) +) + +(define-method find + (of-object "GtkTargetList") + (c-name "gtk_target_list_find") + (return-type "gboolean") + (parameters + '("GdkAtom" "target") + '("guint*" "info") + ) +) + +(define-method selection_owner_set + (of-object "GtkWidget") + (c-name "gtk_selection_owner_set") + (return-type "gboolean") + (parameters + '("GdkAtom" "selection") + '("guint32" "time" (default "GDK_CURRENT_TIME")) + ) +) + +(define-method selection_add_target + (of-object "GtkWidget") + (c-name "gtk_selection_add_target") + (return-type "none") + (parameters + '("GdkAtom" "selection") + '("GdkAtom" "target") + '("guint" "info") + ) +) + +(define-method selection_add_targets + (of-object "GtkWidget") + (c-name "gtk_selection_add_targets") + (return-type "none") + (parameters + '("GdkAtom" "selection") + '("const-GtkTargetEntry*" "targets") + '("guint" "ntargets") + ) +) + +(define-method selection_clear_targets + (of-object "GtkWidget") + (c-name "gtk_selection_clear_targets") + (return-type "none") + (parameters + '("GdkAtom" "selection") + ) +) + +(define-method selection_convert + (of-object "GtkWidget") + (c-name "gtk_selection_convert") + (return-type "gint") + (parameters + '("GdkAtom" "selection") + '("GdkAtom" "target") + '("guint32" "time" (default "GDK_CURRENT_TIME")) + ) +) + +(define-method set + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_set") + (return-type "none") + (parameters + '("GdkAtom" "type") + '("gint" "format") + '("const-guchar*" "data") + '("gint" "length") + ) +) + +(define-method set_text + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_set_text") + (return-type "gboolean") + (parameters + '("const-guchar*" "str") + ) +) + +(define-method get_text + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_get_text") + (return-type "guchar*") +) + +(define-method selection_remove_all + (of-object "GtkWidget") + (c-name "gtk_selection_remove_all") + (return-type "none") +) + +(define-method selection_clear + (of-object "GtkWidget") + (c-name "gtk_selection_clear") + (return-type "gint") + (parameters + '("GdkEventSelection*" "event") + ) +) + +(define-method selection_request + (of-object "GtkWidget") + (c-name "gtk_selection_request") + (return-type "gint") + (parameters + '("GdkEventSelection*" "event") + ) +) + +(define-function gtk_selection_incr_event + (c-name "gtk_selection_incr_event") + (return-type "gint") + (parameters + '("GdkWindow*" "window") + '("GdkEventProperty*" "event") + ) +) + +(define-method selection_notify + (of-object "GtkWidget") + (c-name "gtk_selection_notify") + (return-type "gint") + (parameters + '("GdkEventSelection*" "event") + ) +) + +(define-method selection_property_notify + (of-object "GtkWidget") + (c-name "gtk_selection_property_notify") + (return-type "gint") + (parameters + '("GdkEventProperty*" "event") + ) +) + +(define-method copy + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_copy") + (return-type "GtkSelectionData*") +) + +(define-method free + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_free") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkseparator.h + +(define-function gtk_separator_get_type + (c-name "gtk_separator_get_type") + (return-type "GtkType") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkseparatormenuitem.h + +(define-function gtk_separator_menu_item_get_type + (c-name "gtk_separator_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_separator_menu_item_new + (c-name "gtk_separator_menu_item_new") + (is-constructor-of GtkSeparatorMenuItem) + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtksettings.h + +(define-function gtk_settings_get_type + (c-name "gtk_settings_get_type") + (return-type "GType") +) + +(define-function settings_get_default + (c-name "gtk_settings_get_default") + (return-type "GtkSettings*") +) + +(define-method install_property + (of-object "GtkSettings") + (c-name "gtk_settings_install_property") + (return-type "none") + (parameters + '("GParamSpec*" "pspec") + ) +) + +(define-method install_property_parser + (of-object "GtkSettings") + (c-name "gtk_settings_install_property_parser") + (return-type "none") + (parameters + '("GParamSpec*" "pspec") + '("GtkRcPropertyParser" "parser") + ) +) + +(define-function rc_property_parse_color + (c-name "gtk_rc_property_parse_color") + (return-type "gboolean") + (parameters + '("const-GParamSpec*" "pspec") + '("const-GString*" "gstring") + '("GValue*" "property_value") + ) +) + +(define-function rc_property_parse_enum + (c-name "gtk_rc_property_parse_enum") + (return-type "gboolean") + (parameters + '("const-GParamSpec*" "pspec") + '("const-GString*" "gstring") + '("GValue*" "property_value") + ) +) + +(define-function rc_property_parse_flags + (c-name "gtk_rc_property_parse_flags") + (return-type "gboolean") + (parameters + '("const-GParamSpec*" "pspec") + '("const-GString*" "gstring") + '("GValue*" "property_value") + ) +) + +(define-function rc_property_parse_requisition + (c-name "gtk_rc_property_parse_requisition") + (return-type "gboolean") + (parameters + '("const-GParamSpec*" "pspec") + '("const-GString*" "gstring") + '("GValue*" "property_value") + ) +) + +(define-function rc_property_parse_border + (c-name "gtk_rc_property_parse_border") + (return-type "gboolean") + (parameters + '("const-GParamSpec*" "pspec") + '("const-GString*" "gstring") + '("GValue*" "property_value") + ) +) + +(define-method set_property_value + (of-object "GtkSettings") + (c-name "gtk_settings_set_property_value") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-GtkSettingsValue*" "svalue") + ) +) + +(define-method set_string_property + (of-object "GtkSettings") + (c-name "gtk_settings_set_string_property") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "v_string") + '("const-gchar*" "origin") + ) +) + +(define-method set_long_property + (of-object "GtkSettings") + (c-name "gtk_settings_set_long_property") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("glong" "v_long") + '("const-gchar*" "origin") + ) +) + +(define-method set_double_property + (of-object "GtkSettings") + (c-name "gtk_settings_set_double_property") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("gdouble" "v_double") + '("const-gchar*" "origin") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtksizegroup.h + +(define-function gtk_size_group_get_type + (c-name "gtk_size_group_get_type") + (return-type "GType") +) + +(define-function size_group_new + (c-name "gtk_size_group_new") + (is-constructor-of GtkSizeGroup) + (return-type "GtkSizeGroup*") + (parameters + '("GtkSizeGroupMode" "mode") + ) +) + +(define-method set_mode + (of-object "GtkSizeGroup") + (c-name "gtk_size_group_set_mode") + (return-type "none") + (parameters + '("GtkSizeGroupMode" "mode") + ) +) + +(define-method get_mode + (of-object "GtkSizeGroup") + (c-name "gtk_size_group_get_mode") + (return-type "GtkSizeGroupMode") +) + +(define-method add_widget + (of-object "GtkSizeGroup") + (c-name "gtk_size_group_add_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method remove_widget + (of-object "GtkSizeGroup") + (c-name "gtk_size_group_remove_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtksocket.h + +(define-function gtk_socket_new + (c-name "gtk_socket_new") + (is-constructor-of GtkSocket) + (return-type "GtkWidget*") +) + +(define-function gtk_socket_get_type + (c-name "gtk_socket_get_type") + (return-type "GtkType") +) + +(define-method steal + (of-object "GtkSocket") + (c-name "gtk_socket_steal") + (return-type "none") + (parameters + '("GdkNativeWindow" "wid") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkspinbutton.h + +(define-function gtk_spin_button_get_type + (c-name "gtk_spin_button_get_type") + (return-type "GtkType") +) + +(define-method configure + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_configure") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok)) + '("gfloat" "climb_rate") + '("guint" "digits") + ) +) + +(define-function gtk_spin_button_new + (c-name "gtk_spin_button_new") + (is-constructor-of GtkSpinButton) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + '("gfloat" "climb_rate" (default "0.0")) + '("guint" "digits" (default "0")) + ) +) + +(define-function gtk_spin_button_new_with_range + (c-name "gtk_spin_button_new_with_range") + (is-constructor-of GtkSpinButton) + (return-type "GtkWidget*") + (parameters + '("gdouble" "min") + '("gdouble" "max") + '("gdouble" "step") + ) +) + +(define-method set_adjustment + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_adjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_adjustment + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_adjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_digits + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_digits") + (return-type "none") + (parameters + '("guint" "digits") + ) +) + +(define-method get_digits + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_digits") + (return-type "guint") +) + +(define-method set_increments + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_increments") + (return-type "none") + (parameters + '("gdouble" "step") + '("gdouble" "page") + ) +) + +(define-method get_increments + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_increments") + (return-type "none") + (parameters + '("gdouble*" "step") + '("gdouble*" "page") + ) +) + +(define-method set_range + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_range") + (return-type "none") + (parameters + '("gdouble" "min") + '("gdouble" "max") + ) +) + +(define-method get_range + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_range") + (return-type "none") + (parameters + '("gdouble*" "min") + '("gdouble*" "max") + ) +) + +(define-method get_value + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_value") + (return-type "gdouble") +) + +(define-method get_value_as_int + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_value_as_int") + (return-type "gint") +) + +(define-method set_value + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_value") + (return-type "none") + (parameters + '("gfloat" "value") + ) +) + +(define-method set_update_policy + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_update_policy") + (return-type "none") + (parameters + '("GtkSpinButtonUpdatePolicy" "policy") + ) +) + +(define-method get_update_policy + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_update_policy") + (return-type "guint") +) + +(define-method set_numeric + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_numeric") + (return-type "none") + (parameters + '("gboolean" "numeric") + ) +) + +(define-method get_numeric + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_numeric") + (return-type "gboolean") +) + +(define-method spin + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_spin") + (return-type "none") + (parameters + '("GtkSpinType" "direction") + '("gfloat" "increment") + ) +) + +(define-method set_wrap + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_wrap") + (return-type "none") + (parameters + '("gboolean" "wrap") + ) +) + +(define-method get_wrap + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_wrap") + (return-type "gboolean") +) + +(define-method set_snap_to_ticks + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_set_snap_to_ticks") + (return-type "none") + (parameters + '("gboolean" "snap_to_ticks") + ) +) + +(define-method get_snap_to_ticks + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_get_snap_to_ticks") + (return-type "gboolean") +) + +(define-method update + (of-object "GtkSpinButton") + (c-name "gtk_spin_button_update") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkstatusbar.h + +(define-function gtk_statusbar_get_type + (c-name "gtk_statusbar_get_type") + (return-type "GtkType") +) + +(define-function gtk_statusbar_new + (c-name "gtk_statusbar_new") + (is-constructor-of GtkStatusbar) + (return-type "GtkWidget*") +) + +(define-method get_context_id + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_get_context_id") + (return-type "guint") + (parameters + '("const-gchar*" "context_description") + ) +) + +(define-method push + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_push") + (return-type "guint") + (parameters + '("guint" "context_id") + '("const-gchar*" "text") + ) +) + +(define-method pop + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_pop") + (return-type "none") + (parameters + '("guint" "context_id") + ) +) + +(define-method remove + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_remove") + (return-type "none") + (parameters + '("guint" "context_id") + '("guint" "message_id") + ) +) + +(define-method get_has_resize_grip + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_get_has_resize_grip") + (return-type "gboolean") +) + +(define-method set_has_resize_grip + (of-object "GtkStatusbar") + (c-name "gtk_statusbar_set_has_resize_grip") + (parameters + '("gboolean" "setting") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkstock.h + +(define-function stock_add + (c-name "gtk_stock_add") + (return-type "none") + (parameters + '("const-GtkStockItem*" "item") + '("guint" "n_items") + ) +) + +(define-function stock_add_static + (c-name "gtk_stock_add_static") + (return-type "none") + (parameters + '("const-GtkStockItem*" "item") + '("guint" "n_items") + ) +) + +(define-function stock_lookup + (c-name "gtk_stock_lookup") + (return-type "gboolean") + (parameters + '("const-gchar*" "stock_id") + '("GtkStockItem*" "item") + ) +) + +(define-function stock_list_ids + (c-name "gtk_stock_list_ids") + (return-type "GSList*") +) + +(define-method copy + (of-object "GtkStockItem") + (c-name "gtk_stock_item_copy") + (return-type "GtkStockItem*") +) + +(define-method free + (of-object "GtkStockItem") + (c-name "gtk_stock_item_free") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkstyle.h + +(define-function gtk_style_get_type + (c-name "gtk_style_get_type") + (return-type "GType") +) + +(define-function gtk_style_new + (c-name "gtk_style_new") + (is-constructor-of GtkStyle) + (return-type "GtkStyle*") +) + +(define-method copy + (of-object "GtkStyle") + (c-name "gtk_style_copy") + (return-type "GtkStyle*") +) + +(define-method attach + (of-object "GtkStyle") + (c-name "gtk_style_attach") + (return-type "GtkStyle*") + (parameters + '("GdkWindow*" "window") + ) +) + +(define-method detach + (of-object "GtkStyle") + (c-name "gtk_style_detach") + (return-type "none") +) + +(define-method ref + (of-object "GtkStyle") + (c-name "gtk_style_ref") + (return-type "GtkStyle*") +) + +(define-method unref + (of-object "GtkStyle") + (c-name "gtk_style_unref") + (return-type "none") +) + +(define-method set_background + (of-object "GtkStyle") + (c-name "gtk_style_set_background") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + ) +) + +(define-method apply_default_background + (of-object "GtkStyle") + (c-name "gtk_style_apply_default_background") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("gboolean" "set_bg") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method lookup_icon_set + (of-object "GtkStyle") + (c-name "gtk_style_lookup_icon_set") + (return-type "GtkIconSet*") + (parameters + '("const-gchar*" "stock_id") + ) +) + +(define-method render_icon + (of-object "GtkStyle") + (c-name "gtk_style_render_icon") + (return-type "GdkPixbuf*") + (parameters + '("const-GtkIconSource*" "source") + '("GtkTextDirection" "direction") + '("GtkStateType" "state") + '("const-gchar*" "size") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + ) +) + +(define-method draw_hline + (of-object "GtkStyle") + (c-name "gtk_draw_hline") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gint" "x1") + '("gint" "x2") + '("gint" "y") + ) +) + +(define-method draw_vline + (of-object "GtkStyle") + (c-name "gtk_draw_vline") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gint" "y1") + '("gint" "y2") + '("gint" "x") + ) +) + +(define-method draw_shadow + (of-object "GtkStyle") + (c-name "gtk_draw_shadow") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_polygon + (of-object "GtkStyle") + (c-name "gtk_draw_polygon") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkPoint*" "points") + '("gint" "npoints") + '("gboolean" "fill") + ) +) + +(define-method draw_arrow + (of-object "GtkStyle") + (c-name "gtk_draw_arrow") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GtkArrowType" "arrow_type") + '("gboolean" "fill") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_diamond + (of-object "GtkStyle") + (c-name "gtk_draw_diamond") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_oval + (of-object "GtkStyle") + (c-name "gtk_draw_oval") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_string + (of-object "GtkStyle") + (c-name "gtk_draw_string") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gint" "x") + '("gint" "y") + '("const-gchar*" "string") + ) +) + +(define-method draw_box + (of-object "GtkStyle") + (c-name "gtk_draw_box") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_flat_box + (of-object "GtkStyle") + (c-name "gtk_draw_flat_box") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_check + (of-object "GtkStyle") + (c-name "gtk_draw_check") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_option + (of-object "GtkStyle") + (c-name "gtk_draw_option") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_cross + (of-object "GtkStyle") + (c-name "gtk_draw_cross") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_ramp + (of-object "GtkStyle") + (c-name "gtk_draw_ramp") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GtkArrowType" "arrow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_tab + (of-object "GtkStyle") + (c-name "gtk_draw_tab") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_shadow_gap + (of-object "GtkStyle") + (c-name "gtk_draw_shadow_gap") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + '("gint" "gap_x") + '("gint" "gap_width") + ) +) + +(define-method draw_box_gap + (of-object "GtkStyle") + (c-name "gtk_draw_box_gap") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + '("gint" "gap_x") + '("gint" "gap_width") + ) +) + +(define-method draw_extension + (of-object "GtkStyle") + (c-name "gtk_draw_extension") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + ) +) + +(define-method draw_focus + (of-object "GtkStyle") + (c-name "gtk_draw_focus") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method draw_slider + (of-object "GtkStyle") + (c-name "gtk_draw_slider") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkOrientation" "orientation") + ) +) + +(define-method draw_handle + (of-object "GtkStyle") + (c-name "gtk_draw_handle") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkOrientation" "orientation") + ) +) + +(define-method draw_expander + (of-object "GtkStyle") + (c-name "gtk_draw_expander") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gint" "x") + '("gint" "y") + '("gboolean" "is_open") + ) +) + +(define-method draw_layout + (of-object "GtkStyle") + (c-name "gtk_draw_layout") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gboolean" "use_text") + '("gint" "x") + '("gint" "y") + '("PangoLayout*" "layout") + ) +) + +(define-method draw_resize_grip + (of-object "GtkStyle") + (c-name "gtk_draw_resize_grip") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkWindowEdge" "edge") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_hline + (of-object "GtkStyle") + (c-name "gtk_paint_hline") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x1") + '("gint" "x2") + '("gint" "y") + ) +) + +(define-method paint_vline + (of-object "GtkStyle") + (c-name "gtk_paint_vline") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "y1") + '("gint" "y2") + '("gint" "x") + ) +) + +(define-method paint_shadow + (of-object "GtkStyle") + (c-name "gtk_paint_shadow") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_polygon + (of-object "GtkStyle") + (c-name "gtk_paint_polygon") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("GdkPoint*" "points") + '("gint" "npoints") + '("gboolean" "fill") + ) +) + +(define-method paint_arrow + (of-object "GtkStyle") + (c-name "gtk_paint_arrow") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("GtkArrowType" "arrow_type") + '("gboolean" "fill") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_diamond + (of-object "GtkStyle") + (c-name "gtk_paint_diamond") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_string + (of-object "GtkStyle") + (c-name "gtk_paint_string") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("const-gchar*" "string") + ) +) + +(define-method paint_box + (of-object "GtkStyle") + (c-name "gtk_paint_box") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_flat_box + (of-object "GtkStyle") + (c-name "gtk_paint_flat_box") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_check + (of-object "GtkStyle") + (c-name "gtk_paint_check") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_option + (of-object "GtkStyle") + (c-name "gtk_paint_option") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_tab + (of-object "GtkStyle") + (c-name "gtk_paint_tab") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_shadow_gap + (of-object "GtkStyle") + (c-name "gtk_paint_shadow_gap") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + '("gint" "gap_x") + '("gint" "gap_width") + ) +) + +(define-method paint_box_gap + (of-object "GtkStyle") + (c-name "gtk_paint_box_gap") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + '("gint" "gap_x") + '("gint" "gap_width") + ) +) + +(define-method paint_extension + (of-object "GtkStyle") + (c-name "gtk_paint_extension") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkPositionType" "gap_side") + ) +) + +(define-method paint_focus + (of-object "GtkStyle") + (c-name "gtk_paint_focus") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method paint_slider + (of-object "GtkStyle") + (c-name "gtk_paint_slider") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkOrientation" "orientation") + ) +) + +(define-method paint_handle + (of-object "GtkStyle") + (c-name "gtk_paint_handle") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GtkShadowType" "shadow_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + '("GtkOrientation" "orientation") + ) +) + +(define-method paint_expander + (of-object "GtkStyle") + (c-name "gtk_paint_expander") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("gboolean" "is_open") + ) +) + +(define-method paint_layout + (of-object "GtkStyle") + (c-name "gtk_paint_layout") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("gboolean" "use_text") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("gint" "x") + '("gint" "y") + '("PangoLayout*" "layout") + ) +) + +(define-method paint_resize_grip + (of-object "GtkStyle") + (c-name "gtk_paint_resize_grip") + (return-type "none") + (parameters + '("GdkWindow*" "window") + '("GtkStateType" "state_type") + '("GdkRectangle*" "area") + '("GtkWidget*" "widget") + '("const-gchar*" "detail") + '("GtkWindowEdge" "edge") + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktable.h + +(define-function gtk_table_get_type + (c-name "gtk_table_get_type") + (return-type "GtkType") +) + +(define-function gtk_table_new + (c-name "gtk_table_new") + (is-constructor-of GtkTable) + (return-type "GtkWidget*") + (parameters + '("guint" "rows" (default "1")) + '("guint" "columns" (default "1")) + '("gboolean" "homogeneous" (default "FALSE")) + ) +) + +(define-method resize + (of-object "GtkTable") + (c-name "gtk_table_resize") + (return-type "none") + (parameters + '("guint" "rows") + '("guint" "columns") + ) +) + +(define-method attach + (of-object "GtkTable") + (c-name "gtk_table_attach") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("guint" "left_attach") + '("guint" "right_attach") + '("guint" "top_attach") + '("guint" "bottom_attach") + '("GtkAttachOptions" "xoptions" (default "GTK_EXPAND|GTK_FILL")) + '("GtkAttachOptions" "yoptions" (default "GTK_EXPAND|GTK_FILL")) + '("guint" "xpadding" (default "0")) + '("guint" "ypadding" (default "0")) + ) +) + +(define-method attach_defaults + (of-object "GtkTable") + (c-name "gtk_table_attach_defaults") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("guint" "left_attach") + '("guint" "right_attach") + '("guint" "top_attach") + '("guint" "bottom_attach") + ) +) + +(define-method set_row_spacing + (of-object "GtkTable") + (c-name "gtk_table_set_row_spacing") + (return-type "none") + (parameters + '("guint" "row") + '("guint" "spacing") + ) +) + +(define-method set_col_spacing + (of-object "GtkTable") + (c-name "gtk_table_set_col_spacing") + (return-type "none") + (parameters + '("guint" "column") + '("guint" "spacing") + ) +) + +(define-method set_row_spacings + (of-object "GtkTable") + (c-name "gtk_table_set_row_spacings") + (return-type "none") + (parameters + '("guint" "spacing") + ) +) + +(define-method set_col_spacings + (of-object "GtkTable") + (c-name "gtk_table_set_col_spacings") + (return-type "none") + (parameters + '("guint" "spacing") + ) +) + +(define-method set_homogeneous + (of-object "GtkTable") + (c-name "gtk_table_set_homogeneous") + (return-type "none") + (parameters + '("gboolean" "homogeneous") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktearoffmenuitem.h + +(define-function gtk_tearoff_menu_item_get_type + (c-name "gtk_tearoff_menu_item_get_type") + (return-type "GtkType") +) + +(define-function gtk_tearoff_menu_item_new + (c-name "gtk_tearoff_menu_item_new") + (is-constructor-of GtkTearoffMenuItem) + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextbuffer.h + +(define-function gtk_text_buffer_get_type + (c-name "gtk_text_buffer_get_type") + (return-type "GtkType") +) + +(define-function gtk_text_buffer_new + (c-name "gtk_text_buffer_new") + (is-constructor-of GtkTextBuffer) + (return-type "GtkTextBuffer*") + (parameters + '("GtkTextTagTable*" "table" (null-ok)) + ) +) + +(define-method get_line_count + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_line_count") + (return-type "gint") +) + +(define-method get_char_count + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_char_count") + (return-type "gint") +) + +(define-method get_tag_table + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_tag_table") + (return-type "GtkTextTagTable*") +) + +(define-method set_text + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_set_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("gint" "len") + ) +) + +(define-method insert + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "text") + '("gint" "len" (default "-1")) + ) +) + +(define-method insert_at_cursor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_at_cursor") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("gint" "len") + ) +) + +(define-method insert_interactive + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_interactive") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "text") + '("gint" "len") + '("gboolean" "default_editable") + ) +) + +(define-method insert_interactive_at_cursor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_interactive_at_cursor") + (return-type "gboolean") + (parameters + '("const-gchar*" "text") + '("gint" "len") + '("gboolean" "default_editable") + ) +) + +(define-method insert_range + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_range") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method insert_range_interactive + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_range_interactive") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + '("gboolean" "default_editable") + ) +) + +(define-method insert_with_tags + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_with_tags") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "text") + '("gint" "len") + '("GtkTextTag*" "first_tag") + ) + (varargs #t) +) + +(define-method insert_with_tags_by_name + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_with_tags_by_name") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "text") + '("gint" "len") + '("const-gchar*" "first_tag_name") + ) + (varargs #t) +) + +(define-method delete + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_delete") + (return-type "none") + (parameters + '("GtkTextIter*" "start") + '("GtkTextIter*" "end") + ) +) + +(define-method delete_interactive + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_delete_interactive") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "start_iter") + '("GtkTextIter*" "end_iter") + '("gboolean" "default_editable") + ) +) + +(define-method get_text + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_text") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + '("gboolean" "include_hidden_chars") + ) +) + +(define-method get_slice + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_slice") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + '("gboolean" "include_hidden_chars") + ) +) + +(define-method insert_pixbuf + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_pixbuf") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("GdkPixbuf*" "pixbuf") + ) +) + +(define-method insert_child_anchor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_insert_child_anchor") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("GtkTextChildAnchor*" "anchor") + ) +) + +(define-method create_child_anchor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_create_child_anchor") + (return-type "GtkTextChildAnchor*") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method create_mark + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_create_mark") + (return-type "GtkTextMark*") + (parameters + '("const-gchar*" "mark_name") + '("const-GtkTextIter*" "where") + '("gboolean" "left_gravity") + ) +) + +(define-method move_mark + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_move_mark") + (return-type "none") + (parameters + '("GtkTextMark*" "mark") + '("const-GtkTextIter*" "where") + ) +) + +(define-method delete_mark + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_delete_mark") + (return-type "none") + (parameters + '("GtkTextMark*" "mark") + ) +) + +(define-method get_mark + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_mark") + (return-type "GtkTextMark*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method move_mark_by_name + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_move_mark_by_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-GtkTextIter*" "where") + ) +) + +(define-method delete_mark_by_name + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_delete_mark_by_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_insert + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_insert") + (return-type "GtkTextMark*") +) + +(define-method get_selection_bound + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_selection_bound") + (return-type "GtkTextMark*") +) + +(define-method place_cursor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_place_cursor") + (return-type "none") + (parameters + '("const-GtkTextIter*" "where") + ) +) + +(define-method apply_tag + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_apply_tag") + (return-type "none") + (parameters + '("GtkTextTag*" "tag") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method remove_tag + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_remove_tag") + (return-type "none") + (parameters + '("GtkTextTag*" "tag") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method apply_tag_by_name + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_apply_tag_by_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method remove_tag_by_name + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_remove_tag_by_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method remove_all_tags + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_remove_all_tags") + (return-type "none") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method create_tag + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_create_tag") + (return-type "GtkTextTag*") + (parameters + '("const-gchar*" "tag_name") + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method get_iter_at_line_offset + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_line_offset") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("gint" "line_number") + '("gint" "char_offset") + ) +) + +(define-method get_iter_at_line_index + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_line_index") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("gint" "line_number") + '("gint" "byte_offset") + ) +) + +(define-method get_iter_at_offset + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_offset") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("gint" "char_offset") + ) +) + +(define-method get_iter_at_line + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_line") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("gint" "line_number") + ) +) + +(define-method get_start_iter + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_start_iter") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method get_end_iter + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_end_iter") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method get_bounds + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_bounds") + (return-type "none") + (parameters + '("GtkTextIter*" "start") + '("GtkTextIter*" "end") + ) +) + +(define-method get_iter_at_mark + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_mark") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("GtkTextMark*" "mark") + ) +) + +(define-method get_iter_at_child_anchor + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_iter_at_child_anchor") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("GtkTextChildAnchor*" "anchor") + ) +) + +(define-method get_modified + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_modified") + (return-type "gboolean") +) + +(define-method set_modified + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_set_modified") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method cut_clipboard + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_cut_clipboard") + (return-type "none") + (parameters + '("GtkClipboard*" "clipboard") + '("gboolean" "default_editable") + ) +) + +(define-method copy_clipboard + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_copy_clipboard") + (return-type "none") + (parameters + '("GtkClipboard*" "clipboard") + ) +) + +(define-method paste_clipboard + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_paste_clipboard") + (return-type "none") + (parameters + '("GtkClipboard*" "clipboard") + '("GtkTextIter*" "override_location") + '("gboolean" "default_editable") + ) +) + +(define-method get_selection_bounds + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_get_selection_bounds") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "start") + '("GtkTextIter*" "end") + ) +) + +(define-method delete_selection + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_delete_selection") + (return-type "gboolean") + (parameters + '("gboolean" "interactive") + '("gboolean" "default_editable") + ) +) + +(define-method begin_user_action + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_begin_user_action") + (return-type "none") +) + +(define-method end_user_action + (of-object "GtkTextBuffer") + (c-name "gtk_text_buffer_end_user_action") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextchild.h + +(define-function gtk_text_child_anchor_get_type + (c-name "gtk_text_child_anchor_get_type") + (return-type "GType") +) + +(define-function gtk_text_child_anchor_new + (c-name "gtk_text_child_anchor_new") + (is-constructor-of GtkTextChildAnchor) + (return-type "GtkTextChildAnchor*") +) + +(define-method get_widgets + (of-object "GtkTextChildAnchor") + (c-name "gtk_text_child_anchor_get_widgets") + (return-type "GList*") +) + +(define-method get_deleted + (of-object "GtkTextChildAnchor") + (c-name "gtk_text_child_anchor_get_deleted") + (return-type "gboolean") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextdisplay.h + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextiter.h + +(define-method get_buffer + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_buffer") + (return-type "GtkTextBuffer*") +) + +(define-method copy + (of-object "GtkTextIter") + (c-name "gtk_text_iter_copy") + (return-type "GtkTextIter*") +) + +(define-method free + (of-object "GtkTextIter") + (c-name "gtk_text_iter_free") + (return-type "none") +) + +(define-method get_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_offset") + (return-type "gint") +) + +(define-method get_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_line") + (return-type "gint") +) + +(define-method get_line_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_line_offset") + (return-type "gint") +) + +(define-method get_line_index + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_line_index") + (return-type "gint") +) + +(define-method get_visible_line_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_visible_line_offset") + (return-type "gint") +) + +(define-method get_visible_line_index + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_visible_line_index") + (return-type "gint") +) + +(define-method get_char + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_char") + (return-type "gunichar") +) + +(define-method get_slice + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_slice") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "end") + ) +) + +(define-method get_text + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_text") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "end") + ) +) + +(define-method get_visible_slice + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_visible_slice") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "end") + ) +) + +(define-method get_visible_text + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_visible_text") + (return-type "gchar*") + (parameters + '("const-GtkTextIter*" "end") + ) +) + +(define-method get_pixbuf + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_pixbuf") + (return-type "GdkPixbuf*") +) + +(define-method get_marks + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_marks") + (return-type "GSList*") +) + +(define-method get_child_anchor + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_child_anchor") + (return-type "GtkTextChildAnchor*") +) + +(define-method get_toggled_tags + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_toggled_tags") + (return-type "GSList*") + (parameters + '("gboolean" "toggled_on") + ) +) + +(define-method begins_tag + (of-object "GtkTextIter") + (c-name "gtk_text_iter_begins_tag") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method ends_tag + (of-object "GtkTextIter") + (c-name "gtk_text_iter_ends_tag") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method toggles_tag + (of-object "GtkTextIter") + (c-name "gtk_text_iter_toggles_tag") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method has_tag + (of-object "GtkTextIter") + (c-name "gtk_text_iter_has_tag") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method get_tags + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_tags") + (return-type "GSList*") +) + +(define-method editable + (of-object "GtkTextIter") + (c-name "gtk_text_iter_editable") + (return-type "gboolean") + (parameters + '("gboolean" "default_setting") + ) +) + +(define-method starts_word + (of-object "GtkTextIter") + (c-name "gtk_text_iter_starts_word") + (return-type "gboolean") +) + +(define-method ends_word + (of-object "GtkTextIter") + (c-name "gtk_text_iter_ends_word") + (return-type "gboolean") +) + +(define-method inside_word + (of-object "GtkTextIter") + (c-name "gtk_text_iter_inside_word") + (return-type "gboolean") +) + +(define-method starts_sentence + (of-object "GtkTextIter") + (c-name "gtk_text_iter_starts_sentence") + (return-type "gboolean") +) + +(define-method ends_sentence + (of-object "GtkTextIter") + (c-name "gtk_text_iter_ends_sentence") + (return-type "gboolean") +) + +(define-method inside_sentence + (of-object "GtkTextIter") + (c-name "gtk_text_iter_inside_sentence") + (return-type "gboolean") +) + +(define-method starts_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_starts_line") + (return-type "gboolean") +) + +(define-method ends_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_ends_line") + (return-type "gboolean") +) + +(define-method is_cursor_position + (of-object "GtkTextIter") + (c-name "gtk_text_iter_is_cursor_position") + (return-type "gboolean") +) + +(define-method get_chars_in_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_chars_in_line") + (return-type "gint") +) + +(define-method get_bytes_in_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_bytes_in_line") + (return-type "gint") +) + +(define-method get_attributes + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_attributes") + (return-type "gboolean") + (parameters + '("GtkTextAttributes*" "values") + ) +) + +(define-method get_language + (of-object "GtkTextIter") + (c-name "gtk_text_iter_get_language") + (return-type "PangoLanguage*") +) + +(define-method is_end + (of-object "GtkTextIter") + (c-name "gtk_text_iter_is_end") + (return-type "gboolean") +) + +(define-method is_start + (of-object "GtkTextIter") + (c-name "gtk_text_iter_is_start") + (return-type "gboolean") +) + +(define-method forward_char + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_char") + (return-type "gboolean") +) + +(define-method backward_char + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_char") + (return-type "gboolean") +) + +(define-method forward_chars + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_chars") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method backward_chars + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_chars") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method forward_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_line") + (return-type "gboolean") +) + +(define-method backward_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_line") + (return-type "gboolean") +) + +(define-method forward_lines + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_lines") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method backward_lines + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_lines") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method forward_word_end + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_word_end") + (return-type "gboolean") +) + +(define-method backward_word_start + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_word_start") + (return-type "gboolean") +) + +(define-method forward_word_ends + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_word_ends") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method backward_word_starts + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_word_starts") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method forward_sentence_end + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_sentence_end") + (return-type "gboolean") +) + +(define-method backward_sentence_start + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_sentence_start") + (return-type "gboolean") +) + +(define-method forward_sentence_ends + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_sentence_ends") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method backward_sentence_starts + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_sentence_starts") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method forward_cursor_position + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_cursor_position") + (return-type "gboolean") +) + +(define-method backward_cursor_position + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_cursor_position") + (return-type "gboolean") +) + +(define-method forward_cursor_positions + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_cursor_positions") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method backward_cursor_positions + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_cursor_positions") + (return-type "gboolean") + (parameters + '("gint" "count") + ) +) + +(define-method set_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_offset") + (return-type "none") + (parameters + '("gint" "char_offset") + ) +) + +(define-method set_line + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_line") + (return-type "none") + (parameters + '("gint" "line_number") + ) +) + +(define-method set_line_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_line_offset") + (return-type "none") + (parameters + '("gint" "char_on_line") + ) +) + +(define-method set_line_index + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_line_index") + (return-type "none") + (parameters + '("gint" "byte_on_line") + ) +) + +(define-method forward_to_end + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_to_end") + (return-type "none") +) + +(define-method forward_to_line_end + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_to_line_end") + (return-type "gboolean") +) + +(define-method set_visible_line_offset + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_visible_line_offset") + (return-type "none") + (parameters + '("gint" "char_on_line") + ) +) + +(define-method set_visible_line_index + (of-object "GtkTextIter") + (c-name "gtk_text_iter_set_visible_line_index") + (return-type "none") + (parameters + '("gint" "byte_on_line") + ) +) + +(define-method forward_to_tag_toggle + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_to_tag_toggle") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag" (null-ok)) + ) +) + +(define-method backward_to_tag_toggle + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_to_tag_toggle") + (return-type "gboolean") + (parameters + '("GtkTextTag*" "tag" (null-ok)) + ) +) + +(define-method forward_find_char + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_find_char") + (return-type "gboolean") + (parameters + '("GtkTextCharPredicate" "pred") + '("gpointer" "user_data") + '("const-GtkTextIter*" "limit") + ) +) + +(define-method backward_find_char + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_find_char") + (return-type "gboolean") + (parameters + '("GtkTextCharPredicate" "pred") + '("gpointer" "user_data") + '("const-GtkTextIter*" "limit") + ) +) + +(define-method forward_search + (of-object "GtkTextIter") + (c-name "gtk_text_iter_forward_search") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + '("gboolean" "visible_only") + '("gboolean" "slice") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + '("const-GtkTextIter*" "limit" (null-ok)) + ) +) + +(define-method backward_search + (of-object "GtkTextIter") + (c-name "gtk_text_iter_backward_search") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + '("gboolean" "visible_only") + '("gboolean" "slice") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + '("const-GtkTextIter*" "limit" (null-ok)) + ) +) + +(define-method equal + (of-object "GtkTextIter") + (c-name "gtk_text_iter_equal") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "rhs") + ) +) + +(define-method compare + (of-object "GtkTextIter") + (c-name "gtk_text_iter_compare") + (return-type "gint") + (parameters + '("const-GtkTextIter*" "rhs") + ) +) + +(define-method in_range + (of-object "GtkTextIter") + (c-name "gtk_text_iter_in_range") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + ) +) + +(define-method order + (of-object "GtkTextIter") + (c-name "gtk_text_iter_order") + (return-type "none") + (parameters + '("GtkTextIter*" "second") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextmark.h + +(define-function gtk_text_mark_get_type + (c-name "gtk_text_mark_get_type") + (return-type "GType") +) + +(define-method set_visible + (of-object "GtkTextMark") + (c-name "gtk_text_mark_set_visible") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_visible + (of-object "GtkTextMark") + (c-name "gtk_text_mark_get_visible") + (return-type "gboolean") +) + +(define-method get_name + (of-object "GtkTextMark") + (c-name "gtk_text_mark_get_name") + (return-type "const-gchar*") +) + +(define-method get_deleted + (of-object "GtkTextMark") + (c-name "gtk_text_mark_get_deleted") + (return-type "gboolean") +) + +(define-method get_buffer + (of-object "GtkTextMark") + (c-name "gtk_text_mark_get_buffer") + (return-type "GtkTextBuffer*") +) + +(define-method get_left_gravity + (of-object "GtkTextMark") + (c-name "gtk_text_mark_get_left_gravity") + (return-type "gboolean") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktexttag.h + +(define-function gtk_text_tag_get_type + (c-name "gtk_text_tag_get_type") + (return-type "GtkType") +) + +(define-function gtk_text_tag_new + (c-name "gtk_text_tag_new") + (is-constructor-of GtkTextTag) + (return-type "GtkTextTag*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_priority + (of-object "GtkTextTag") + (c-name "gtk_text_tag_get_priority") + (return-type "gint") +) + +(define-method set_priority + (of-object "GtkTextTag") + (c-name "gtk_text_tag_set_priority") + (return-type "none") + (parameters + '("gint" "priority") + ) +) + +(define-method event + (of-object "GtkTextTag") + (c-name "gtk_text_tag_event") + (return-type "gint") + (parameters + '("GObject*" "event_object") + '("GdkEvent*" "event") + '("const-GtkTextIter*" "iter") + ) +) + +(define-function gtk_text_attributes_new + (c-name "gtk_text_attributes_new") + (is-constructor-of GtkTextAttributes) + (return-type "GtkTextAttributes*") +) + +(define-method copy + (of-object "GtkTextAttributes") + (c-name "gtk_text_attributes_copy") + (return-type "none") + (parameters + '("GtkTextAttributes*" "dest") + ) +) + +(define-method copy_values + (of-object "GtkTextAttributes") + (c-name "gtk_text_attributes_copy_values") + (return-type "none") + (parameters + '("GtkTextAttributes*" "dest") + ) +) + +(define-method unref + (of-object "GtkTextAttributes") + (c-name "gtk_text_attributes_unref") + (return-type "none") +) + +(define-method ref + (of-object "GtkTextAttributes") + (c-name "gtk_text_attributes_ref") + (return-type "none") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktexttagtable.h + +(define-function gtk_text_tag_table_get_type + (c-name "gtk_text_tag_table_get_type") + (return-type "GtkType") +) + +(define-function gtk_text_tag_table_new + (c-name "gtk_text_tag_table_new") + (is-constructor-of GtkTextTagTable) + (return-type "GtkTextTagTable*") +) + +(define-method add + (of-object "GtkTextTagTable") + (c-name "gtk_text_tag_table_add") + (return-type "none") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method remove + (of-object "GtkTextTagTable") + (c-name "gtk_text_tag_table_remove") + (return-type "none") + (parameters + '("GtkTextTag*" "tag") + ) +) + +(define-method lookup + (of-object "GtkTextTagTable") + (c-name "gtk_text_tag_table_lookup") + (return-type "GtkTextTag*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method foreach + (of-object "GtkTextTagTable") + (c-name "gtk_text_tag_table_foreach") + (return-type "none") + (parameters + '("GtkTextTagTableForeach" "func") + '("gpointer" "data") + ) +) + +(define-method get_size + (of-object "GtkTextTagTable") + (c-name "gtk_text_tag_table_get_size") + (return-type "guint") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktextview.h + +(define-function gtk_text_view_get_type + (c-name "gtk_text_view_get_type") + (return-type "GtkType") +) + +(define-function gtk_text_view_new + (c-name "gtk_text_view_new") + (is-constructor-of GtkTextView) + (return-type "GtkWidget*") +) + +(define-function gtk_text_view_new_with_buffer + (c-name "gtk_text_view_new_with_buffer") + (is-constructor-of GtkTextView) + (return-type "GtkWidget*") + (parameters + '("GtkTextBuffer*" "buffer") + ) +) + +(define-method set_buffer + (of-object "GtkTextView") + (c-name "gtk_text_view_set_buffer") + (return-type "none") + (parameters + '("GtkTextBuffer*" "buffer") + ) +) + +(define-method get_buffer + (of-object "GtkTextView") + (c-name "gtk_text_view_get_buffer") + (return-type "GtkTextBuffer*") +) + +(define-method scroll_to_iter + (of-object "GtkTextView") + (c-name "gtk_text_view_scroll_to_iter") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("gdouble" "within_margin") + '("gboolean" "use_align" (default "FALSE")) + '("gdouble" "xalign" (default "0.5")) + '("gdouble" "yalign" (default "0.5")) + ) +) + +(define-method scroll_to_mark + (of-object "GtkTextView") + (c-name "gtk_text_view_scroll_to_mark") + (return-type "none") + (parameters + '("GtkTextMark*" "mark") + '("gdouble" "within_margin") + '("gboolean" "use_align" (default "FALSE")) + '("gdouble" "xalign" (default "0.5")) + '("gdouble" "yalign" (default "0.5")) + ) +) + +(define-method scroll_mark_onscreen + (of-object "GtkTextView") + (c-name "gtk_text_view_scroll_mark_onscreen") + (return-type "none") + (parameters + '("GtkTextMark*" "mark") + ) +) + +(define-method move_mark_onscreen + (of-object "GtkTextView") + (c-name "gtk_text_view_move_mark_onscreen") + (return-type "gboolean") + (parameters + '("GtkTextMark*" "mark") + ) +) + +(define-method place_cursor_onscreen + (of-object "GtkTextView") + (c-name "gtk_text_view_place_cursor_onscreen") + (return-type "gboolean") +) + +(define-method get_visible_rect + (of-object "GtkTextView") + (c-name "gtk_text_view_get_visible_rect") + (return-type "none") + (parameters + '("GdkRectangle*" "visible_rect") + ) +) + +(define-method set_cursor_visible + (of-object "GtkTextView") + (c-name "gtk_text_view_set_cursor_visible") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_cursor_visible + (of-object "GtkTextView") + (c-name "gtk_text_view_get_cursor_visible") + (return-type "gboolean") +) + +(define-method get_iter_location + (of-object "GtkTextView") + (c-name "gtk_text_view_get_iter_location") + (return-type "none") + (parameters + '("const-GtkTextIter*" "iter") + '("GdkRectangle*" "location") + ) +) + +(define-method get_iter_at_location + (of-object "GtkTextView") + (c-name "gtk_text_view_get_iter_at_location") + (return-type "none") + (parameters + '("GtkTextIter*" "iter") + '("gint" "x") + '("gint" "y") + ) +) + +(define-method get_line_yrange + (of-object "GtkTextView") + (c-name "gtk_text_view_get_line_yrange") + (return-type "none") + (parameters + '("const-GtkTextIter*" "iter") + '("gint*" "y") + '("gint*" "height") + ) +) + +(define-method get_line_at_y + (of-object "GtkTextView") + (c-name "gtk_text_view_get_line_at_y") + (return-type "none") + (parameters + '("GtkTextIter*" "target_iter") + '("gint" "y") + '("gint*" "line_top") + ) +) + +(define-method buffer_to_window_coords + (of-object "GtkTextView") + (c-name "gtk_text_view_buffer_to_window_coords") + (return-type "none") + (parameters + '("GtkTextWindowType" "win") + '("gint" "buffer_x") + '("gint" "buffer_y") + '("gint*" "window_x") + '("gint*" "window_y") + ) +) + +(define-method window_to_buffer_coords + (of-object "GtkTextView") + (c-name "gtk_text_view_window_to_buffer_coords") + (return-type "none") + (parameters + '("GtkTextWindowType" "win") + '("gint" "window_x") + '("gint" "window_y") + '("gint*" "buffer_x") + '("gint*" "buffer_y") + ) +) + +(define-method get_window + (of-object "GtkTextView") + (c-name "gtk_text_view_get_window") + (return-type "GdkWindow*") + (parameters + '("GtkTextWindowType" "win") + ) +) + +(define-method get_window_type + (of-object "GtkTextView") + (c-name "gtk_text_view_get_window_type") + (return-type "GtkTextWindowType") + (parameters + '("GdkWindow*" "window") + ) +) + +(define-method set_border_window_size + (of-object "GtkTextView") + (c-name "gtk_text_view_set_border_window_size") + (return-type "none") + (parameters + '("GtkTextWindowType" "type") + '("gint" "size") + ) +) + +(define-method forward_display_line + (of-object "GtkTextView") + (c-name "gtk_text_view_forward_display_line") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method backward_display_line + (of-object "GtkTextView") + (c-name "gtk_text_view_backward_display_line") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method forward_display_line_end + (of-object "GtkTextView") + (c-name "gtk_text_view_forward_display_line_end") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method backward_display_line_start + (of-object "GtkTextView") + (c-name "gtk_text_view_backward_display_line_start") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + ) +) + +(define-method starts_display_line + (of-object "GtkTextView") + (c-name "gtk_text_view_starts_display_line") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "iter") + ) +) + +(define-method move_visually + (of-object "GtkTextView") + (c-name "gtk_text_view_move_visually") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("gint" "count") + ) +) + +(define-method add_child_at_anchor + (of-object "GtkTextView") + (c-name "gtk_text_view_add_child_at_anchor") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkTextChildAnchor*" "anchor") + ) +) + +(define-method add_child_in_window + (of-object "GtkTextView") + (c-name "gtk_text_view_add_child_in_window") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("GtkTextWindowType" "which_window") + '("gint" "xpos") + '("gint" "ypos") + ) +) + +(define-method move_child + (of-object "GtkTextView") + (c-name "gtk_text_view_move_child") + (return-type "none") + (parameters + '("GtkWidget*" "child") + '("gint" "xpos") + '("gint" "ypos") + ) +) + +(define-method set_wrap_mode + (of-object "GtkTextView") + (c-name "gtk_text_view_set_wrap_mode") + (return-type "none") + (parameters + '("GtkWrapMode" "wrap_mode") + ) +) + +(define-method get_wrap_mode + (of-object "GtkTextView") + (c-name "gtk_text_view_get_wrap_mode") + (return-type "GtkWrapMode") +) + +(define-method set_editable + (of-object "GtkTextView") + (c-name "gtk_text_view_set_editable") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_editable + (of-object "GtkTextView") + (c-name "gtk_text_view_get_editable") + (return-type "gboolean") +) + +(define-method set_pixels_above_lines + (of-object "GtkTextView") + (c-name "gtk_text_view_set_pixels_above_lines") + (return-type "none") + (parameters + '("gint" "pixels_above_lines") + ) +) + +(define-method get_pixels_above_lines + (of-object "GtkTextView") + (c-name "gtk_text_view_get_pixels_above_lines") + (return-type "gint") +) + +(define-method set_pixels_below_lines + (of-object "GtkTextView") + (c-name "gtk_text_view_set_pixels_below_lines") + (return-type "none") + (parameters + '("gint" "pixels_below_lines") + ) +) + +(define-method get_pixels_below_lines + (of-object "GtkTextView") + (c-name "gtk_text_view_get_pixels_below_lines") + (return-type "gint") +) + +(define-method set_pixels_inside_wrap + (of-object "GtkTextView") + (c-name "gtk_text_view_set_pixels_inside_wrap") + (return-type "none") + (parameters + '("gint" "pixels_inside_wrap") + ) +) + +(define-method get_pixels_inside_wrap + (of-object "GtkTextView") + (c-name "gtk_text_view_get_pixels_inside_wrap") + (return-type "gint") +) + +(define-method set_justification + (of-object "GtkTextView") + (c-name "gtk_text_view_set_justification") + (return-type "none") + (parameters + '("GtkJustification" "justification") + ) +) + +(define-method get_justification + (of-object "GtkTextView") + (c-name "gtk_text_view_get_justification") + (return-type "GtkJustification") +) + +(define-method set_left_margin + (of-object "GtkTextView") + (c-name "gtk_text_view_set_left_margin") + (return-type "none") + (parameters + '("gint" "left_margin") + ) +) + +(define-method get_left_margin + (of-object "GtkTextView") + (c-name "gtk_text_view_get_left_margin") + (return-type "gint") +) + +(define-method set_right_margin + (of-object "GtkTextView") + (c-name "gtk_text_view_set_right_margin") + (return-type "none") + (parameters + '("gint" "right_margin") + ) +) + +(define-method get_right_margin + (of-object "GtkTextView") + (c-name "gtk_text_view_get_right_margin") + (return-type "gint") +) + +(define-method set_indent + (of-object "GtkTextView") + (c-name "gtk_text_view_set_indent") + (return-type "none") + (parameters + '("gint" "indent") + ) +) + +(define-method get_indent + (of-object "GtkTextView") + (c-name "gtk_text_view_get_indent") + (return-type "gint") +) + +(define-method set_tabs + (of-object "GtkTextView") + (c-name "gtk_text_view_set_tabs") + (return-type "none") + (parameters + '("PangoTabArray*" "tabs") + ) +) + +(define-method get_tabs + (of-object "GtkTextView") + (c-name "gtk_text_view_get_tabs") + (return-type "PangoTabArray*") +) + +(define-method get_default_attributes + (of-object "GtkTextView") + (c-name "gtk_text_view_get_default_attributes") + (return-type "GtkTextAttributes*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktipsquery.h + +(define-function gtk_tips_query_get_type + (c-name "gtk_tips_query_get_type") + (return-type "GtkType") +) + +(define-function gtk_tips_query_new + (c-name "gtk_tips_query_new") + (is-constructor-of GtkTipsQuery) + (return-type "GtkWidget*") +) + +(define-method start_query + (of-object "GtkTipsQuery") + (c-name "gtk_tips_query_start_query") + (return-type "none") +) + +(define-method stop_query + (of-object "GtkTipsQuery") + (c-name "gtk_tips_query_stop_query") + (return-type "none") +) + +(define-method set_caller + (of-object "GtkTipsQuery") + (c-name "gtk_tips_query_set_caller") + (return-type "none") + (parameters + '("GtkWidget*" "caller") + ) +) + +(define-method set_labels + (of-object "GtkTipsQuery") + (c-name "gtk_tips_query_set_labels") + (return-type "none") + (parameters + '("const-gchar*" "label_inactive") + '("const-gchar*" "label_no_tip") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktogglebutton.h + +(define-function gtk_toggle_button_get_type + (c-name "gtk_toggle_button_get_type") + (return-type "GtkType") +) + +(define-function gtk_toggle_button_new + (c-name "gtk_toggle_button_new") + (is-constructor-of GtkToggleButton) + (return-type "GtkWidget*") +) + +(define-function gtk_toggle_button_new_with_label + (c-name "gtk_toggle_button_new_with_label") + (is-constructor-of GtkToggleButton) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-function gtk_toggle_button_new_with_mnemonic + (c-name "gtk_toggle_button_new_with_mnemonic") + (is-constructor-of GtkToggleButton) + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "label") + ) +) + +(define-method get_mode + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_get_mode") + (return-type "gboolean") +) + +(define-method set_mode + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_set_mode") + (return-type "none") + (parameters + '("gboolean" "draw_indicator") + ) +) + +(define-method set_active + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_set_active") + (return-type "none") + (parameters + '("gboolean" "is_active") + ) +) + +(define-method get_active + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_get_active") + (return-type "gboolean") +) + +(define-method toggled + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_toggled") + (return-type "none") +) + +(define-method set_inconsistent + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_set_inconsistent") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_inconsistent + (of-object "GtkToggleButton") + (c-name "gtk_toggle_button_get_inconsistent") + (return-type "gboolean") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktoolbar.h + +(define-function gtk_toolbar_get_type + (c-name "gtk_toolbar_get_type") + (return-type "GtkType") +) + +(define-function gtk_toolbar_new + (c-name "gtk_toolbar_new") + (is-constructor-of GtkToolbar) + (return-type "GtkWidget*") +) + +(define-method append_item + (of-object "GtkToolbar") + (c-name "gtk_toolbar_append_item") + (return-type "GtkWidget*") + (parameters + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data" (null-ok) (default "NULL")) + ) +) + +(define-method prepend_item + (of-object "GtkToolbar") + (c-name "gtk_toolbar_prepend_item") + (return-type "GtkWidget*") + (parameters + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + ) +) + +(define-method insert_item + (of-object "GtkToolbar") + (c-name "gtk_toolbar_insert_item") + (return-type "GtkWidget*") + (parameters + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + '("gint" "position") + ) +) + +(define-method insert_stock + (of-object "GtkToolbar") + (c-name "gtk_toolbar_insert_stock") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "stock_id") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + '("gint" "position") + ) +) + +(define-method append_space + (of-object "GtkToolbar") + (c-name "gtk_toolbar_append_space") + (return-type "none") +) + +(define-method prepend_space + (of-object "GtkToolbar") + (c-name "gtk_toolbar_prepend_space") + (return-type "none") +) + +(define-method insert_space + (of-object "GtkToolbar") + (c-name "gtk_toolbar_insert_space") + (return-type "none") + (parameters + '("gint" "position") + ) +) + +(define-method remove_space + (of-object "GtkToolbar") + (c-name "gtk_toolbar_remove_space") + (return-type "none") + (parameters + '("gint" "position") + ) +) + +(define-method append_element + (of-object "GtkToolbar") + (c-name "gtk_toolbar_append_element") + (return-type "GtkWidget*") + (parameters + '("GtkToolbarChildType" "type") + '("GtkWidget*" "widget") + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + ) +) + +(define-method prepend_element + (of-object "GtkToolbar") + (c-name "gtk_toolbar_prepend_element") + (return-type "GtkWidget*") + (parameters + '("GtkToolbarChildType" "type") + '("GtkWidget*" "widget") + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + ) +) + +(define-method insert_element + (of-object "GtkToolbar") + (c-name "gtk_toolbar_insert_element") + (return-type "GtkWidget*") + (parameters + '("GtkToolbarChildType" "type") + '("GtkWidget*" "widget") + '("const-char*" "text") + '("const-char*" "tooltip_text") + '("const-char*" "tooltip_private_text") + '("GtkWidget*" "icon") + '("GtkSignalFunc" "callback") + '("gpointer" "user_data") + '("gint" "position") + ) +) + +(define-method append_widget + (of-object "GtkToolbar") + (c-name "gtk_toolbar_append_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("const-char*" "tooltip_text" (null-ok)) + '("const-char*" "tooltip_private_text" (null-ok)) + ) +) + +(define-method prepend_widget + (of-object "GtkToolbar") + (c-name "gtk_toolbar_prepend_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("const-char*" "tooltip_text" (null-ok)) + '("const-char*" "tooltip_private_text" (null-ok)) + ) +) + +(define-method insert_widget + (of-object "GtkToolbar") + (c-name "gtk_toolbar_insert_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("const-char*" "tooltip_text" (null-ok)) + '("const-char*" "tooltip_private_text" (null-ok)) + '("gint" "position") + ) +) + +(define-method set_orientation + (of-object "GtkToolbar") + (c-name "gtk_toolbar_set_orientation") + (return-type "none") + (parameters + '("GtkOrientation" "orientation") + ) +) + +(define-method set_style + (of-object "GtkToolbar") + (c-name "gtk_toolbar_set_style") + (return-type "none") + (parameters + '("GtkToolbarStyle" "style") + ) +) + +(define-method set_icon_size + (of-object "GtkToolbar") + (c-name "gtk_toolbar_set_icon_size") + (return-type "none") + (parameters + '("GtkIconSize" "icon_size") + ) +) + +(define-method set_tooltips + (of-object "GtkToolbar") + (c-name "gtk_toolbar_set_tooltips") + (return-type "none") + (parameters + '("gint" "enable") + ) +) + +(define-method unset_style + (of-object "GtkToolbar") + (c-name "gtk_toolbar_unset_style") + (return-type "none") +) + +(define-method unset_icon_size + (of-object "GtkToolbar") + (c-name "gtk_toolbar_unset_icon_size") + (return-type "none") +) + +(define-method get_orientantion + (of-object "GtkToolbar") + (c-name "gtk_toolbar_get_orientation") + (return-type "GtkOrientation") +) + +(define-method get_style + (of-object "GtkToolbar") + (c-name "gtk_toolbar_get_style") + (return-type "GtkToolbarStyle") +) + +(define-method get_icon_size + (of-object "GtkToolbar") + (c-name "gtk_toolbar_get_icon_size") + (return-type "GtkIconSize") +) + +(define-method get_tooltips + (of-object "GtkToolbar") + (c-name "gtk_toolbar_get_tooltips") + (return-type "gboolean") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktooltips.h + +(define-function gtk_tooltips_get_type + (c-name "gtk_tooltips_get_type") + (return-type "GtkType") +) + +(define-function gtk_tooltips_new + (c-name "gtk_tooltips_new") + (is-constructor-of GtkTooltips) + (return-type "GtkTooltips*") +) + +(define-method enable + (of-object "GtkTooltips") + (c-name "gtk_tooltips_enable") + (return-type "none") +) + +(define-method disable + (of-object "GtkTooltips") + (c-name "gtk_tooltips_disable") + (return-type "none") +) + +(define-method set_delay + (of-object "GtkTooltips") + (c-name "gtk_tooltips_set_delay") + (return-type "none") + (parameters + '("guint" "delay") + ) +) + +(define-method set_tip + (of-object "GtkTooltips") + (c-name "gtk_tooltips_set_tip") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("const-gchar*" "tip_text") + '("const-gchar*" "tip_private") + ) +) + +(define-function gtk_tooltips_data_get + (c-name "gtk_tooltips_data_get") + (return-type "GtkTooltipsData*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method force_window + (of-object "GtkTooltips") + (c-name "gtk_tooltips_force_window") + (return-type "none") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreednd.h + +(define-function gtk_tree_drag_source_get_type + (c-name "gtk_tree_drag_source_get_type") + (return-type "GType") +) + +(define-method drag_data_delete + (of-object "GtkTreeDragSource") + (c-name "gtk_tree_drag_source_drag_data_delete") + (return-type "gboolean") + (parameters + '("GtkTreePath*" "path") + ) +) + +(define-method drag_data_get + (of-object "GtkTreeDragSource") + (c-name "gtk_tree_drag_source_drag_data_get") + (return-type "gboolean") + (parameters + '("GtkTreePath*" "path") + '("GtkSelectionData*" "selection_data") + ) +) + +(define-function gtk_tree_drag_dest_get_type + (c-name "gtk_tree_drag_dest_get_type") + (return-type "GType") +) + +(define-method drag_data_received + (of-object "GtkTreeDragDest") + (c-name "gtk_tree_drag_dest_drag_data_received") + (return-type "gboolean") + (parameters + '("GtkTreePath*" "dest") + '("GtkSelectionData*" "selection_data") + ) +) + +(define-method row_drop_possible + (of-object "GtkTreeDragDest") + (c-name "gtk_tree_drag_dest_row_drop_possible") + (return-type "gboolean") + (parameters + '("GtkTreeModel*" "src_model") + '("GtkTreePath*" "src_path") + '("GtkTreePath*" "dest_path") + ) +) + +(define-method set_tree_row + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_set_tree_row") + (return-type "gboolean") + (parameters + '("GtkTreeModel*" "tree_model") + '("GtkTreePath*" "path") + ) +) + +(define-method get_tree_row + (of-object "GtkSelectionData") + (c-name "gtk_selection_data_get_tree_row") + (return-type "gboolean") + (parameters + '("GtkTreeModel**" "tree_model") + '("GtkTreePath**" "path") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreemodel.h + +(define-function gtk_tree_model_get_type + (c-name "gtk_tree_model_get_type") + (return-type "GtkType") +) + +(define-function gtk_tree_path_new + (c-name "gtk_tree_path_new") + (return-type "GtkTreePath*") +) + +(define-function gtk_tree_path_new_from_string + (c-name "gtk_tree_path_new_from_string") + (return-type "GtkTreePath*") + (parameters + '("gchar*" "path") + ) +) + +(define-method to_string + (of-object "GtkTreePath") + (c-name "gtk_tree_path_to_string") + (return-type "gchar*") +) + +(define-function gtk_tree_path_new_root + (c-name "gtk_tree_path_new_root") + (return-type "GtkTreePath*") +) + +(define-method append_index + (of-object "GtkTreePath") + (c-name "gtk_tree_path_append_index") + (return-type "none") + (parameters + '("gint" "index") + ) +) + +(define-method prepend_index + (of-object "GtkTreePath") + (c-name "gtk_tree_path_prepend_index") + (return-type "none") + (parameters + '("gint" "index") + ) +) + +(define-method get_depth + (of-object "GtkTreePath") + (c-name "gtk_tree_path_get_depth") + (return-type "gint") +) + +(define-method get_indices + (of-object "GtkTreePath") + (c-name "gtk_tree_path_get_indices") + (return-type "gint*") +) + +(define-method free + (of-object "GtkTreePath") + (c-name "gtk_tree_path_free") + (return-type "none") +) + +(define-method copy + (of-object "GtkTreePath") + (c-name "gtk_tree_path_copy") + (return-type "GtkTreePath*") +) + +(define-method compare + (of-object "GtkTreePath") + (c-name "gtk_tree_path_compare") + (return-type "gint") + (parameters + '("const-GtkTreePath*" "b") + ) +) + +(define-method next + (of-object "GtkTreePath") + (c-name "gtk_tree_path_next") + (return-type "none") +) + +(define-method prev + (of-object "GtkTreePath") + (c-name "gtk_tree_path_prev") + (return-type "gint") +) + +(define-method up + (of-object "GtkTreePath") + (c-name "gtk_tree_path_up") + (return-type "gint") +) + +(define-method down + (of-object "GtkTreePath") + (c-name "gtk_tree_path_down") + (return-type "none") +) + +(define-method is_ancestor + (of-object "GtkTreePath") + (c-name "gtk_tree_path_is_ancestor") + (return-type "gboolean") + (parameters + '("GtkTreePath*" "descendant") + ) +) + +(define-method is_descendant + (of-object "GtkTreePath") + (c-name "gtk_tree_path_is_descendant") + (return-type "gboolean") + (parameters + '("GtkTreePath*" "ancestor") + ) +) + +(define-function gtk_tree_row_reference_new + (c-name "gtk_tree_row_reference_new") + (is-constructor-of GtkTreeRowReference) + (return-type "GtkTreeRowReference*") + (parameters + '("GtkTreeModel*" "model") + '("GtkTreePath*" "path") + ) +) + +(define-function gtk_tree_row_reference_new_proxy + (c-name "gtk_tree_row_reference_new_proxy") + (is-constructor-of GtkTreeRowReference) + (return-type "GtkTreeRowReference*") + (parameters + '("GObject*" "proxy") + '("GtkTreeModel*" "model") + '("GtkTreePath*" "path") + ) +) + +(define-method get_path + (of-object "GtkTreeRowReference") + (c-name "gtk_tree_row_reference_get_path") + (return-type "GtkTreePath*") +) + +(define-method free + (of-object "GtkTreeRowReference") + (c-name "gtk_tree_row_reference_free") + (return-type "none") +) + +(define-function tree_row_reference_inserted + (c-name "gtk_tree_row_reference_inserted") + (return-type "none") + (parameters + '("GObject*" "proxy") + '("GtkTreePath*" "path") + ) +) + +(define-function tree_row_reference_deleted + (c-name "gtk_tree_row_reference_deleted") + (return-type "none") + (parameters + '("GObject*" "proxy") + '("GtkTreePath*" "path") + ) +) + +(define-function gtk_tree_row_reference_reordered + (c-name "gtk_tree_row_reference_reordered") + (return-type "none") + (parameters + '("GObject*" "proxy") + '("GtkTreePath*" "path") + '("GtkTreeIter*" "iter") + '("gint*" "new_order") + ) +) + +(define-function gtk_tree_model_get_type + (c-name "gtk_tree_model_get_type") + (return-type "GtkType") +) + +(define-method get_flags + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_flags") + (return-type "GtkTreeModelFlags") +) + +(define-method get_n_columns + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_n_columns") + (return-type "gint") +) + +(define-method get_column_type + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_column_type") + (return-type "GType") + (parameters + '("gint" "index") + ) +) + +(define-method get_iter + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_iter") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreePath*" "path") + ) +) + +(define-method get_iter_root + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_iter_root") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method get_path + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_path") + (return-type "GtkTreePath*") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method get_value + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_value") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("gint" "column") + '("GValue*" "value") + ) +) + +(define-method iter_next + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_next") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method iter_children + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_children") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + ) +) + +(define-method iter_has_child + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_has_child") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method iter_n_children + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_n_children") + (return-type "gint") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method iter_nth_child + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_nth_child") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + '("gint" "n") + ) +) + +(define-method iter_parent + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_iter_parent") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "child") + ) +) + +(define-method ref_node + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_ref_node") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method unref_node + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_unref_node") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method get + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) + (varargs #t) +) + +(define-method get_valist + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_get_valist") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("va_list" "var_args") + ) +) + +(define-method row_changed + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_row_changed") + (return-type "none") + (parameters + '("GtkTreePath*" "start_path") + '("GtkTreeIter*" "start_iter") + ) +) + +(define-method row_inserted + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_row_inserted") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeIter*" "iter") + ) +) + +(define-method row_has_child_toggled + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_row_has_child_toggled") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeIter*" "iter") + ) +) + +(define-method row_deleted + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_row_deleted") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + ) +) + +(define-method rows_reordered + (of-object "GtkTreeModel") + (c-name "gtk_tree_model_rows_reordered") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeIter*" "iter") + '("gint*" "new_order") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreemodelsort.h + +(define-function gtk_tree_model_sort_get_type + (c-name "gtk_tree_model_sort_get_type") + (return-type "GtkType") +) + +(define-function gtk_tree_model_sort_new + (c-name "gtk_tree_model_sort_new") + (is-constructor-of GtkTreeModel) + (return-type "GtkTreeModel*") +) + +(define-function gtk_tree_model_sort_new_with_model + (c-name "gtk_tree_model_sort_new_with_model") + (is-constructor-of GtkTreeModel) + (return-type "GtkTreeModel*") + (parameters + '("GValueCompareFunc" "func") + '("gint" "sort_col") + ) +) + +(define-method set_model + (of-object "GtkTreeModelSort") + (c-name "gtk_tree_model_sort_set_model") + (return-type "none") + (parameters + '("GtkTreeModel*" "child_model") + ) +) + +(define-method get_model + (of-object "GtkTreeModelSort") + (c-name "gtk_tree_model_sort_get_model") + (return-type "GtkTreeModel*") +) + +(define-method convert_path + (of-object "GtkTreeModelSort") + (c-name "gtk_tree_model_sort_convert_path") + (return-type "GtkTreePath*") + (parameters + '("GtkTreePath*" "child_path") + ) +) + +; (method convert_iter +; (of-object TreeModelSort (Gtk)) +; (c-name gtk_tree_model_sort_convert_iter) +; (return-type none) +; (parameter (type-and-name GtkTreeIter* sort_iter)) +; (parameter (type-and-name GtkTreeIter* child_iter)) +; ) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreeselection.h + +(define-function gtk_tree_selection_get_type + (c-name "gtk_tree_selection_get_type") + (return-type "GtkType") +) + +(define-method set_mode + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_set_mode") + (return-type "none") + (parameters + '("GtkSelectionMode" "type") + ) +) + +(define-method set_select_function + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_set_select_function") + (return-type "none") + (parameters + '("GtkSelectionFunc" "func") + '("gpointer" "data") + ) +) + +(define-method get_user_data + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_get_user_data") + (return-type "gpointer") +) + +(define-method get_selected + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_get_selected") + (return-type "gboolean") + (parameters + '("GtkTreeModel**" "model") + '("GtkTreeIter*" "iter") + ) +) + +(define-method selected_foreach + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_selected_foreach") + (return-type "none") + (parameters + '("GtkTreeSelectionForeachFunc" "func") + '("gpointer" "data") + ) +) + +(define-method select_path + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_select_path") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + ) +) + +(define-method unselect_path + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_unselect_path") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + ) +) + +(define-method select_iter + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_select_iter") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method unselect_iter + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_unselect_iter") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method select_all + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_select_all") + (return-type "none") +) + +(define-method unselect_all + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_unselect_all") + (return-type "none") +) + +(define-method select_range + (of-object "GtkTreeSelection") + (c-name "gtk_tree_selection_select_range") + (return-type "none") + (parameters + '("GtkTreePath*" "start_path") + '("GtkTreePath*" "end_path") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreesortable.h + +(define-function gtk_tree_sortable_get_type + (c-name "gtk_tree_sortable_get_type") + (return-type "GType") +) + +(define-method sort_column_changed + (of-object "GtkTreeSortable") + (c-name "gtk_tree_sortable_sort_column_changed") + (return-type "none") +) + +(define-method get_sort_column_id + (of-object "GtkTreeSortable") + (c-name "gtk_tree_sortable_get_sort_column_id") + (return-type "gboolean") + (parameters + '("gint*" "sort_column_id") + '("GtkSortType*" "order") + ) +) + +(define-method set_sort_column_id + (of-object "GtkTreeSortable") + (c-name "gtk_tree_sortable_set_sort_column_id") + (return-type "none") + (parameters + '("gint" "sort_column_id") + '("GtkSortType" "order") + ) +) + +(define-method sort_column_id_set_func + (of-object "GtkTreeSortable") + (c-name "gtk_tree_sortable_sort_column_id_set_func") + (return-type "none") + (parameters + '("gint" "sort_column_id") + '("GtkTreeIterCompareFunc" "func") + '("gpointer" "data") + '("GtkDestroyNotify" "destroy") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreestore.h + +(define-function gtk_tree_store_get_type + (c-name "gtk_tree_store_get_type") + (return-type "GtkType") +) + +(define-function gtk_tree_store_new + (c-name "gtk_tree_store_new") + (is-constructor-of GtkTreeStore) + (return-type "GtkTreeStore*") +) + +(define-method set_value + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_set_value") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("gint" "column") + '("GValue*" "value") + ) +) + +(define-method set + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_set") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_setv") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("va_list" "var_args") + ) +) + +(define-method remove + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_remove") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + ) +) + +(define-method insert + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_insert") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + '("gint" "position") + ) +) + +(define-method insert_before + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_insert_before") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + '("GtkTreeIter*" "sibling") + ) +) + +(define-method insert_after + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_insert_after") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + '("GtkTreeIter*" "sibling") + ) +) + +(define-method prepend + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_prepend") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + ) +) + +(define-method append + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_append") + (return-type "none") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "parent") + ) +) + +(define-method is_ancestor + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_is_ancestor") + (return-type "gboolean") + (parameters + '("GtkTreeIter*" "iter") + '("GtkTreeIter*" "descendant") + ) +) + +(define-method iter_depth + (of-object "GtkTreeStore") + (c-name "gtk_tree_store_iter_depth") + (return-type "gint") + (parameters + '("GtkTreeIter*" "iter") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreeview.h + +(define-function gtk_tree_view_get_type + (c-name "gtk_tree_view_get_type") + (return-type "GtkType") +) + +(define-function gtk_tree_view_new + (c-name "gtk_tree_view_new") + (is-constructor-of GtkTreeView) + (return-type "GtkWidget*") +) + +(define-function gtk_tree_view_new_with_model + (c-name "gtk_tree_view_new_with_model") + (is-constructor-of GtkTreeView) + (return-type "GtkWidget*") + (parameters + '("GtkTreeModel*" "model" (null-ok) (default "NULL")) + ) +) + +(define-method get_model + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_model") + (return-type "GtkTreeModel*") +) + +(define-method set_model + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_model") + (return-type "none") + (parameters + '("GtkTreeModel*" "model" (null-ok) (default "NULL")) + ) +) + +(define-method get_selection + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_selection") + (return-type "GtkTreeSelection*") +) + +(define-method get_hadjustment + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_hadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_hadjustment + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_vadjustment + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_vadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_vadjustment + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment") + ) +) + +(define-method get_headers_visible + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_headers_visible") + (return-type "gboolean") +) + +(define-method set_headers_visible + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_headers_visible") + (return-type "none") + (parameters + '("gboolean" "headers_visible") + ) +) + +(define-method columns_autosize + (of-object "GtkTreeView") + (c-name "gtk_tree_view_columns_autosize") + (return-type "none") +) + +(define-method set_headers_clickable + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_headers_clickable") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method set_rules_hint + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_rules_hint") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_rules_hint + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_rules_hint") + (return-type "gboolean") +) + +(define-method append_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_append_column") + (return-type "gint") + (parameters + '("GtkTreeViewColumn*" "column") + ) +) + +(define-method remove_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_remove_column") + (return-type "gint") + (parameters + '("GtkTreeViewColumn*" "column") + ) +) + +(define-method insert_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_insert_column") + (return-type "gint") + (parameters + '("GtkTreeViewColumn*" "column") + '("gint" "position") + ) +) + +(define-method insert_column_with_attributes + (of-object "GtkTreeView") + (c-name "gtk_tree_view_insert_column_with_attributes") + (return-type "gint") + (parameters + '("gint" "position") + '("gchar*" "title") + '("GtkCellRenderer*" "cell") + ) + (varargs #t) +) + +(define-method insert_column_with_data_func + (of-object "GtkTreeView") + (c-name "gtk_tree_view_insert_column_with_data_func") + (return-type "gint") + (parameters + '("gint" "position") + '("gchar*" "title") + '("GtkCellRenderer*" "cell") + '("GtkTreeCellDataFunc" "func") + '("gpointer" "data") + '("GDestroyNotify" "dnotify") + ) +) + +(define-method get_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_column") + (return-type "GtkTreeViewColumn*") + (parameters + '("gint" "n") + ) +) + +(define-method set_expander_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_expander_column") + (return-type "none") + (parameters + '("GtkTreeViewColumn*" "column") + ) +) + +(define-method get_expander_column + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_expander_column") + (return-type "GtkTreeViewColumn*") +) + +(define-method set_column_drag_function + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_column_drag_function") + (return-type "void") + (parameters + '("GtkTreeViewColumnDropFunc" "func") + '("gpointer" "user_data") + '("GDestroyNotify" "dnotify") + ) +) + +(define-method scroll_to_point + (of-object "GtkTreeView") + (c-name "gtk_tree_view_scroll_to_point") + (return-type "none") + (parameters + '("gint" "tree_x") + '("gint" "tree_y") + ) +) + +(define-method scroll_to_cell + (of-object "GtkTreeView") + (c-name "gtk_tree_view_scroll_to_cell") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewColumn*" "column") + '("gboolean" "use_align") + '("gfloat" "row_align") + '("gfloat" "col_align") + ) +) + +(define-method row_activated + (of-object "GtkTreeView") + (c-name "gtk_tree_view_row_activated") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewColumn*" "column") + ) +) + +(define-method expand_all + (of-object "GtkTreeView") + (c-name "gtk_tree_view_expand_all") + (return-type "none") +) + +(define-method collapse_all + (of-object "GtkTreeView") + (c-name "gtk_tree_view_collapse_all") + (return-type "none") +) + +(define-method expand_row + (of-object "GtkTreeView") + (c-name "gtk_tree_view_expand_row") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("gboolean" "open_all") + ) +) + +(define-method collapse_row + (of-object "GtkTreeView") + (c-name "gtk_tree_view_collapse_row") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + ) +) + +(define-method expand_rows + (of-object "GtkTreeView") + (c-name "gtk_tree_view_expand_rows") + (return-type "none") + (parameters + '("GtkTreeViewMappingFunc" "func") + '("gpointer" "data") + ) +) + +(define-method set_reorderable + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_reorderable") + (return-type "none") + (parameters + '("gboolean" "reorderable") + ) +) + +(define-method set_cursor + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_cursor") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewColumn*" "focus_column") + '("gboolean" "start_editing") + ) +) + +(define-method get_path_at_pos + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_path_at_pos") + (return-type "gboolean") + (parameters + '("GdkWindow*" "window") + '("gint" "x") + '("gint" "y") + '("GtkTreePath**" "path") + '("GtkTreeViewColumn**" "column") + '("gint*" "cell_x") + '("gint*" "cell_y") + ) +) + +(define-method get_cell_area + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_cell_area") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewColumn*" "column") + '("GdkRectangle*" "rect") + ) +) + +(define-method get_background_area + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_background_area") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewColumn*" "column") + '("GdkRectangle*" "rect") + ) +) + +(define-method get_visible_rect + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_visible_rect") + (return-type "none") + (parameters + '("GdkRectangle*" "visible_rect") + ) +) + +(define-method widget_to_tree_coords + (of-object "GtkTreeView") + (c-name "gtk_tree_view_widget_to_tree_coords") + (return-type "none") + (parameters + '("gint" "wx") + '("gint" "wy") + '("gint*" "tx") + '("gint*" "ty") + ) +) + +(define-method tree_to_widget_coords + (of-object "GtkTreeView") + (c-name "gtk_tree_view_tree_to_widget_coords") + (return-type "none") + (parameters + '("gint" "tx") + '("gint" "ty") + '("gint*" "wx") + '("gint*" "wy") + ) +) + +(define-method set_rows_drag_source + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_rows_drag_source") + (return-type "none") + (parameters + '("GdkModifierType" "start_button_mask") + '("const-GtkTargetEntry*" "targets") + '("gint" "n_targets") + '("GdkDragAction" "actions") + '("GtkTreeViewDraggableFunc" "row_draggable_func") + '("gpointer" "user_data") + ) +) + +(define-method set_rows_drag_dest + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_rows_drag_dest") + (return-type "none") + (parameters + '("const-GtkTargetEntry*" "targets") + '("gint" "n_targets") + '("GdkDragAction" "actions") + '("GtkTreeViewDroppableFunc" "location_droppable_func") + '("gpointer" "user_data") + ) +) + +(define-method unset_rows_drag_source + (of-object "GtkTreeView") + (c-name "gtk_tree_view_unset_rows_drag_source") + (return-type "none") +) + +(define-method unset_rows_drag_dest + (of-object "GtkTreeView") + (c-name "gtk_tree_view_unset_rows_drag_dest") + (return-type "none") +) + +(define-method set_drag_dest_row + (of-object "GtkTreeView") + (c-name "gtk_tree_view_set_drag_dest_row") + (return-type "none") + (parameters + '("GtkTreePath*" "path") + '("GtkTreeViewDropPosition" "pos") + ) +) + +(define-method get_drag_dest_row + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_drag_dest_row") + (return-type "none") + (parameters + '("GtkTreePath**" "path") + '("GtkTreeViewDropPosition*" "pos") + ) +) + +(define-method get_dest_row_at_pos + (of-object "GtkTreeView") + (c-name "gtk_tree_view_get_dest_row_at_pos") + (return-type "gboolean") + (parameters + '("gint" "drag_x") + '("gint" "drag_y") + '("GtkTreePath**" "path") + '("GtkTreeViewDropPosition*" "pos") + ) +) + +(define-method create_row_drag_icon + (of-object "GtkTreeView") + (c-name "gtk_tree_view_create_row_drag_icon") + (return-type "GdkPixmap*") + (parameters + '("GtkTreePath*" "path") + ) +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktreeviewcolumn.h + +(define-function gtk_tree_view_column_get_type + (c-name "gtk_tree_view_column_get_type") + (return-type "GtkType") +) + +(define-function gtk_tree_view_column_new + (c-name "gtk_tree_view_column_new") + (is-constructor-of GtkTreeViewColumn) + (return-type "GtkObject*") +) + +(define-function gtk_tree_view_column_new_with_attributes + (c-name "gtk_tree_view_column_new_with_attributes") + (is-constructor-of GtkTreeViewColumn) + (return-type "GtkObject*") + (parameters + '("gchar*" "title") + '("GtkCellRenderer*" "cell") + ) + (varargs #t) +) + +(define-method pack_start + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_pack_start") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell") + '("gboolean" "expand") + ) +) + +(define-method pack_end + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_pack_end") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell") + '("gboolean" "expand") + ) +) + +(define-method clear + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_clear") + (return-type "none") +) + +(define-method get_cell_renderers + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_cell_renderers") + (return-type "GList*") +) + +(define-method add_attribute + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_add_attribute") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell_renderer") + '("gchar*" "attribute") + '("gint" "column") + ) +) + +(define-method set_attributes + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_attributes") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell_renderer") + ) + (varargs #t) +) + +(define-method set_cell_data_func + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_cell_data_func") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell_renderer") + '("GtkCellDataFunc" "func") + '("gpointer" "func_data") + '("GtkDestroyNotify" "destroy") + ) +) + +(define-method clear_attributes + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_clear_attributes") + (return-type "none") + (parameters + '("GtkCellRenderer*" "cell_renderer") + ) +) + +(define-method set_visible + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_visible") + (return-type "none") + (parameters + '("gboolean" "visible") + ) +) + +(define-method get_visible + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_visible") + (return-type "gboolean") +) + +(define-method set_sizing + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_sizing") + (return-type "none") + (parameters + '("GtkTreeViewColumnSizing" "type") + ) +) + +(define-method get_sizing + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_sizing") + (return-type "gint") +) + +(define-method get_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_width") + (return-type "gint") +) + +(define-method get_fixed_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_fixed_width") + (return-type "gint") +) + +(define-method set_fixed_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_fixed_width") + (return-type "none") + (parameters + '("gint" "fixed_width") + ) +) + +(define-method set_min_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_min_width") + (return-type "none") + (parameters + '("gint" "min_width") + ) +) + +(define-method get_min_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_min_width") + (return-type "gint") +) + +(define-method set_max_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_max_width") + (return-type "none") + (parameters + '("gint" "max_width") + ) +) + +(define-method get_max_width + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_max_width") + (return-type "gint") +) + +(define-method clicked + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_clicked") + (return-type "none") +) + +(define-method set_title + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_title") + (return-type "none") + (parameters + '("gchar*" "title") + ) +) + +(define-method get_title + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_title") + (return-type "const-gchar*") +) + +(define-method set_clickable + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_clickable") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method set_widget + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_widget") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-method get_widget + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_widget") + (return-type "GtkWidget*") +) + +(define-method set_alignment + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_alignment") + (return-type "none") + (parameters + '("gfloat" "xalign") + ) +) + +(define-method get_alignment + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_alignment") + (return-type "gfloat") +) + +(define-method set_reorderable + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_reorderable") + (return-type "none") + (parameters + '("gboolean" "reorderable") + ) +) + +(define-method get_reorderable + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_reorderable") + (return-type "gboolean") +) + +(define-method set_sort_column_id + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_sort_column_id") + (return-type "none") + (parameters + '("gint" "sort_column_id") + ) +) + +(define-method set_sort_indicator + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_sort_indicator") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_sort_indicator + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_sort_indicator") + (return-type "gboolean") +) + +(define-method set_sort_order + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_set_sort_order") + (return-type "none") + (parameters + '("GtkSortType" "order") + ) +) + +(define-method get_sort_order + (of-object "GtkTreeViewColumn") + (c-name "gtk_tree_view_column_get_sort_order") + (return-type "GtkSortType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtktypeutils.h + + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvbbox.h + +(define-function gtk_vbutton_box_get_type + (c-name "gtk_vbutton_box_get_type") + (return-type "GtkType") +) + +(define-function gtk_vbutton_box_new + (c-name "gtk_vbutton_box_new") + (is-constructor-of GtkVButtonBox) + (return-type "GtkWidget*") +) + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvbox.h + +(define-function gtk_vbox_get_type + (c-name "gtk_vbox_get_type") + (return-type "GtkType") +) + +(define-function gtk_vbox_new + (c-name "gtk_vbox_new") + (is-constructor-of GtkVBox) + (return-type "GtkWidget*") + (parameters + '("gboolean" "homogeneous" (default "FALSE")) + '("gint" "spacing" (default "0")) + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkviewport.h + +(define-function gtk_viewport_get_type + (c-name "gtk_viewport_get_type") + (return-type "GtkType") +) + +(define-function gtk_viewport_new + (c-name "gtk_viewport_new") + (is-constructor-of GtkViewport) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "hadjustment" (null-ok) (default "NULL")) + '("GtkAdjustment*" "vadjustment" (null-ok) (default "NULL")) + ) +) + +(define-method get_hadjustment + (of-object "GtkViewport") + (c-name "gtk_viewport_get_hadjustment") + (return-type "GtkAdjustment*") +) + +(define-method get_vadjustment + (of-object "GtkViewport") + (c-name "gtk_viewport_get_vadjustment") + (return-type "GtkAdjustment*") +) + +(define-method set_hadjustment + (of-object "GtkViewport") + (c-name "gtk_viewport_set_hadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok)) + ) +) + +(define-method set_vadjustment + (of-object "GtkViewport") + (c-name "gtk_viewport_set_vadjustment") + (return-type "none") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok)) + ) +) + +(define-method set_shadow_type + (of-object "GtkViewport") + (c-name "gtk_viewport_set_shadow_type") + (return-type "none") + (parameters + '("GtkShadowType" "type") + ) +) + +(define-method get_shadow_type + (of-object "GtkViewport") + (c-name "gtk_viewport_get_shadow_type") + (return-type "GtkShadowType") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvpaned.h + +(define-function gtk_vpaned_get_type + (c-name "gtk_vpaned_get_type") + (return-type "GtkType") +) + +(define-function gtk_vpaned_new + (c-name "gtk_vpaned_new") + (is-constructor-of GtkVPaned) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvruler.h + +(define-function gtk_vruler_get_type + (c-name "gtk_vruler_get_type") + (return-type "GtkType") +) + +(define-function gtk_vruler_new + (c-name "gtk_vruler_new") + (is-constructor-of GtkVRuler) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvscale.h + +(define-function gtk_vscale_get_type + (c-name "gtk_vscale_get_type") + (return-type "GtkType") +) + +(define-function gtk_vscale_new + (c-name "gtk_vscale_new") + (is-constructor-of GtkVScale) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + ) +) + +(define-function gtk_vscale_new_with_range + (c-name "gtk_vscale_new_with_range") + (is-constructor-of GtkVScale) + (return-type "GtkWidget*") + (parameters + '("gdouble" "min") + '("gdouble" "max") + '("gdouble" "step") + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvscrollbar.h + +(define-function gtk_vscrollbar_get_type + (c-name "gtk_vscrollbar_get_type") + (return-type "GtkType") +) + +(define-function gtk_vscrollbar_new + (c-name "gtk_vscrollbar_new") + (is-constructor-of GtkVScrollbar) + (return-type "GtkWidget*") + (parameters + '("GtkAdjustment*" "adjustment" (null-ok) (default "NULL")) + ) +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkvseparator.h + +(define-function gtk_vseparator_get_type + (c-name "gtk_vseparator_get_type") + (return-type "GtkType") +) + +(define-function gtk_vseparator_new + (c-name "gtk_vseparator_new") + (is-constructor-of GtkVSeparator) + (return-type "GtkWidget*") +) + + + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkwidget.h + +(define-function gtk_widget_get_type + (c-name "gtk_widget_get_type") + (return-type "GtkType") +) + +(define-function gtk_widget_new + (c-name "gtk_widget_new") + (is-constructor-of GtkWidget) + (return-type "GtkWidget*") + (parameters + '("GtkType" "type") + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-method ref + (of-object "GtkWidget") + (c-name "gtk_widget_ref") + (return-type "GtkWidget*") +) + +(define-method unref + (of-object "GtkWidget") + (c-name "gtk_widget_unref") + (return-type "none") +) + +(define-method destroy + (of-object "GtkWidget") + (c-name "gtk_widget_destroy") + (return-type "none") +) + +(define-method destroyed + (of-object "GtkWidget") + (c-name "gtk_widget_destroyed") + (return-type "none") + (parameters + '("GtkWidget**" "widget_pointer") + ) +) + +(define-method set + (of-object "GtkWidget") + (c-name "gtk_widget_set") + (return-type "none") + (parameters + '("const-gchar*" "first_arg_name") + ) + (varargs #t) +) + +(define-method unparent + (of-object "GtkWidget") + (c-name "gtk_widget_unparent") + (return-type "none") +) + +(define-method show + (of-object "GtkWidget") + (c-name "gtk_widget_show") + (return-type "none") +) + +(define-method show_now + (of-object "GtkWidget") + (c-name "gtk_widget_show_now") + (return-type "none") +) + +(define-method hide + (of-object "GtkWidget") + (c-name "gtk_widget_hide") + (return-type "none") +) + +(define-method show_all + (of-object "GtkWidget") + (c-name "gtk_widget_show_all") + (return-type "none") +) + +(define-method hide_all + (of-object "GtkWidget") + (c-name "gtk_widget_hide_all") + (return-type "none") +) + +(define-method map + (of-object "GtkWidget") + (c-name "gtk_widget_map") + (return-type "none") +) + +(define-method unmap + (of-object "GtkWidget") + (c-name "gtk_widget_unmap") + (return-type "none") +) + +(define-method realize + (of-object "GtkWidget") + (c-name "gtk_widget_realize") + (return-type "none") +) + +(define-method unrealize + (of-object "GtkWidget") + (c-name "gtk_widget_unrealize") + (return-type "none") +) + +(define-method queue_draw + (of-object "GtkWidget") + (c-name "gtk_widget_queue_draw") + (return-type "none") +) + +(define-method queue_draw_area + (of-object "GtkWidget") + (c-name "gtk_widget_queue_draw_area") + (return-type "none") + (parameters + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method queue_clear + (of-object "GtkWidget") + (c-name "gtk_widget_queue_clear") + (return-type "none") +) + +(define-method queue_clear_area + (of-object "GtkWidget") + (c-name "gtk_widget_queue_clear_area") + (return-type "none") + (parameters + '("gint" "x") + '("gint" "y") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method queue_resize + (of-object "GtkWidget") + (c-name "gtk_widget_queue_resize") + (return-type "none") +) + +(define-method draw + (of-object "GtkWidget") + (c-name "gtk_widget_draw") + (return-type "none") + (parameters + '("GdkRectangle*" "area") + ) +) + +(define-method size_request + (of-object "GtkWidget") + (c-name "gtk_widget_size_request") + (return-type "none") + (parameters + '("GtkRequisition*" "requisition") + ) +) + +(define-method size_allocate + (of-object "GtkWidget") + (c-name "gtk_widget_size_allocate") + (return-type "none") + (parameters + '("GtkAllocation*" "allocation") + ) +) + +(define-method get_child_requisition + (of-object "GtkWidget") + (c-name "gtk_widget_get_child_requisition") + (return-type "none") + (parameters + '("GtkRequisition*" "requisition") + ) +) + +(define-method add_accelerator + (of-object "GtkWidget") + (c-name "gtk_widget_add_accelerator") + (return-type "none") + (parameters + '("const-gchar*" "accel_signal") + '("GtkAccelGroup*" "accel_group") + '("guint" "accel_key") + '("guint" "accel_mods") + '("GtkAccelFlags" "accel_flags") + ) +) + +(define-method remove_accelerator + (of-object "GtkWidget") + (c-name "gtk_widget_remove_accelerator") + (return-type "none") + (parameters + '("GtkAccelGroup*" "accel_group") + '("guint" "accel_key") + '("guint" "accel_mods") + ) +) + +(define-method remove_accelerators + (of-object "GtkWidget") + (c-name "gtk_widget_remove_accelerators") + (return-type "none") + (parameters + '("const-gchar*" "accel_signal") + '("gboolean" "visible_only") + ) +) + +(define-method accelerator_signal + (of-object "GtkWidget") + (c-name "gtk_widget_accelerator_signal") + (return-type "guint") + (parameters + '("GtkAccelGroup*" "accel_group") + '("guint" "accel_key") + '("guint" "accel_mods") + ) +) + +(define-method lock_accelerators + (of-object "GtkWidget") + (c-name "gtk_widget_lock_accelerators") + (return-type "none") +) + +(define-method unlock_accelerators + (of-object "GtkWidget") + (c-name "gtk_widget_unlock_accelerators") + (return-type "none") +) + +(define-method accelerators_locked + (of-object "GtkWidget") + (c-name "gtk_widget_accelerators_locked") + (return-type "gboolean") +) + +(define-method mnemonic_activate + (of-object "GtkWidget") + (c-name "gtk_widget_mnemonic_activate") + (return-type "gboolean") + (parameters + '("gboolean" "group_cycling") + ) +) + +(define-method event + (of-object "GtkWidget") + (c-name "gtk_widget_event") + (return-type "gint") + (parameters + '("GdkEvent*" "event") + ) +) + +(define-method send_expose + (of-object "GtkWidget") + (c-name "gtk_widget_send_expose") + (return-type "gint") + (parameters + '("GdkEvent*" "event") + ) +) + +(define-method activate + (of-object "GtkWidget") + (c-name "gtk_widget_activate") + (return-type "gboolean") +) + +(define-method set_scroll_adjustments + (of-object "GtkWidget") + (c-name "gtk_widget_set_scroll_adjustments") + (return-type "gboolean") + (parameters + '("GtkAdjustment*" "hadjustment" (null-ok)) + '("GtkAdjustment*" "vadjustment" (null-ok)) + ) +) + +(define-method reparent + (of-object "GtkWidget") + (c-name "gtk_widget_reparent") + (return-type "none") + (parameters + '("GtkWidget*" "new_parent") + ) +) + +(define-method intersect + (of-object "GtkWidget") + (c-name "gtk_widget_intersect") + (return-type "gint") + (parameters + '("GdkRectangle*" "area") + '("GdkRectangle*" "intersection") + ) +) + +(define-method region_intersect + (of-object "GtkWidget") + (c-name "gtk_widget_region_intersect") + (return-type "GdkRegion*") + (parameters + '("GdkRegion*" "region") + ) +) + +(define-method is_focus + (of-object "GtkWidget") + (c-name "gtk_widget_is_focus") + (return-type "gboolean") +) + +(define-method grab_focus + (of-object "GtkWidget") + (c-name "gtk_widget_grab_focus") + (return-type "none") +) + +(define-method grab_default + (of-object "GtkWidget") + (c-name "gtk_widget_grab_default") + (return-type "none") +) + +(define-method set_name + (of-object "GtkWidget") + (c-name "gtk_widget_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GtkWidget") + (c-name "gtk_widget_get_name") + (return-type "const-gchar*") +) + +(define-method set_state + (of-object "GtkWidget") + (c-name "gtk_widget_set_state") + (return-type "none") + (parameters + '("GtkStateType" "state") + ) +) + +(define-method set_sensitive + (of-object "GtkWidget") + (c-name "gtk_widget_set_sensitive") + (return-type "none") + (parameters + '("gboolean" "sensitive") + ) +) + +(define-method set_app_paintable + (of-object "GtkWidget") + (c-name "gtk_widget_set_app_paintable") + (return-type "none") + (parameters + '("gboolean" "app_paintable") + ) +) + +(define-method set_double_buffered + (of-object "GtkWidget") + (c-name "gtk_widget_set_double_buffered") + (return-type "none") + (parameters + '("gboolean" "double_buffered") + ) +) + +(define-method set_parent + (of-object "GtkWidget") + (c-name "gtk_widget_set_parent") + (return-type "none") + (parameters + '("GtkWidget*" "parent") + ) +) + +(define-method set_parent_window + (of-object "GtkWidget") + (c-name "gtk_widget_set_parent_window") + (return-type "none") + (parameters + '("GdkWindow*" "parent_window") + ) +) + +(define-method get_parent_window + (of-object "GtkWidget") + (c-name "gtk_widget_get_parent_window") + (return-type "GdkWindow*") +) + +(define-method child_focus + (of-object "GtkWidget") + (c-name "gtk_widget_child_focus") + (return-type "gboolean") + (parameters + '("GtkDirectionType" "direction") + ) +) + +(define-method set_uposition + (of-object "GtkWidget") + (c-name "gtk_widget_set_uposition") + (return-type "none") + (parameters + '("gint" "x") + '("gint" "y") + ) +) + +(define-method set_usize + (of-object "GtkWidget") + (c-name "gtk_widget_set_usize") + (return-type "none") + (parameters + '("gint" "width") + '("gint" "height") + ) +) + +(define-method set_events + (of-object "GtkWidget") + (c-name "gtk_widget_set_events") + (return-type "none") + (parameters + '("gint" "events") + ) +) + +(define-method add_events + (of-object "GtkWidget") + (c-name "gtk_widget_add_events") + (return-type "none") + (parameters + '("gint" "events") + ) +) + +(define-method set_extension_events + (of-object "GtkWidget") + (c-name "gtk_widget_set_extension_events") + (return-type "none") + (parameters + '("GdkExtensionMode" "mode") + ) +) + +(define-method get_extension_events + (of-object "GtkWidget") + (c-name "gtk_widget_get_extension_events") + (return-type "GdkExtensionMode") +) + +(define-method get_toplevel + (of-object "GtkWidget") + (c-name "gtk_widget_get_toplevel") + (return-type "GtkWidget*") +) + +(define-method get_ancestor + (of-object "GtkWidget") + (c-name "gtk_widget_get_ancestor") + (return-type "GtkWidget*") + (parameters + '("GtkType" "widget_type") + ) +) + +(define-method get_colormap + (of-object "GtkWidget") + (c-name "gtk_widget_get_colormap") + (return-type "GdkColormap*") +) + +(define-method get_visual + (of-object "GtkWidget") + (c-name "gtk_widget_get_visual") + (return-type "GdkVisual*") +) + +(define-method get_accessible + (of-object "GtkWidget") + (c-name "gtk_widget_get_accessible") + (return-type "AtkObject*") +) + +(define-method set_colormap + (of-object "GtkWidget") + (c-name "gtk_widget_set_colormap") + (return-type "none") + (parameters + '("GdkColormap*" "colormap") + ) +) + +(define-method get_events + (of-object "GtkWidget") + (c-name "gtk_widget_get_events") + (return-type "gint") +) + +(define-method get_pointer + (of-object "GtkWidget") + (c-name "gtk_widget_get_pointer") + (return-type "none") + (parameters + '("gint*" "x") + '("gint*" "y") + ) +) + +(define-method is_ancestor + (of-object "GtkWidget") + (c-name "gtk_widget_is_ancestor") + (return-type "gint") + (parameters + '("GtkWidget*" "ancestor") + ) +) + +(define-method hide_on_delete + (of-object "GtkWidget") + (c-name "gtk_widget_hide_on_delete") + (return-type "gint") +) + +(define-method set_style + (of-object "GtkWidget") + (c-name "gtk_widget_set_style") + (return-type "none") + (parameters + '("GtkStyle*" "style") + ) +) + +(define-method ensure_style + (of-object "GtkWidget") + (c-name "gtk_widget_ensure_style") + (return-type "none") +) + +(define-method get_style + (of-object "GtkWidget") + (c-name "gtk_widget_get_style") + (return-type "GtkStyle*") +) + +(define-method modify_style + (of-object "GtkWidget") + (c-name "gtk_widget_modify_style") + (return-type "none") + (parameters + '("GtkRcStyle*" "style") + ) +) + +(define-method get_modifier_style + (of-object "GtkWidget") + (c-name "gtk_widget_get_modifier_style") + (return-type "GtkRcStyle*") +) + +(define-method modify_fg + (of-object "GtkWidget") + (c-name "gtk_widget_modify_fg") + (return-type "none") + (parameters + '("GtkStateType" "state") + '("GdkColor*" "color") + ) +) + +(define-method modify_bg + (of-object "GtkWidget") + (c-name "gtk_widget_modify_bg") + (return-type "none") + (parameters + '("GtkStateType" "state") + '("GdkColor*" "color") + ) +) + +(define-method modify_text + (of-object "GtkWidget") + (c-name "gtk_widget_modify_text") + (return-type "none") + (parameters + '("GtkStateType" "state") + '("GdkColor*" "color") + ) +) + +(define-method modify_base + (of-object "GtkWidget") + (c-name "gtk_widget_modify_base") + (return-type "none") + (parameters + '("GtkStateType" "state") + '("GdkColor*" "color") + ) +) + +(define-method modify_font + (of-object "GtkWidget") + (c-name "gtk_widget_modify_font") + (return-type "none") + (parameters + '("PangoFontDescription*" "font_desc") + ) +) + +(define-method create_pango_context + (of-object "GtkWidget") + (c-name "gtk_widget_create_pango_context") + (return-type "PangoContext*") +) + +(define-method get_pango_context + (of-object "GtkWidget") + (c-name "gtk_widget_get_pango_context") + (return-type "PangoContext*") +) + +(define-method create_pango_layout + (of-object "GtkWidget") + (c-name "gtk_widget_create_pango_layout") + (return-type "PangoLayout*") + (parameters + '("const-gchar*" "text") + ) +) + +(define-method render_icon + (of-object "GtkWidget") + (c-name "gtk_widget_render_icon") + (return-type "GdkPixbuf*") + (parameters + '("const-gchar*" "stock_id") + '("GtkIconSize" "size") + '("const-gchar*" "detail") + ) +) + +(define-method set_composite_name + (of-object "GtkWidget") + (c-name "gtk_widget_set_composite_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_composite_name + (of-object "GtkWidget") + (c-name "gtk_widget_get_composite_name") + (return-type "gchar*") +) + +(define-method reset_rc_styles + (of-object "GtkWidget") + (c-name "gtk_widget_reset_rc_styles") + (return-type "none") +) + +(define-function widget_push_colormap + (c-name "gtk_widget_push_colormap") + (return-type "none") + (parameters + '("GdkColormap*" "cmap") + ) +) + +(define-function widget_push_composite_child + (c-name "gtk_widget_push_composite_child") + (return-type "none") +) + +(define-function widget_pop_composite_child + (c-name "gtk_widget_pop_composite_child") + (return-type "none") +) + +(define-function widget_pop_colormap + (c-name "gtk_widget_pop_colormap") + (return-type "none") +) + +(define-method install_style_property + (of-object "GtkWidgetClass") + (c-name "gtk_widget_class_install_style_property") + (return-type "none") + (parameters + '("GParamSpec*" "pspec") + ) +) + +(define-method install_style_property_parser + (of-object "GtkWidgetClass") + (c-name "gtk_widget_class_install_style_property_parser") + (return-type "none") + (parameters + '("GParamSpec*" "pspec") + '("GtkRcPropertyParser" "parser") + ) +) + +(define-method style_get_property + (of-object "GtkWidget") + (c-name "gtk_widget_style_get_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("GValue*" "value") + ) +) + +(define-method style_get_valist + (of-object "GtkWidget") + (c-name "gtk_widget_style_get_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method style_get + (of-object "GtkWidget") + (c-name "gtk_widget_style_get") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-function widget_set_default_colormap + (c-name "gtk_widget_set_default_colormap") + (return-type "none") + (parameters + '("GdkColormap*" "colormap") + ) +) + +(define-function widget_get_default_colormap + (c-name "gtk_widget_get_default_colormap") + (return-type "GdkColormap*") +) + +(define-function widget_get_default_visual + (c-name "gtk_widget_get_default_visual") + (return-type "GdkVisual*") +) + +(define-method set_direction + (of-object "GtkWidget") + (c-name "gtk_widget_set_direction") + (return-type "none") + (parameters + '("GtkTextDirection" "dir") + ) +) + +(define-method get_direction + (of-object "GtkWidget") + (c-name "gtk_widget_get_direction") + (return-type "GtkTextDirection") +) + +(define-function widget_set_default_direction + (c-name "gtk_widget_set_default_direction") + (return-type "none") + (parameters + '("GtkTextDirection" "dir") + ) +) + +(define-function widget_get_default_direction + (c-name "gtk_widget_get_default_direction") + (return-type "GtkTextDirection") +) + +(define-method shape_combine_mask + (of-object "GtkWidget") + (c-name "gtk_widget_shape_combine_mask") + (return-type "none") + (parameters + '("GdkBitmap*" "shape_mask") + '("gint" "offset_x") + '("gint" "offset_y") + ) +) + +(define-method reset_shapes + (of-object "GtkWidget") + (c-name "gtk_widget_reset_shapes") + (return-type "none") +) + +(define-method path + (of-object "GtkWidget") + (c-name "gtk_widget_path") + (return-type "none") + (parameters + '("guint*" "path_length") + '("gchar**" "path") + '("gchar**" "path_reversed") + ) +) + +(define-method class_path + (of-object "GtkWidget") + (c-name "gtk_widget_class_path") + (return-type "none") + (parameters + '("guint*" "path_length") + '("gchar**" "path") + '("gchar**" "path_reversed") + ) +) + +;; From /opt/gtk2/include/gtk-2.0/gtk/gtkwindow.h + +(define-function gtk_window_get_type + (c-name "gtk_window_get_type") + (return-type "GtkType") +) + +(define-function gtk_window_new + (c-name "gtk_window_new") + (is-constructor-of GtkWindow) + (return-type "GtkWidget*") + (parameters + '("GtkWindowType" "type" (default "GTK_WINDOW_TOPLEVEL")) + ) +) + +(define-method set_title + (of-object "GtkWindow") + (c-name "gtk_window_set_title") + (return-type "none") + (parameters + '("const-gchar*" "title") + ) +) + +(define-method set_wmclass + (of-object "GtkWindow") + (c-name "gtk_window_set_wmclass") + (return-type "none") + (parameters + '("const-gchar*" "wmclass_name") + '("const-gchar*" "wmclass_class") + ) +) + +(define-method set_role + (of-object "GtkWindow") + (c-name "gtk_window_set_role") + (return-type "none") + (parameters + '("const-gchar*" "role") + ) +) + +(define-method add_accel_group + (of-object "GtkWindow") + (c-name "gtk_window_add_accel_group") + (return-type "none") + (parameters + '("GtkAccelGroup*" "accel_group") + ) +) + +(define-method remove_accel_group + (of-object "GtkWindow") + (c-name "gtk_window_remove_accel_group") + (return-type "none") + (parameters + '("GtkAccelGroup*" "accel_group") + ) +) + +(define-method set_position + (of-object "GtkWindow") + (c-name "gtk_window_set_position") + (return-type "none") + (parameters + '("GtkWindowPosition" "position") + ) +) + +(define-method activate_focus + (of-object "GtkWindow") + (c-name "gtk_window_activate_focus") + (return-type "gint") +) + +(define-method activate_default + (of-object "GtkWindow") + (c-name "gtk_window_activate_default") + (return-type "gint") +) + +(define-method set_transient_for + (of-object "GtkWindow") + (c-name "gtk_window_set_transient_for") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + +(define-method set_type_hint + (of-object "GtkWindow") + (c-name "gtk_window_set_type_hint") + (return-type "none") + (parameters + '("GdkWindowTypeHint" "hint") + ) +) + +(define-method set_destroy_with_parent + (of-object "GtkWindow") + (c-name "gtk_window_set_destroy_with_parent") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method set_resizable + (of-object "GtkWindow") + (c-name "gtk_window_set_resizable") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method get_resizable + (of-object "GtkWindow") + (c-name "gtk_window_get_resizable") + (return-type "gboolean") +) + +(define-method set_gravity + (of-object "GtkWindow") + (c-name "gtk_window_set_gravity") + (return-type "none") + (parameters + '("GdkGravity" "gravity") + ) +) + +(define-method get_gravity + (of-object "GtkWindow") + (c-name "gtk_window_get_gravity") + (return-type "GdkGravity") +) + +(define-method set_geometry_hints + (of-object "GtkWindow") + (c-name "gtk_window_set_geometry_hints") + (return-type "none") + (parameters + '("GtkWidget*" "geometry_widget") + '("GdkGeometry*" "geometry") + '("GdkWindowHints" "geom_mask") + ) +) + +(define-method set_has_frame + (of-object "GtkWindow") + (c-name "gtk_window_set_has_frame") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method set_frame_dimensions + (of-object "GtkWindow") + (c-name "gtk_window_set_frame_dimensions") + (return-type "none") + (parameters + '("gint" "left") + '("gint" "top") + '("gint" "right") + '("gint" "bottom") + ) +) + +(define-method set_decorated + (of-object "GtkWindow") + (c-name "gtk_window_set_decorated") + (return-type "none") + (parameters + '("gboolean" "setting") + ) +) + +(define-method set_modal + (of-object "GtkWindow") + (c-name "gtk_window_set_modal") + (return-type "none") + (parameters + '("gboolean" "modal") + ) +) + +(define-function window_list_toplevels + (c-name "gtk_window_list_toplevels") + (return-type "GList*") +) + +(define-method add_mnemonic + (of-object "GtkWindow") + (c-name "gtk_window_add_mnemonic") + (return-type "none") + (parameters + '("guint" "keyval") + '("GtkWidget*" "target") + ) +) + +(define-method remove_mnemonic + (of-object "GtkWindow") + (c-name "gtk_window_remove_mnemonic") + (return-type "none") + (parameters + '("guint" "keyval") + '("GtkWidget*" "target") + ) +) + +(define-method mnemonic_activate + (of-object "GtkWindow") + (c-name "gtk_window_mnemonic_activate") + (return-type "gboolean") + (parameters + '("guint" "keyval") + '("GdkModifierType" "modifier") + ) +) + +(define-method set_mnemonic_modifier + (of-object "GtkWindow") + (c-name "gtk_window_set_mnemonic_modifier") + (return-type "none") + (parameters + '("GdkModifierType" "modifier") + ) +) + +(define-method present + (of-object "GtkWindow") + (c-name "gtk_window_present") + (return-type "none") +) + +(define-method iconify + (of-object "GtkWindow") + (c-name "gtk_window_iconify") + (return-type "none") +) + +(define-method deiconify + (of-object "GtkWindow") + (c-name "gtk_window_deiconify") + (return-type "none") +) + +(define-method stick + (of-object "GtkWindow") + (c-name "gtk_window_stick") + (return-type "none") +) + +(define-method unstick + (of-object "GtkWindow") + (c-name "gtk_window_unstick") + (return-type "none") +) + +(define-method maximize + (of-object "GtkWindow") + (c-name "gtk_window_maximize") + (return-type "none") +) + +(define-method unmaximize + (of-object "GtkWindow") + (c-name "gtk_window_unmaximize") + (return-type "none") +) + +(define-method begin_resize_drag + (of-object "GtkWindow") + (c-name "gtk_window_begin_resize_drag") + (return-type "none") + (parameters + '("GdkWindowEdge" "edge") + '("gint" "button") + '("gint" "root_x") + '("gint" "root_y") + '("guint32" "timestamp") + ) +) + +(define-method begin_move_drag + (of-object "GtkWindow") + (c-name "gtk_window_begin_move_drag") + (return-type "none") + (parameters + '("gint" "button") + '("gint" "root_x") + '("gint" "root_y") + '("guint32" "timestamp") + ) +) + +(define-method set_policy + (of-object "GtkWindow") + (c-name "gtk_window_set_policy") + (return-type "none") + (parameters + '("gint" "allow_shrink") + '("gint" "allow_grow") + '("gint" "auto_shrink") + ) +) + +(define-method set_default_size + (of-object "GtkWindow") + (c-name "gtk_window_set_default_size") + (return-type "none") + (parameters + '("gint" "width") + '("gint" "height") + ) +) + +(define-method set_focus + (of-object "GtkWindow") + (c-name "gtk_window_set_focus") + (return-type "none") + (parameters + '("GtkWidget*" "focus") + ) +) + +(define-method set_default + (of-object "GtkWindow") + (c-name "gtk_window_set_default") + (return-type "none") + (parameters + '("GtkWidget*" "defaultw") + ) +) + +(define-method remove_embedded_xid + (of-object "GtkWindow") + (c-name "gtk_window_remove_embedded_xid") + (return-type "none") + (parameters + '("guint" "xid") + ) +) + +(define-method add_embedded_xid + (of-object "GtkWindow") + (c-name "gtk_window_add_embedded_xid") + (return-type "none") + (parameters + '("guint" "xid") + ) +) diff --git a/codegen/makefile b/codegen/makefile index 0a16abcaf..a85803abc 100755 --- a/codegen/makefile +++ b/codegen/makefile @@ -3,7 +3,7 @@ all: @echo "'make unix' is broken for now." windows: - ./defs-parse.pl < gtk-types.defs + cat gdk-types.defs gtk-types.defs gtk-props.defs gtk.defs | ./defs-parse.pl unix: @echo "'make unix' is broken for now."