Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

58 files changed, 39641 insertions, 0 deletions

diff --git a/plug-ins/pygimp/Makefile.am b/plug-ins/pygimp/Makefile.am
new file mode 100644
index 0000000..801b78a
--- /dev/null
+++ b/plug-ins/pygimp/Makefile.am
@@ -0,0 +1,188 @@
+## Process this file with automake to produce Makefile.in
+
+libgimpui = $(top_builddir)/libgimp/libgimpui-$(GIMP_API_VERSION).la
+libgimpconfig = $(top_builddir)/libgimpconfig/libgimpconfig-$(GIMP_API_VERSION).la
+libgimpwidgets = $(top_builddir)/libgimpwidgets/libgimpwidgets-$(GIMP_API_VERSION).la
+libgimp = $(top_builddir)/libgimp/libgimp-$(GIMP_API_VERSION).la
+libgimpcolor = $(top_builddir)/libgimpcolor/libgimpcolor-$(GIMP_API_VERSION).la
+libgimpbase = $(top_builddir)/libgimpbase/libgimpbase-$(GIMP_API_VERSION).la
+libgimpmath = $(top_builddir)/libgimpmath/libgimpmath-$(GIMP_API_VERSION).la
+libgimpthumb = $(top_builddir)/libgimpthumb/libgimpthumb-$(GIMP_API_VERSION).la
+
+SUBDIRS = plug-ins
+
+if PLATFORM_WIN32
+no_undefined = -no-undefined
+shrext       = -shrext .pyd
+path_separator = ;
+else
+path_separator = :
+endif
+
+AM_CFLAGS = $(PYGIMP_EXTRA_CFLAGS)
+
+AM_CPPFLAGS = \
+	-I$(top_srcdir)		\
+	$(PYTHON_INCLUDES)	\
+	$(PYGTK_CFLAGS)		\
+	$(PYCAIRO_CFLAGS)	\
+	$(GTK_CFLAGS)		\
+	$(GEGL_CFLAGS)
+
+pygimpbase = python
+
+pygimpdir = $(gimpplugindir)/$(pygimpbase)
+
+pygimp_LTLIBRARIES = gimp.la _gimpenums.la gimpcolor.la _gimpui.la \
+	gimpthumb.la
+
+gimp_la_SOURCES = \
+	gimpmodule.c		\
+	pygimp-item.c		\
+	pygimp-display.c	\
+	pygimp-drawable.c	\
+	pygimp-image.c		\
+	pygimp-parasite.c	\
+	pygimp-pdb.c		\
+	pygimp-tile.c		\
+	pygimp-vectors.c	\
+	pygimp.h		\
+	pygimp-api.h		\
+	pygimp-intl.h		\
+	pygimp-util.h
+
+gimp_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimp
+
+gimp_la_LIBADD = \
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(libgimpui)		\
+	$(GLIB_LIBS)		\
+	$(GEGL_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)
+
+_gimpenums_la_SOURCES = \
+	gimpenumsmodule.c
+
+_gimpenums_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex init_gimpenums
+
+_gimpenums_la_LIBADD = \
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(GLIB_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)
+
+gimpcolor_la_SOURCES = \
+	gimpcolormodule.c	\
+	pygimp-colors.c		\
+	pygimpcolor.h		\
+	pygimpcolor-api.h
+
+gimpcolor_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimpcolor
+
+gimpcolor_la_LIBADD = \
+	$(libgimpcolor)		\
+	$(GLIB_LIBS)		\
+	$(PYLINK_LIBS)
+
+_gimpui_la_SOURCES = \
+	gimpuimodule.c		\
+	gimpui.c
+
+_gimpui_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex init_gimpui
+
+_gimpui_la_LIBADD = \
+	$(libgimpui)		\
+	$(libgimpwidgets)	\
+	$(libgimpconfig)	\
+	$(libgimpmath)		\
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(GTK_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)		\
+	$(INTLLIBS)
+
+gimpthumb_la_SOURCES = \
+	gimpthumbmodule.c \
+	gimpthumb.c
+
+gimpthumb_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimpthumb
+
+gimpthumb_la_LIBADD = \
+	$(libgimpthumb)		\
+	$(GDK_PIXBUF_LIBS)	\
+	$(PYLINK_LIBS)
+
+pygimp_PYTHON = \
+	gimpenums.py	\
+	gimpfu.py	\
+	gimpplugin.py	\
+	gimpshelf.py	\
+	gimpui.py
+
+pygimp_DATA = pygimp-logo.png
+
+codegen_files = \
+	gimp-types.defs		\
+	gimpcolor-types.defs	\
+	gimpenums-types.defs	\
+	gimpthumb.defs		\
+	gimpthumb.override	\
+	gimpui.defs		\
+	gimpui.override
+
+pyenvdir = $(gimpplugindir)/environ
+pyinterpdir = $(gimpplugindir)/interpreters
+
+pyenvfile = $(pyenvdir)/pygimp.env
+pyinterpfile = $(pyinterpdir)/pygimp.interp
+
+install-env-file:
+	$(mkinstalldirs) '$(DESTDIR)$(pyenvdir)'
+	echo '$(path_separator) PYTHONPATH=$${gimp_plug_in_dir}/$(pygimpbase)' > '$(DESTDIR)$(pyenvfile)'
+
+install-interp-file:
+	$(mkinstalldirs) '$(DESTDIR)$(pyinterpdir)'
+	echo 'python=$(PYBIN_PATH)' > '$(DESTDIR)$(pyinterpfile)'
+	echo 'python2=$(PYBIN_PATH)' >> '$(DESTDIR)$(pyinterpfile)'
+	echo '/usr/bin/python=$(PYBIN_PATH)' >> '$(DESTDIR)$(pyinterpfile)'
+	echo ":Python:E::py::`basename $(PYTHON)`:" >> '$(DESTDIR)$(pyinterpfile)'
+
+install-data-local: install-env-file install-interp-file
+
+uninstall-local:
+	rm -f '$(DESTDIR)$(pyenvfile)' '$(DESTDIR)$(pyinterpfile)'
+
+EXTRA_DIST = \
+	$(pygimp_DATA)		\
+	$(codegen_files)
+
+gimpui.c: gimpui.defs gimpui.override gimp-types.defs gimpcolor-types.defs gimpenums-types.defs
+
+gimpthumb.c: gimpthumb.defs gimpthumb.override
+
+CLEANFILES = gimpui.c gimpthumb.c
+
+.defs.c:
+	(cd $(srcdir) \
+	 && $(PYGTK_CODEGEN) \
+	    --override $*.override \
+	    --register $(PYGTK_DEFSDIR)/gdk-types.defs \
+	    --register $(PYGTK_DEFSDIR)/gtk-types.defs \
+	    --register gimp-types.defs \
+	    --register gimpcolor-types.defs \
+	    --register gimpenums-types.defs \
+	    --prefix $* $*.defs) > gen-$*.c \
+	 && cp gen-$*.c $*.c \
+	 && rm -f gen-$*.c
diff --git a/plug-ins/pygimp/Makefile.in b/plug-ins/pygimp/Makefile.in
new file mode 100644
index 0000000..7055e26
--- /dev/null
+++ b/plug-ins/pygimp/Makefile.in
@@ -0,0 +1,1431 @@
+# Makefile.in generated by automake 1.16.3 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2020 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = plug-ins/pygimp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/m4macros/alsa.m4 \
+	$(top_srcdir)/m4macros/ax_compare_version.m4 \
+	$(top_srcdir)/m4macros/ax_cxx_compile_stdcxx.m4 \
+	$(top_srcdir)/m4macros/ax_gcc_func_attribute.m4 \
+	$(top_srcdir)/m4macros/ax_prog_cc_for_build.m4 \
+	$(top_srcdir)/m4macros/ax_prog_perl_version.m4 \
+	$(top_srcdir)/m4macros/detectcflags.m4 \
+	$(top_srcdir)/m4macros/pythondev.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(pygimp_PYTHON) \
+	$(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(pygimpdir)" "$(DESTDIR)$(pygimpdir)" \
+	"$(DESTDIR)$(pygimpdir)"
+LTLIBRARIES = $(pygimp_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+_gimpenums_la_DEPENDENCIES = $(libgimp) $(libgimpcolor) $(libgimpbase) \
+	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
+	$(am__DEPENDENCIES_1)
+am__gimpenums_la_OBJECTS = gimpenumsmodule.lo
+_gimpenums_la_OBJECTS = $(am__gimpenums_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+_gimpenums_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(_gimpenums_la_LDFLAGS) $(LDFLAGS) -o $@
+_gimpui_la_DEPENDENCIES = $(libgimpui) $(libgimpwidgets) \
+	$(libgimpconfig) $(libgimpmath) $(libgimp) $(libgimpcolor) \
+	$(libgimpbase) $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
+	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
+am__gimpui_la_OBJECTS = gimpuimodule.lo gimpui.lo
+_gimpui_la_OBJECTS = $(am__gimpui_la_OBJECTS)
+_gimpui_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(_gimpui_la_LDFLAGS) $(LDFLAGS) -o $@
+gimp_la_DEPENDENCIES = $(libgimp) $(libgimpcolor) $(libgimpbase) \
+	$(libgimpui) $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
+	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
+am_gimp_la_OBJECTS = gimpmodule.lo pygimp-item.lo pygimp-display.lo \
+	pygimp-drawable.lo pygimp-image.lo pygimp-parasite.lo \
+	pygimp-pdb.lo pygimp-tile.lo pygimp-vectors.lo
+gimp_la_OBJECTS = $(am_gimp_la_OBJECTS)
+gimp_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(gimp_la_LDFLAGS) $(LDFLAGS) -o $@
+gimpcolor_la_DEPENDENCIES = $(libgimpcolor) $(am__DEPENDENCIES_1) \
+	$(am__DEPENDENCIES_1)
+am_gimpcolor_la_OBJECTS = gimpcolormodule.lo pygimp-colors.lo
+gimpcolor_la_OBJECTS = $(am_gimpcolor_la_OBJECTS)
+gimpcolor_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(gimpcolor_la_LDFLAGS) $(LDFLAGS) -o $@
+gimpthumb_la_DEPENDENCIES = $(libgimpthumb) $(am__DEPENDENCIES_1) \
+	$(am__DEPENDENCIES_1)
+am_gimpthumb_la_OBJECTS = gimpthumbmodule.lo gimpthumb.lo
+gimpthumb_la_OBJECTS = $(am_gimpthumb_la_OBJECTS)
+gimpthumb_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(gimpthumb_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/gimpcolormodule.Plo \
+	./$(DEPDIR)/gimpenumsmodule.Plo ./$(DEPDIR)/gimpmodule.Plo \
+	./$(DEPDIR)/gimpthumb.Plo ./$(DEPDIR)/gimpthumbmodule.Plo \
+	./$(DEPDIR)/gimpui.Plo ./$(DEPDIR)/gimpuimodule.Plo \
+	./$(DEPDIR)/pygimp-colors.Plo ./$(DEPDIR)/pygimp-display.Plo \
+	./$(DEPDIR)/pygimp-drawable.Plo ./$(DEPDIR)/pygimp-image.Plo \
+	./$(DEPDIR)/pygimp-item.Plo ./$(DEPDIR)/pygimp-parasite.Plo \
+	./$(DEPDIR)/pygimp-pdb.Plo ./$(DEPDIR)/pygimp-tile.Plo \
+	./$(DEPDIR)/pygimp-vectors.Plo
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(_gimpenums_la_SOURCES) $(_gimpui_la_SOURCES) \
+	$(gimp_la_SOURCES) $(gimpcolor_la_SOURCES) \
+	$(gimpthumb_la_SOURCES)
+DIST_SOURCES = $(_gimpenums_la_SOURCES) $(_gimpui_la_SOURCES) \
+	$(gimp_la_SOURCES) $(gimpcolor_la_SOURCES) \
+	$(gimpthumb_la_SOURCES)
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+	ctags-recursive dvi-recursive html-recursive info-recursive \
+	install-data-recursive install-dvi-recursive \
+	install-exec-recursive install-html-recursive \
+	install-info-recursive install-pdf-recursive \
+	install-ps-recursive install-recursive installcheck-recursive \
+	installdirs-recursive pdf-recursive ps-recursive \
+	tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile)
+am__pep3147_tweak = \
+  sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.pyc __pycache__/&.*.pyo|'
+py_compile = $(top_srcdir)/py-compile
+DATA = $(pygimp_DATA)
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+  $(RECURSIVE_TARGETS) \
+  $(RECURSIVE_CLEAN_TARGETS) \
+  $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+	distdir distdir-am
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = $(SUBDIRS)
+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp \
+	$(top_srcdir)/py-compile py-compile
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+AA_LIBS = @AA_LIBS@
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+ALL_LINGUAS = @ALL_LINGUAS@
+ALSA_CFLAGS = @ALSA_CFLAGS@
+ALSA_LIBS = @ALSA_LIBS@
+ALTIVEC_EXTRA_CFLAGS = @ALTIVEC_EXTRA_CFLAGS@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+APPSTREAM_UTIL = @APPSTREAM_UTIL@
+AR = @AR@
+AS = @AS@
+ATK_CFLAGS = @ATK_CFLAGS@
+ATK_LIBS = @ATK_LIBS@
+ATK_REQUIRED_VERSION = @ATK_REQUIRED_VERSION@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BABL_CFLAGS = @BABL_CFLAGS@
+BABL_LIBS = @BABL_LIBS@
+BABL_REQUIRED_VERSION = @BABL_REQUIRED_VERSION@
+BUG_REPORT_URL = @BUG_REPORT_URL@
+BUILD_EXEEXT = @BUILD_EXEEXT@
+BUILD_OBJEXT = @BUILD_OBJEXT@
+BZIP2_LIBS = @BZIP2_LIBS@
+CAIRO_CFLAGS = @CAIRO_CFLAGS@
+CAIRO_LIBS = @CAIRO_LIBS@
+CAIRO_PDF_CFLAGS = @CAIRO_PDF_CFLAGS@
+CAIRO_PDF_LIBS = @CAIRO_PDF_LIBS@
+CAIRO_PDF_REQUIRED_VERSION = @CAIRO_PDF_REQUIRED_VERSION@
+CAIRO_REQUIRED_VERSION = @CAIRO_REQUIRED_VERSION@
+CATALOGS = @CATALOGS@
+CATOBJEXT = @CATOBJEXT@
+CC = @CC@
+CCAS = @CCAS@
+CCASDEPMODE = @CCASDEPMODE@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CC_FOR_BUILD = @CC_FOR_BUILD@
+CC_VERSION = @CC_VERSION@
+CFLAGS = @CFLAGS@
+CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@
+CPP_FOR_BUILD = @CPP_FOR_BUILD@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DATADIRNAME = @DATADIRNAME@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DESKTOP_DATADIR = @DESKTOP_DATADIR@
+DESKTOP_FILE_VALIDATE = @DESKTOP_FILE_VALIDATE@
+DLLTOOL = @DLLTOOL@
+DOC_SHOOTER = @DOC_SHOOTER@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+FILE_AA = @FILE_AA@
+FILE_EXR = @FILE_EXR@
+FILE_HEIF = @FILE_HEIF@
+FILE_JP2_LOAD = @FILE_JP2_LOAD@
+FILE_JPEGXL = @FILE_JPEGXL@
+FILE_MNG = @FILE_MNG@
+FILE_PDF_SAVE = @FILE_PDF_SAVE@
+FILE_PS = @FILE_PS@
+FILE_WMF = @FILE_WMF@
+FILE_XMC = @FILE_XMC@
+FILE_XPM = @FILE_XPM@
+FONTCONFIG_CFLAGS = @FONTCONFIG_CFLAGS@
+FONTCONFIG_LIBS = @FONTCONFIG_LIBS@
+FONTCONFIG_REQUIRED_VERSION = @FONTCONFIG_REQUIRED_VERSION@
+FREETYPE2_REQUIRED_VERSION = @FREETYPE2_REQUIRED_VERSION@
+FREETYPE_CFLAGS = @FREETYPE_CFLAGS@
+FREETYPE_LIBS = @FREETYPE_LIBS@
+GDBUS_CODEGEN = @GDBUS_CODEGEN@
+GDK_PIXBUF_CFLAGS = @GDK_PIXBUF_CFLAGS@
+GDK_PIXBUF_CSOURCE = @GDK_PIXBUF_CSOURCE@
+GDK_PIXBUF_LIBS = @GDK_PIXBUF_LIBS@
+GDK_PIXBUF_REQUIRED_VERSION = @GDK_PIXBUF_REQUIRED_VERSION@
+GEGL = @GEGL@
+GEGL_CFLAGS = @GEGL_CFLAGS@
+GEGL_LIBS = @GEGL_LIBS@
+GEGL_MAJOR_MINOR_VERSION = @GEGL_MAJOR_MINOR_VERSION@
+GEGL_REQUIRED_VERSION = @GEGL_REQUIRED_VERSION@
+GETTEXT_PACKAGE = @GETTEXT_PACKAGE@
+GEXIV2_CFLAGS = @GEXIV2_CFLAGS@
+GEXIV2_LIBS = @GEXIV2_LIBS@
+GEXIV2_REQUIRED_VERSION = @GEXIV2_REQUIRED_VERSION@
+GIMP_API_VERSION = @GIMP_API_VERSION@
+GIMP_APP_VERSION = @GIMP_APP_VERSION@
+GIMP_BINARY_AGE = @GIMP_BINARY_AGE@
+GIMP_COMMAND = @GIMP_COMMAND@
+GIMP_DATA_VERSION = @GIMP_DATA_VERSION@
+GIMP_FULL_NAME = @GIMP_FULL_NAME@
+GIMP_INTERFACE_AGE = @GIMP_INTERFACE_AGE@
+GIMP_MAJOR_VERSION = @GIMP_MAJOR_VERSION@
+GIMP_MICRO_VERSION = @GIMP_MICRO_VERSION@
+GIMP_MINOR_VERSION = @GIMP_MINOR_VERSION@
+GIMP_MKENUMS = @GIMP_MKENUMS@
+GIMP_MODULES = @GIMP_MODULES@
+GIMP_PACKAGE_REVISION = @GIMP_PACKAGE_REVISION@
+GIMP_PKGCONFIG_VERSION = @GIMP_PKGCONFIG_VERSION@
+GIMP_PLUGINS = @GIMP_PLUGINS@
+GIMP_PLUGIN_VERSION = @GIMP_PLUGIN_VERSION@
+GIMP_REAL_VERSION = @GIMP_REAL_VERSION@
+GIMP_RELEASE = @GIMP_RELEASE@
+GIMP_SYSCONF_VERSION = @GIMP_SYSCONF_VERSION@
+GIMP_TOOL_VERSION = @GIMP_TOOL_VERSION@
+GIMP_UNSTABLE = @GIMP_UNSTABLE@
+GIMP_USER_VERSION = @GIMP_USER_VERSION@
+GIMP_VERSION = @GIMP_VERSION@
+GIO_CFLAGS = @GIO_CFLAGS@
+GIO_LIBS = @GIO_LIBS@
+GIO_UNIX_CFLAGS = @GIO_UNIX_CFLAGS@
+GIO_UNIX_LIBS = @GIO_UNIX_LIBS@
+GIO_WINDOWS_CFLAGS = @GIO_WINDOWS_CFLAGS@
+GIO_WINDOWS_LIBS = @GIO_WINDOWS_LIBS@
+GLIB_CFLAGS = @GLIB_CFLAGS@
+GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@
+GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
+GLIB_LIBS = @GLIB_LIBS@
+GLIB_MKENUMS = @GLIB_MKENUMS@
+GLIB_REQUIRED_VERSION = @GLIB_REQUIRED_VERSION@
+GMODULE_NO_EXPORT_CFLAGS = @GMODULE_NO_EXPORT_CFLAGS@
+GMODULE_NO_EXPORT_LIBS = @GMODULE_NO_EXPORT_LIBS@
+GMOFILES = @GMOFILES@
+GMSGFMT = @GMSGFMT@
+GOBJECT_QUERY = @GOBJECT_QUERY@
+GREP = @GREP@
+GS_LIBS = @GS_LIBS@
+GTKDOC_CHECK = @GTKDOC_CHECK@
+GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
+GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
+GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
+GTKDOC_MKPDF = @GTKDOC_MKPDF@
+GTKDOC_REBASE = @GTKDOC_REBASE@
+GTK_CFLAGS = @GTK_CFLAGS@
+GTK_LIBS = @GTK_LIBS@
+GTK_MAC_INTEGRATION_CFLAGS = @GTK_MAC_INTEGRATION_CFLAGS@
+GTK_MAC_INTEGRATION_LIBS = @GTK_MAC_INTEGRATION_LIBS@
+GTK_REQUIRED_VERSION = @GTK_REQUIRED_VERSION@
+GTK_UPDATE_ICON_CACHE = @GTK_UPDATE_ICON_CACHE@
+GUDEV_CFLAGS = @GUDEV_CFLAGS@
+GUDEV_LIBS = @GUDEV_LIBS@
+HARFBUZZ_CFLAGS = @HARFBUZZ_CFLAGS@
+HARFBUZZ_LIBS = @HARFBUZZ_LIBS@
+HARFBUZZ_REQUIRED_VERSION = @HARFBUZZ_REQUIRED_VERSION@
+HAVE_CXX14 = @HAVE_CXX14@
+HAVE_FINITE = @HAVE_FINITE@
+HAVE_ISFINITE = @HAVE_ISFINITE@
+HAVE_VFORK = @HAVE_VFORK@
+HOST_GLIB_COMPILE_RESOURCES = @HOST_GLIB_COMPILE_RESOURCES@
+HTML_DIR = @HTML_DIR@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INSTOBJEXT = @INSTOBJEXT@
+INTLLIBS = @INTLLIBS@
+INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@
+INTLTOOL_MERGE = @INTLTOOL_MERGE@
+INTLTOOL_PERL = @INTLTOOL_PERL@
+INTLTOOL_REQUIRED_VERSION = @INTLTOOL_REQUIRED_VERSION@
+INTLTOOL_UPDATE = @INTLTOOL_UPDATE@
+INTLTOOL_V_MERGE = @INTLTOOL_V_MERGE@
+INTLTOOL_V_MERGE_OPTIONS = @INTLTOOL_V_MERGE_OPTIONS@
+INTLTOOL__v_MERGE_ = @INTLTOOL__v_MERGE_@
+INTLTOOL__v_MERGE_0 = @INTLTOOL__v_MERGE_0@
+INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@
+ISO_CODES_LOCALEDIR = @ISO_CODES_LOCALEDIR@
+ISO_CODES_LOCATION = @ISO_CODES_LOCATION@
+JPEG_LIBS = @JPEG_LIBS@
+JSON_GLIB_CFLAGS = @JSON_GLIB_CFLAGS@
+JSON_GLIB_LIBS = @JSON_GLIB_LIBS@
+JXL_CFLAGS = @JXL_CFLAGS@
+JXL_LIBS = @JXL_LIBS@
+JXL_THREADS_CFLAGS = @JXL_THREADS_CFLAGS@
+JXL_THREADS_LIBS = @JXL_THREADS_LIBS@
+LCMS_CFLAGS = @LCMS_CFLAGS@
+LCMS_LIBS = @LCMS_LIBS@
+LCMS_REQUIRED_VERSION = @LCMS_REQUIRED_VERSION@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
+LIBBACKTRACE_LIBS = @LIBBACKTRACE_LIBS@
+LIBHEIF_CFLAGS = @LIBHEIF_CFLAGS@
+LIBHEIF_LIBS = @LIBHEIF_LIBS@
+LIBHEIF_REQUIRED_VERSION = @LIBHEIF_REQUIRED_VERSION@
+LIBJXL_REQUIRED_VERSION = @LIBJXL_REQUIRED_VERSION@
+LIBLZMA_REQUIRED_VERSION = @LIBLZMA_REQUIRED_VERSION@
+LIBMYPAINT_CFLAGS = @LIBMYPAINT_CFLAGS@
+LIBMYPAINT_LIBS = @LIBMYPAINT_LIBS@
+LIBMYPAINT_REQUIRED_VERSION = @LIBMYPAINT_REQUIRED_VERSION@
+LIBOBJS = @LIBOBJS@
+LIBPNG_REQUIRED_VERSION = @LIBPNG_REQUIRED_VERSION@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBUNWIND_CFLAGS = @LIBUNWIND_CFLAGS@
+LIBUNWIND_LIBS = @LIBUNWIND_LIBS@
+LIBUNWIND_REQUIRED_VERSION = @LIBUNWIND_REQUIRED_VERSION@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_CURRENT_MINUS_AGE = @LT_CURRENT_MINUS_AGE@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+LT_VERSION_INFO = @LT_VERSION_INFO@
+LZMA_CFLAGS = @LZMA_CFLAGS@
+LZMA_LIBS = @LZMA_LIBS@
+MAIL = @MAIL@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MIME_INFO_CFLAGS = @MIME_INFO_CFLAGS@
+MIME_INFO_LIBS = @MIME_INFO_LIBS@
+MIME_TYPES = @MIME_TYPES@
+MKDIR_P = @MKDIR_P@
+MKINSTALLDIRS = @MKINSTALLDIRS@
+MMX_EXTRA_CFLAGS = @MMX_EXTRA_CFLAGS@
+MNG_CFLAGS = @MNG_CFLAGS@
+MNG_LIBS = @MNG_LIBS@
+MSGFMT = @MSGFMT@
+MSGFMT_OPTS = @MSGFMT_OPTS@
+MSGMERGE = @MSGMERGE@
+MYPAINT_BRUSHES_CFLAGS = @MYPAINT_BRUSHES_CFLAGS@
+MYPAINT_BRUSHES_LIBS = @MYPAINT_BRUSHES_LIBS@
+NATIVE_GLIB_CFLAGS = @NATIVE_GLIB_CFLAGS@
+NATIVE_GLIB_LIBS = @NATIVE_GLIB_LIBS@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPENEXR_CFLAGS = @OPENEXR_CFLAGS@
+OPENEXR_LIBS = @OPENEXR_LIBS@
+OPENEXR_REQUIRED_VERSION = @OPENEXR_REQUIRED_VERSION@
+OPENJPEG_CFLAGS = @OPENJPEG_CFLAGS@
+OPENJPEG_LIBS = @OPENJPEG_LIBS@
+OPENJPEG_REQUIRED_VERSION = @OPENJPEG_REQUIRED_VERSION@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PANGOCAIRO_CFLAGS = @PANGOCAIRO_CFLAGS@
+PANGOCAIRO_LIBS = @PANGOCAIRO_LIBS@
+PANGOCAIRO_REQUIRED_VERSION = @PANGOCAIRO_REQUIRED_VERSION@
+PATHSEP = @PATHSEP@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PERL = @PERL@
+PERL_REQUIRED_VERSION = @PERL_REQUIRED_VERSION@
+PERL_VERSION = @PERL_VERSION@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+PNG_CFLAGS = @PNG_CFLAGS@
+PNG_LIBS = @PNG_LIBS@
+POFILES = @POFILES@
+POPPLER_CFLAGS = @POPPLER_CFLAGS@
+POPPLER_DATA_CFLAGS = @POPPLER_DATA_CFLAGS@
+POPPLER_DATA_LIBS = @POPPLER_DATA_LIBS@
+POPPLER_DATA_REQUIRED_VERSION = @POPPLER_DATA_REQUIRED_VERSION@
+POPPLER_LIBS = @POPPLER_LIBS@
+POPPLER_REQUIRED_VERSION = @POPPLER_REQUIRED_VERSION@
+POSUB = @POSUB@
+PO_IN_DATADIR_FALSE = @PO_IN_DATADIR_FALSE@
+PO_IN_DATADIR_TRUE = @PO_IN_DATADIR_TRUE@
+PYBIN_PATH = @PYBIN_PATH@
+PYCAIRO_CFLAGS = @PYCAIRO_CFLAGS@
+PYCAIRO_LIBS = @PYCAIRO_LIBS@
+PYGIMP_EXTRA_CFLAGS = @PYGIMP_EXTRA_CFLAGS@
+PYGTK_CFLAGS = @PYGTK_CFLAGS@
+PYGTK_CODEGEN = @PYGTK_CODEGEN@
+PYGTK_DEFSDIR = @PYGTK_DEFSDIR@
+PYGTK_LIBS = @PYGTK_LIBS@
+PYLINK_LIBS = @PYLINK_LIBS@
+PYTHON = @PYTHON@
+PYTHON2_REQUIRED_VERSION = @PYTHON2_REQUIRED_VERSION@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_INCLUDES = @PYTHON_INCLUDES@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+RSVG_REQUIRED_VERSION = @RSVG_REQUIRED_VERSION@
+RT_LIBS = @RT_LIBS@
+SCREENSHOT_LIBS = @SCREENSHOT_LIBS@
+SED = @SED@
+SENDMAIL = @SENDMAIL@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SOCKET_LIBS = @SOCKET_LIBS@
+SSE2_EXTRA_CFLAGS = @SSE2_EXTRA_CFLAGS@
+SSE4_1_EXTRA_CFLAGS = @SSE4_1_EXTRA_CFLAGS@
+SSE_EXTRA_CFLAGS = @SSE_EXTRA_CFLAGS@
+STRIP = @STRIP@
+SVG_CFLAGS = @SVG_CFLAGS@
+SVG_LIBS = @SVG_LIBS@
+SYMPREFIX = @SYMPREFIX@
+TIFF_LIBS = @TIFF_LIBS@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+WEBKIT_CFLAGS = @WEBKIT_CFLAGS@
+WEBKIT_LIBS = @WEBKIT_LIBS@
+WEBKIT_REQUIRED_VERSION = @WEBKIT_REQUIRED_VERSION@
+WEBPDEMUX_CFLAGS = @WEBPDEMUX_CFLAGS@
+WEBPDEMUX_LIBS = @WEBPDEMUX_LIBS@
+WEBPMUX_CFLAGS = @WEBPMUX_CFLAGS@
+WEBPMUX_LIBS = @WEBPMUX_LIBS@
+WEBP_CFLAGS = @WEBP_CFLAGS@
+WEBP_LIBS = @WEBP_LIBS@
+WEBP_REQUIRED_VERSION = @WEBP_REQUIRED_VERSION@
+WEB_PAGE = @WEB_PAGE@
+WIN32_LARGE_ADDRESS_AWARE = @WIN32_LARGE_ADDRESS_AWARE@
+WINDRES = @WINDRES@
+WMF_CFLAGS = @WMF_CFLAGS@
+WMF_CONFIG = @WMF_CONFIG@
+WMF_LIBS = @WMF_LIBS@
+WMF_REQUIRED_VERSION = @WMF_REQUIRED_VERSION@
+XDG_EMAIL = @XDG_EMAIL@
+XFIXES_CFLAGS = @XFIXES_CFLAGS@
+XFIXES_LIBS = @XFIXES_LIBS@
+XGETTEXT = @XGETTEXT@
+XGETTEXT_REQUIRED_VERSION = @XGETTEXT_REQUIRED_VERSION@
+XMC_CFLAGS = @XMC_CFLAGS@
+XMC_LIBS = @XMC_LIBS@
+XMKMF = @XMKMF@
+XMLLINT = @XMLLINT@
+XMU_LIBS = @XMU_LIBS@
+XPM_LIBS = @XPM_LIBS@
+XSLTPROC = @XSLTPROC@
+XVFB_RUN = @XVFB_RUN@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+Z_LIBS = @Z_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CC_FOR_BUILD = @ac_ct_CC_FOR_BUILD@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+gimpdatadir = @gimpdatadir@
+gimpdir = @gimpdir@
+gimplocaledir = @gimplocaledir@
+gimpplugindir = @gimpplugindir@
+gimpsysconfdir = @gimpsysconfdir@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+intltool__v_merge_options_ = @intltool__v_merge_options_@
+intltool__v_merge_options_0 = @intltool__v_merge_options_0@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+manpage_gimpdir = @manpage_gimpdir@
+mkdir_p = @mkdir_p@
+ms_librarian = @ms_librarian@
+mypaint_brushes_dir = @mypaint_brushes_dir@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+libgimpui = $(top_builddir)/libgimp/libgimpui-$(GIMP_API_VERSION).la
+libgimpconfig = $(top_builddir)/libgimpconfig/libgimpconfig-$(GIMP_API_VERSION).la
+libgimpwidgets = $(top_builddir)/libgimpwidgets/libgimpwidgets-$(GIMP_API_VERSION).la
+libgimp = $(top_builddir)/libgimp/libgimp-$(GIMP_API_VERSION).la
+libgimpcolor = $(top_builddir)/libgimpcolor/libgimpcolor-$(GIMP_API_VERSION).la
+libgimpbase = $(top_builddir)/libgimpbase/libgimpbase-$(GIMP_API_VERSION).la
+libgimpmath = $(top_builddir)/libgimpmath/libgimpmath-$(GIMP_API_VERSION).la
+libgimpthumb = $(top_builddir)/libgimpthumb/libgimpthumb-$(GIMP_API_VERSION).la
+SUBDIRS = plug-ins
+@PLATFORM_WIN32_TRUE@no_undefined = -no-undefined
+@PLATFORM_WIN32_TRUE@shrext = -shrext .pyd
+@PLATFORM_WIN32_FALSE@path_separator = :
+@PLATFORM_WIN32_TRUE@path_separator = ;
+AM_CFLAGS = $(PYGIMP_EXTRA_CFLAGS)
+AM_CPPFLAGS = \
+	-I$(top_srcdir)		\
+	$(PYTHON_INCLUDES)	\
+	$(PYGTK_CFLAGS)		\
+	$(PYCAIRO_CFLAGS)	\
+	$(GTK_CFLAGS)		\
+	$(GEGL_CFLAGS)
+
+pygimpbase = python
+pygimpdir = $(gimpplugindir)/$(pygimpbase)
+pygimp_LTLIBRARIES = gimp.la _gimpenums.la gimpcolor.la _gimpui.la \
+	gimpthumb.la
+
+gimp_la_SOURCES = \
+	gimpmodule.c		\
+	pygimp-item.c		\
+	pygimp-display.c	\
+	pygimp-drawable.c	\
+	pygimp-image.c		\
+	pygimp-parasite.c	\
+	pygimp-pdb.c		\
+	pygimp-tile.c		\
+	pygimp-vectors.c	\
+	pygimp.h		\
+	pygimp-api.h		\
+	pygimp-intl.h		\
+	pygimp-util.h
+
+gimp_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimp
+
+gimp_la_LIBADD = \
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(libgimpui)		\
+	$(GLIB_LIBS)		\
+	$(GEGL_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)
+
+_gimpenums_la_SOURCES = \
+	gimpenumsmodule.c
+
+_gimpenums_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex init_gimpenums
+
+_gimpenums_la_LIBADD = \
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(GLIB_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)
+
+gimpcolor_la_SOURCES = \
+	gimpcolormodule.c	\
+	pygimp-colors.c		\
+	pygimpcolor.h		\
+	pygimpcolor-api.h
+
+gimpcolor_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimpcolor
+
+gimpcolor_la_LIBADD = \
+	$(libgimpcolor)		\
+	$(GLIB_LIBS)		\
+	$(PYLINK_LIBS)
+
+_gimpui_la_SOURCES = \
+	gimpuimodule.c		\
+	gimpui.c
+
+_gimpui_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex init_gimpui
+
+_gimpui_la_LIBADD = \
+	$(libgimpui)		\
+	$(libgimpwidgets)	\
+	$(libgimpconfig)	\
+	$(libgimpmath)		\
+	$(libgimp)		\
+	$(libgimpcolor)		\
+	$(libgimpbase)		\
+	$(GTK_LIBS)		\
+	$(PYLINK_LIBS)		\
+	$(RT_LIBS)		\
+	$(INTLLIBS)
+
+gimpthumb_la_SOURCES = \
+	gimpthumbmodule.c \
+	gimpthumb.c
+
+gimpthumb_la_LDFLAGS = -module -avoid-version $(no_undefined) $(shrext) \
+	-export-symbols-regex initgimpthumb
+
+gimpthumb_la_LIBADD = \
+	$(libgimpthumb)		\
+	$(GDK_PIXBUF_LIBS)	\
+	$(PYLINK_LIBS)
+
+pygimp_PYTHON = \
+	gimpenums.py	\
+	gimpfu.py	\
+	gimpplugin.py	\
+	gimpshelf.py	\
+	gimpui.py
+
+pygimp_DATA = pygimp-logo.png
+codegen_files = \
+	gimp-types.defs		\
+	gimpcolor-types.defs	\
+	gimpenums-types.defs	\
+	gimpthumb.defs		\
+	gimpthumb.override	\
+	gimpui.defs		\
+	gimpui.override
+
+pyenvdir = $(gimpplugindir)/environ
+pyinterpdir = $(gimpplugindir)/interpreters
+pyenvfile = $(pyenvdir)/pygimp.env
+pyinterpfile = $(pyinterpdir)/pygimp.interp
+EXTRA_DIST = \
+	$(pygimp_DATA)		\
+	$(codegen_files)
+
+CLEANFILES = gimpui.c gimpthumb.c
+all: all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .c .defs .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu plug-ins/pygimp/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu plug-ins/pygimp/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-pygimpLTLIBRARIES: $(pygimp_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(pygimp_LTLIBRARIES)'; test -n "$(pygimpdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pygimpdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pygimpdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(pygimpdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(pygimpdir)"; \
+	}
+
+uninstall-pygimpLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pygimp_LTLIBRARIES)'; test -n "$(pygimpdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(pygimpdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(pygimpdir)/$$f"; \
+	done
+
+clean-pygimpLTLIBRARIES:
+	-test -z "$(pygimp_LTLIBRARIES)" || rm -f $(pygimp_LTLIBRARIES)
+	@list='$(pygimp_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+
+_gimpenums.la: $(_gimpenums_la_OBJECTS) $(_gimpenums_la_DEPENDENCIES) $(EXTRA__gimpenums_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(_gimpenums_la_LINK) -rpath $(pygimpdir) $(_gimpenums_la_OBJECTS) $(_gimpenums_la_LIBADD) $(LIBS)
+
+_gimpui.la: $(_gimpui_la_OBJECTS) $(_gimpui_la_DEPENDENCIES) $(EXTRA__gimpui_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(_gimpui_la_LINK) -rpath $(pygimpdir) $(_gimpui_la_OBJECTS) $(_gimpui_la_LIBADD) $(LIBS)
+
+gimp.la: $(gimp_la_OBJECTS) $(gimp_la_DEPENDENCIES) $(EXTRA_gimp_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(gimp_la_LINK) -rpath $(pygimpdir) $(gimp_la_OBJECTS) $(gimp_la_LIBADD) $(LIBS)
+
+gimpcolor.la: $(gimpcolor_la_OBJECTS) $(gimpcolor_la_DEPENDENCIES) $(EXTRA_gimpcolor_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(gimpcolor_la_LINK) -rpath $(pygimpdir) $(gimpcolor_la_OBJECTS) $(gimpcolor_la_LIBADD) $(LIBS)
+
+gimpthumb.la: $(gimpthumb_la_OBJECTS) $(gimpthumb_la_DEPENDENCIES) $(EXTRA_gimpthumb_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(gimpthumb_la_LINK) -rpath $(pygimpdir) $(gimpthumb_la_OBJECTS) $(gimpthumb_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpcolormodule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpenumsmodule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpmodule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpthumb.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpthumbmodule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpui.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpuimodule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-colors.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-display.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-drawable.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-image.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-item.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-parasite.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-pdb.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-tile.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pygimp-vectors.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-pygimpPYTHON: $(pygimp_PYTHON)
+	@$(NORMAL_INSTALL)
+	@list='$(pygimp_PYTHON)'; dlist=; list2=; test -n "$(pygimpdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pygimpdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pygimpdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \
+	  if test -f $$b$$p; then \
+	    $(am__strip_dir) \
+	    dlist="$$dlist $$f"; \
+	    list2="$$list2 $$b$$p"; \
+	  else :; fi; \
+	done; \
+	for file in $$list2; do echo $$file; done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pygimpdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pygimpdir)" || exit $$?; \
+	done || exit $$?; \
+	if test -n "$$dlist"; then \
+	  $(am__py_compile) --destdir "$(DESTDIR)" \
+	                    --basedir "$(pygimpdir)" $$dlist; \
+	else :; fi
+
+uninstall-pygimpPYTHON:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pygimp_PYTHON)'; test -n "$(pygimpdir)" || list=; \
+	py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$py_files" || exit 0; \
+	dir='$(DESTDIR)$(pygimpdir)'; \
+	pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \
+	pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \
+	st=0; \
+	for files in "$$py_files" "$$pyc_files" "$$pyo_files"; do \
+	  $(am__uninstall_files_from_dir) || st=$$?; \
+	done; \
+	dir='$(DESTDIR)$(pygimpdir)'; \
+	echo "$$py_files" | $(am__pep3147_tweak) | $(am__base_list) | \
+	  while read files; do \
+	    $(am__uninstall_files_from_dir) || st=$$?; \
+	  done || exit $$?; \
+	exit $$st
+install-pygimpDATA: $(pygimp_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(pygimp_DATA)'; test -n "$(pygimpdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pygimpdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pygimpdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pygimpdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pygimpdir)" || exit $$?; \
+	done
+
+uninstall-pygimpDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pygimp_DATA)'; test -n "$(pygimpdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pygimpdir)'; $(am__uninstall_files_from_dir)
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+#     (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+	@fail=; \
+	if $(am__make_keepgoing); then \
+	  failcom='fail=yes'; \
+	else \
+	  failcom='exit 1'; \
+	fi; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    $(am__make_dryrun) \
+	      || test -d "$(distdir)/$$subdir" \
+	      || $(MKDIR_P) "$(distdir)/$$subdir" \
+	      || exit 1; \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(LTLIBRARIES) $(DATA)
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(pygimpdir)" "$(DESTDIR)$(pygimpdir)" "$(DESTDIR)$(pygimpdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool clean-pygimpLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-recursive
+		-rm -f ./$(DEPDIR)/gimpcolormodule.Plo
+	-rm -f ./$(DEPDIR)/gimpenumsmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpthumb.Plo
+	-rm -f ./$(DEPDIR)/gimpthumbmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpui.Plo
+	-rm -f ./$(DEPDIR)/gimpuimodule.Plo
+	-rm -f ./$(DEPDIR)/pygimp-colors.Plo
+	-rm -f ./$(DEPDIR)/pygimp-display.Plo
+	-rm -f ./$(DEPDIR)/pygimp-drawable.Plo
+	-rm -f ./$(DEPDIR)/pygimp-image.Plo
+	-rm -f ./$(DEPDIR)/pygimp-item.Plo
+	-rm -f ./$(DEPDIR)/pygimp-parasite.Plo
+	-rm -f ./$(DEPDIR)/pygimp-pdb.Plo
+	-rm -f ./$(DEPDIR)/pygimp-tile.Plo
+	-rm -f ./$(DEPDIR)/pygimp-vectors.Plo
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am: install-data-local install-pygimpDATA \
+	install-pygimpLTLIBRARIES install-pygimpPYTHON
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+		-rm -f ./$(DEPDIR)/gimpcolormodule.Plo
+	-rm -f ./$(DEPDIR)/gimpenumsmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpthumb.Plo
+	-rm -f ./$(DEPDIR)/gimpthumbmodule.Plo
+	-rm -f ./$(DEPDIR)/gimpui.Plo
+	-rm -f ./$(DEPDIR)/gimpuimodule.Plo
+	-rm -f ./$(DEPDIR)/pygimp-colors.Plo
+	-rm -f ./$(DEPDIR)/pygimp-display.Plo
+	-rm -f ./$(DEPDIR)/pygimp-drawable.Plo
+	-rm -f ./$(DEPDIR)/pygimp-image.Plo
+	-rm -f ./$(DEPDIR)/pygimp-item.Plo
+	-rm -f ./$(DEPDIR)/pygimp-parasite.Plo
+	-rm -f ./$(DEPDIR)/pygimp-pdb.Plo
+	-rm -f ./$(DEPDIR)/pygimp-tile.Plo
+	-rm -f ./$(DEPDIR)/pygimp-vectors.Plo
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-local uninstall-pygimpDATA \
+	uninstall-pygimpLTLIBRARIES uninstall-pygimpPYTHON
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+	am--depfiles check check-am clean clean-generic clean-libtool \
+	clean-pygimpLTLIBRARIES cscopelist-am ctags ctags-am distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am \
+	install-data-local install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-pygimpDATA \
+	install-pygimpLTLIBRARIES install-pygimpPYTHON install-strip \
+	installcheck installcheck-am installdirs installdirs-am \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
+	uninstall-local uninstall-pygimpDATA \
+	uninstall-pygimpLTLIBRARIES uninstall-pygimpPYTHON
+
+.PRECIOUS: Makefile
+
+
+install-env-file:
+	$(mkinstalldirs) '$(DESTDIR)$(pyenvdir)'
+	echo '$(path_separator) PYTHONPATH=$${gimp_plug_in_dir}/$(pygimpbase)' > '$(DESTDIR)$(pyenvfile)'
+
+install-interp-file:
+	$(mkinstalldirs) '$(DESTDIR)$(pyinterpdir)'
+	echo 'python=$(PYBIN_PATH)' > '$(DESTDIR)$(pyinterpfile)'
+	echo 'python2=$(PYBIN_PATH)' >> '$(DESTDIR)$(pyinterpfile)'
+	echo '/usr/bin/python=$(PYBIN_PATH)' >> '$(DESTDIR)$(pyinterpfile)'
+	echo ":Python:E::py::`basename $(PYTHON)`:" >> '$(DESTDIR)$(pyinterpfile)'
+
+install-data-local: install-env-file install-interp-file
+
+uninstall-local:
+	rm -f '$(DESTDIR)$(pyenvfile)' '$(DESTDIR)$(pyinterpfile)'
+
+gimpui.c: gimpui.defs gimpui.override gimp-types.defs gimpcolor-types.defs gimpenums-types.defs
+
+gimpthumb.c: gimpthumb.defs gimpthumb.override
+
+.defs.c:
+	(cd $(srcdir) \
+	 && $(PYGTK_CODEGEN) \
+	    --override $*.override \
+	    --register $(PYGTK_DEFSDIR)/gdk-types.defs \
+	    --register $(PYGTK_DEFSDIR)/gtk-types.defs \
+	    --register gimp-types.defs \
+	    --register gimpcolor-types.defs \
+	    --register gimpenums-types.defs \
+	    --prefix $* $*.defs) > gen-$*.c \
+	 && cp gen-$*.c $*.c \
+	 && rm -f gen-$*.c
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/plug-ins/pygimp/gimp-types.defs b/plug-ins/pygimp/gimp-types.defs
new file mode 100644
index 0000000..0158ede
--- /dev/null
+++ b/plug-ins/pygimp/gimp-types.defs
@@ -0,0 +1,9 @@
+;; -*- scheme -*-
+
+;; from libgimpbase, implemented manually in pygimp-parasite.c
+
+(define-boxed GimpParasite
+  (in-module "Gimp")
+  (c-name "GimpParasite")
+  (gtype-id "GIMP_TYPE_PARASITE")
+)
diff --git a/plug-ins/pygimp/gimpcolor-types.defs b/plug-ins/pygimp/gimpcolor-types.defs
new file mode 100644
index 0000000..460ac92
--- /dev/null
+++ b/plug-ins/pygimp/gimpcolor-types.defs
@@ -0,0 +1,25 @@
+;; -*- scheme -*-
+
+(define-boxed GimpRGB
+  (in-module "Gimp")
+  (c-name "GimpRGB")
+  (gtype-id "GIMP_TYPE_RGB")
+)
+
+(define-boxed GimpHSV
+  (in-module "Gimp")
+  (c-name "GimpHSV")
+  (gtype-id "GIMP_TYPE_HSV")
+)
+
+(define-boxed GimpHSL
+  (in-module "Gimp")
+  (c-name "GimpHSL")
+  (gtype-id "GIMP_TYPE_HSL")
+)
+
+(define-boxed GimpCMYK
+  (in-module "Gimp")
+  (c-name "GimpCMYK")
+  (gtype-id "GIMP_TYPE_CMYK")
+)
diff --git a/plug-ins/pygimp/gimpcolormodule.c b/plug-ins/pygimp/gimpcolormodule.c
new file mode 100644
index 0000000..8b4a478
--- /dev/null
+++ b/plug-ins/pygimp/gimpcolormodule.c
@@ -0,0 +1,433 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005-2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "pygimpcolor.h"
+
+#define _INSIDE_PYGIMPCOLOR_
+#include "pygimpcolor-api.h"
+
+#include "pygimp-util.h"
+
+
+static PyObject *
+pygimp_rgb_parse_name(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *name;
+    int len;
+    GimpRGB rgb;
+    gboolean success;
+    static char *kwlist[] = { "name", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:rgb_parse_name", kwlist,
+				     &name, &len))
+        return NULL;
+
+    rgb.a = 1.0;
+    success = gimp_rgb_parse_name(&rgb, name, len);
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse color name");
+	return NULL;
+    }
+
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_rgb_parse_hex(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *hex;
+    int len;
+    GimpRGB rgb;
+    gboolean success;
+    static char *kwlist[] = { "hex", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:rgb_parse_hex", kwlist,
+				     &hex, &len))
+        return NULL;
+
+    rgb.a = 1.0;
+    success = gimp_rgb_parse_hex(&rgb, hex, len);
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse hex value");
+	return NULL;
+    }
+
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_rgb_parse_css(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *css;
+    int len;
+    GimpRGB rgb;
+    gboolean success, with_alpha = FALSE;
+    static char *kwlist[] = { "css", "with_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "s#|i:rgb_parse_css", kwlist,
+				     &css, &len, &with_alpha))
+        return NULL;
+
+    if (with_alpha)
+	success = gimp_rgba_parse_css(&rgb, css, len);
+    else {
+	rgb.a = 1.0;
+	success = gimp_rgb_parse_css(&rgb, css, len);
+    }
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse CSS color");
+	return NULL;
+    }
+
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_rgb_list_names(PyObject *self)
+{
+    int num_names, i;
+    const char **names;
+    GimpRGB *colors;
+    PyObject *dict, *color;
+
+    num_names = gimp_rgb_list_names(&names, &colors);
+
+    dict = PyDict_New();
+    if (!dict)
+        goto cleanup;
+
+    for (i = 0; i < num_names; i++) {
+        color = pygimp_rgb_new(&colors[i]);
+
+	if (!color)
+	    goto bail;
+
+	if (PyDict_SetItemString(dict, names[i], color) < 0) {
+	    Py_DECREF(color);
+	    goto bail;
+	}
+
+	Py_DECREF(color);
+    }
+
+    goto cleanup;
+
+bail:
+    Py_DECREF(dict);
+    dict = NULL;
+
+cleanup:
+    g_free(names);
+    g_free(colors);
+
+    return dict;
+}
+
+static PyObject *
+pygimp_bilinear(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    gdouble x, y;
+    gdouble values[4];
+    PyObject *py_values;
+    static char *kwlist[] = { "x", "y", "values", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddO:bilinear", kwlist,
+				     &x, &y, &py_values))
+  	return NULL;
+
+    if (PyString_Check(py_values)) {
+        if (PyString_Size(py_values) == 4) {
+            guchar ret;
+            ret = gimp_bilinear_8(x, y, (guchar *)PyString_AsString(py_values));
+            return PyString_FromStringAndSize((char *)&ret, 1);
+        }
+    } else if (PySequence_Check(py_values)) {
+        if (PySequence_Size(py_values) == 4) {
+            int i;
+            for (i = 0; i < 4; i++) {
+                PyObject *v;
+                v = PySequence_GetItem(py_values, i);
+                values[i] = PyFloat_AsDouble(v);
+                Py_DECREF(v);
+            }
+            return PyFloat_FromDouble(gimp_bilinear(x, y, values));
+        }
+    }
+
+    PyErr_SetString(PyExc_TypeError, "values is not a sequence of 4 items");
+    return NULL;
+}
+
+static PyObject *
+pygimp_bilinear_color(PyObject *self, PyObject *args, PyObject *kwargs, gboolean with_alpha)
+{
+    gdouble x, y;
+    GimpRGB values[4];
+    GimpRGB rgb;
+    PyObject *py_values, *v;
+    int i, success;
+    static char *kwlist[] = { "x", "y", "values", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     with_alpha ? "ddO:bilinear_rgba"
+                                               : "ddO:bilinear_rgb",
+                                     kwlist,
+                                     &x, &y, &py_values))
+        return NULL;
+
+    if (!PySequence_Check(py_values) || PySequence_Size(py_values) != 4) {
+        PyErr_SetString(PyExc_TypeError, "values is not a sequence of 4 items");
+        return NULL;
+    }
+
+    for (i = 0; i < 4; i++) {
+        v = PySequence_GetItem(py_values, i);
+        success = pygimp_rgb_from_pyobject(v, &values[i]);
+        Py_DECREF(v);
+        if (!success) {
+            PyErr_Format(PyExc_TypeError, "values[%d] is not a GimpRGB", i);
+            return NULL;
+        }
+    }
+
+    if (with_alpha)
+        rgb = gimp_bilinear_rgba(x, y, values);
+    else
+        rgb = gimp_bilinear_rgb(x, y, values);
+
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_bilinear_rgb(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    return pygimp_bilinear_color(self, args, kwargs, FALSE);
+}
+
+static PyObject *
+pygimp_bilinear_rgba(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    return pygimp_bilinear_color(self, args, kwargs, TRUE);
+}
+
+#if 0
+static PyObject *
+pygimp_bilinear_pixels_8(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+typedef struct
+{
+    PyObject *func;
+    PyObject *data;
+} ProxyData;
+
+static void
+proxy_render(gdouble x, gdouble y, GimpRGB *color, gpointer pdata)
+{
+    ProxyData *data = pdata;
+
+    if (data->data)
+	PyObject_CallFunction(data->func, "ddO&O", x, y, pygimp_rgb_new, color,
+			      data->data);
+    else
+	PyObject_CallFunction(data->func, "ddO&", x, y, pygimp_rgb_new, color);
+}
+
+static void
+proxy_put_pixel(gint x, gint y, GimpRGB *color, gpointer pdata)
+{
+    ProxyData *data = pdata;
+
+    if (data->data)
+	PyObject_CallFunction(data->func, "iiO&O", x, y, pygimp_rgb_new, color,
+			      data->data);
+    else
+	PyObject_CallFunction(data->func, "iiO&", x, y, pygimp_rgb_new, color);
+}
+
+static void
+proxy_progress(gint min, gint max, gint current, gpointer pdata)
+{
+    ProxyData *data = pdata;
+
+    if (data->data)
+	PyObject_CallFunction(data->func, "iiiO", min, max, current,
+			      data->data);
+    else
+	PyObject_CallFunction(data->func, "iii", min, max, current);
+}
+
+static PyObject *
+pygimp_adaptive_supersample_area(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    gulong r;
+
+    gint x1, y1, x2, y2, max_depth;
+    gdouble threshold;
+    PyObject *py_func_render = NULL, *py_data_render = NULL;
+    PyObject *py_func_put_pixel = NULL, *py_data_put_pixel = NULL;
+    PyObject *py_func_progress = NULL, *py_data_progress = NULL;
+
+    GimpRenderFunc proxy_func_render = NULL;
+    GimpPutPixelFunc proxy_func_put_pixel = NULL;
+    GimpProgressFunc proxy_func_progress = NULL;
+
+    ProxyData proxy_data_render, proxy_data_put_pixel, proxy_data_progress;
+
+    static char *kwlist[] = {
+	"x1", "y1", "x2", "y2", "max_depth", "threshold",
+	"render_func", "render_data",
+        "put_pixel_func", "put_pixel_data",
+        "progress_func", "progress_data",
+        NULL
+    };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "iiiiid|OOOOOO"
+				     ":adaptive_supersample_area",
+				     kwlist,
+				     &x1, &y1, &x2, &y2, &max_depth, &threshold,
+				     &py_func_render, &py_data_render,
+				     &py_func_put_pixel, &py_data_put_pixel,
+				     &py_func_progress, &py_data_progress))
+	return NULL;
+
+#define PROCESS_FUNC(n)	G_STMT_START {					\
+    if (py_func_##n != NULL) {						\
+        if (!PyCallable_Check(py_func_##n)) {				\
+	    PyErr_SetString(PyExc_TypeError, #n "_func "		\
+			    "must be callable");			\
+	    return NULL;						\
+	}								\
+									\
+	proxy_func_##n = proxy_##n;					\
+									\
+	proxy_data_##n.func = py_func_##n;				\
+	proxy_data_##n.data = py_data_##n;				\
+    }									\
+} G_STMT_END
+
+    PROCESS_FUNC(render);
+    PROCESS_FUNC(put_pixel);
+    PROCESS_FUNC(progress);
+
+#undef PROCESS_FUNC
+
+#define PASS_FUNC(n) proxy_func_##n, &proxy_data_##n
+
+    r = gimp_adaptive_supersample_area (x1, y1, x2, y2, max_depth, threshold,
+					PASS_FUNC(render),
+					PASS_FUNC(put_pixel),
+					PASS_FUNC(progress));
+
+#undef PASS_FUNC
+
+    return PyInt_FromLong(r);
+}
+#endif
+
+/* List of methods defined in the module */
+
+static struct PyMethodDef gimpcolor_methods[] = {
+    {"rgb_parse_name", (PyCFunction)pygimp_rgb_parse_name, METH_VARARGS | METH_KEYWORDS},
+    {"rgb_parse_hex", (PyCFunction)pygimp_rgb_parse_hex, METH_VARARGS | METH_KEYWORDS},
+    {"rgb_parse_css", (PyCFunction)pygimp_rgb_parse_css, METH_VARARGS | METH_KEYWORDS},
+    {"rgb_names", (PyCFunction)pygimp_rgb_list_names, METH_NOARGS},
+    {"bilinear", (PyCFunction)pygimp_bilinear, METH_VARARGS | METH_KEYWORDS},
+    {"bilinear_rgb", (PyCFunction)pygimp_bilinear_rgb, METH_VARARGS | METH_KEYWORDS},
+    {"bilinear_rgba", (PyCFunction)pygimp_bilinear_rgba, METH_VARARGS | METH_KEYWORDS},
+#if 0
+    {"bilinear_pixels_8", (PyCFunction)pygimp_bilinear_pixels_8, METH_VARARGS | METH_KEYWORDS},
+    {"adaptive_supersample_area", (PyCFunction)pygimp_adaptive_supersample_area, METH_VARARGS | METH_KEYWORDS},
+#endif
+    {NULL,	 (PyCFunction)NULL, 0, NULL}		/* sentinel */
+};
+
+
+static struct _PyGimpColor_Functions pygimpcolor_api_functions = {
+    &PyGimpRGB_Type,
+    pygimp_rgb_new,
+    &PyGimpHSV_Type,
+    pygimp_hsv_new,
+    &PyGimpHSL_Type,
+    pygimp_hsl_new,
+    &PyGimpCMYK_Type,
+    pygimp_cmyk_new,
+    pygimp_rgb_from_pyobject
+};
+
+
+/* Initialization function for the module (*must* be called initgimpcolor) */
+
+static char gimpcolor_doc[] =
+"This module provides interfaces to allow you to write gimp plug-ins"
+;
+
+void initgimpcolor(void);
+
+PyMODINIT_FUNC
+initgimpcolor(void)
+{
+    PyObject *m, *d;
+
+    pygimp_init_pygobject();
+
+    /* Create the module and add the functions */
+    m = Py_InitModule3("gimpcolor", gimpcolor_methods, gimpcolor_doc);
+
+    d = PyModule_GetDict(m);
+
+    pyg_register_boxed(d, "RGB", GIMP_TYPE_RGB, &PyGimpRGB_Type);
+    pyg_register_boxed(d, "HSV", GIMP_TYPE_HSV, &PyGimpHSV_Type);
+    pyg_register_boxed(d, "HSL", GIMP_TYPE_HSL, &PyGimpHSL_Type);
+    pyg_register_boxed(d, "CMYK", GIMP_TYPE_CMYK, &PyGimpCMYK_Type);
+
+    PyModule_AddObject(m, "RGB_COMPOSITE_NONE",
+		       PyInt_FromLong(GIMP_RGB_COMPOSITE_NONE));
+    PyModule_AddObject(m, "RGB_COMPOSITE_NORMAL",
+		       PyInt_FromLong(GIMP_RGB_COMPOSITE_NORMAL));
+    PyModule_AddObject(m, "RGB_COMPOSITE_BEHIND",
+		       PyInt_FromLong(GIMP_RGB_COMPOSITE_BEHIND));
+
+    PyModule_AddObject(m, "RGB_LUMINANCE_RED",
+		       PyFloat_FromDouble(GIMP_RGB_LUMINANCE_RED));
+    PyModule_AddObject(m, "RGB_LUMINANCE_GREEN",
+		       PyFloat_FromDouble(GIMP_RGB_LUMINANCE_GREEN));
+    PyModule_AddObject(m, "RGB_LUMINANCE_BLUE",
+		       PyFloat_FromDouble(GIMP_RGB_LUMINANCE_BLUE));
+
+    /* for other modules */
+    PyModule_AddObject(m, "_PyGimpColor_API",
+                       PyCObject_FromVoidPtr(&pygimpcolor_api_functions, NULL));
+
+    /* Check for errors */
+    if (PyErr_Occurred())
+	Py_FatalError("can't initialize module gimpcolor");
+}
diff --git a/plug-ins/pygimp/gimpenums-types.defs b/plug-ins/pygimp/gimpenums-types.defs
new file mode 100644
index 0000000..b919c93
--- /dev/null
+++ b/plug-ins/pygimp/gimpenums-types.defs
@@ -0,0 +1,338 @@
+;; -*- scheme -*-
+; object definitions ...
+;; Enumerations and flags ...
+
+(define-enum BrushApplicationMode
+  (in-module "Gimp")
+  (c-name "GimpBrushApplicationMode")
+  (gtype-id "GIMP_TYPE_BRUSH_APPLICATION_MODE")
+  (values
+    '("hard" "GIMP_BRUSH_HARD")
+    '("soft" "GIMP_BRUSH_SOFT")
+  )
+)
+
+(define-enum BrushGeneratedShape
+  (in-module "Gimp")
+  (c-name "GimpBrushGeneratedShape")
+  (gtype-id "GIMP_TYPE_BRUSH_GENERATED_SHAPE")
+  (values
+    '("circle" "GIMP_BRUSH_GENERATED_CIRCLE")
+    '("square" "GIMP_BRUSH_GENERATED_SQUARE")
+    '("diamond" "GIMP_BRUSH_GENERATED_DIAMOND")
+  )
+)
+
+(define-enum ConvertDitherType
+  (in-module "Gimp")
+  (c-name "GimpConvertDitherType")
+  (gtype-id "GIMP_TYPE_CONVERT_DITHER_TYPE")
+  (values
+    '("no-dither" "GIMP_NO_DITHER")
+    '("fs-dither" "GIMP_FS_DITHER")
+    '("fslowbleed-dither" "GIMP_FSLOWBLEED_DITHER")
+    '("fixed-dither" "GIMP_FIXED_DITHER")
+  )
+)
+
+(define-enum ConvertPaletteType
+  (in-module "Gimp")
+  (c-name "GimpConvertPaletteType")
+  (gtype-id "GIMP_TYPE_CONVERT_PALETTE_TYPE")
+  (values
+    '("make-palette" "GIMP_MAKE_PALETTE")
+    '("reuse-palette" "GIMP_REUSE_PALETTE")
+    '("web-palette" "GIMP_WEB_PALETTE")
+    '("mono-palette" "GIMP_MONO_PALETTE")
+    '("custom-palette" "GIMP_CUSTOM_PALETTE")
+  )
+)
+
+(define-enum ConvolutionType
+  (in-module "Gimp")
+  (c-name "GimpConvolutionType")
+  (gtype-id "GIMP_TYPE_CONVOLUTION_TYPE")
+  (values
+    '("normal-convol" "GIMP_NORMAL_CONVOL")
+    '("absolute-convol" "GIMP_ABSOLUTE_CONVOL")
+    '("negative-convol" "GIMP_NEGATIVE_CONVOL")
+  )
+)
+
+(define-enum ConvolveType
+  (in-module "Gimp")
+  (c-name "GimpConvolveType")
+  (gtype-id "GIMP_TYPE_CONVOLVE_TYPE")
+  (values
+    '("blur-convolve" "GIMP_BLUR_CONVOLVE")
+    '("sharpen-convolve" "GIMP_SHARPEN_CONVOLVE")
+  )
+)
+
+(define-enum FillType
+  (in-module "Gimp")
+  (c-name "GimpFillType")
+  (gtype-id "GIMP_TYPE_FILL_TYPE")
+  (values
+    '("foreground-fill" "GIMP_FOREGROUND_FILL")
+    '("background-fill" "GIMP_BACKGROUND_FILL")
+    '("white-fill" "GIMP_WHITE_FILL")
+    '("transparent-fill" "GIMP_TRANSPARENT_FILL")
+    '("pattern-fill" "GIMP_PATTERN_FILL")
+  )
+)
+
+(define-enum GradientSegmentColor
+  (in-module "Gimp")
+  (c-name "GimpGradientSegmentColor")
+  (gtype-id "GIMP_TYPE_GRADIENT_SEGMENT_COLOR")
+  (values
+    '("rgb" "GIMP_GRADIENT_SEGMENT_RGB")
+    '("hsv-ccw" "GIMP_GRADIENT_SEGMENT_HSV_CCW")
+    '("hsv-cw" "GIMP_GRADIENT_SEGMENT_HSV_CW")
+  )
+)
+
+(define-enum GradientSegmentType
+  (in-module "Gimp")
+  (c-name "GimpGradientSegmentType")
+  (gtype-id "GIMP_TYPE_GRADIENT_SEGMENT_TYPE")
+  (values
+    '("linear" "GIMP_GRADIENT_SEGMENT_LINEAR")
+    '("curved" "GIMP_GRADIENT_SEGMENT_CURVED")
+    '("sine" "GIMP_GRADIENT_SEGMENT_SINE")
+    '("sphere-increasing" "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING")
+    '("sphere-decreasing" "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING")
+  )
+)
+
+(define-enum HistogramChannel
+  (in-module "Gimp")
+  (c-name "GimpHistogramChannel")
+  (gtype-id "GIMP_TYPE_HISTOGRAM_CHANNEL")
+  (values
+    '("value" "GIMP_HISTOGRAM_VALUE")
+    '("red" "GIMP_HISTOGRAM_RED")
+    '("green" "GIMP_HISTOGRAM_GREEN")
+    '("blue" "GIMP_HISTOGRAM_BLUE")
+    '("alpha" "GIMP_HISTOGRAM_ALPHA")
+  )
+)
+
+(define-enum HueRange
+  (in-module "Gimp")
+  (c-name "GimpHueRange")
+  (gtype-id "GIMP_TYPE_HUE_RANGE")
+  (values
+    '("all-hues" "GIMP_ALL_HUES")
+    '("red-hues" "GIMP_RED_HUES")
+    '("yellow-hues" "GIMP_YELLOW_HUES")
+    '("green-hues" "GIMP_GREEN_HUES")
+    '("cyan-hues" "GIMP_CYAN_HUES")
+    '("blue-hues" "GIMP_BLUE_HUES")
+    '("magenta-hues" "GIMP_MAGENTA_HUES")
+  )
+)
+
+(define-enum ImageType
+  (in-module "Gimp")
+  (c-name "GimpImageType")
+  (gtype-id "GIMP_TYPE_IMAGE_TYPE")
+  (values
+    '("rgb" "GIMP_RGB_IMAGE")
+    '("rgba" "GIMP_RGBA_IMAGE")
+    '("gray" "GIMP_GRAY_IMAGE")
+    '("graya" "GIMP_GRAYA_IMAGE")
+    '("indexed" "GIMP_INDEXED_IMAGE")
+    '("indexeda" "GIMP_INDEXEDA_IMAGE")
+  )
+)
+
+(define-enum LayerModeEffects
+  (in-module "Gimp")
+  (c-name "GimpLayerModeEffects")
+  (gtype-id "GIMP_TYPE_LAYER_MODE_EFFECTS")
+  (values
+    '("normal-mode" "GIMP_NORMAL_MODE")
+    '("dissolve-mode" "GIMP_DISSOLVE_MODE")
+    '("behind-mode" "GIMP_BEHIND_MODE")
+    '("multiply-mode" "GIMP_MULTIPLY_MODE")
+    '("screen-mode" "GIMP_SCREEN_MODE")
+    '("overlay-mode" "GIMP_OVERLAY_MODE")
+    '("difference-mode" "GIMP_DIFFERENCE_MODE")
+    '("addition-mode" "GIMP_ADDITION_MODE")
+    '("subtract-mode" "GIMP_SUBTRACT_MODE")
+    '("darken-only-mode" "GIMP_DARKEN_ONLY_MODE")
+    '("lighten-only-mode" "GIMP_LIGHTEN_ONLY_MODE")
+    '("hue-mode" "GIMP_HUE_MODE")
+    '("saturation-mode" "GIMP_SATURATION_MODE")
+    '("color-mode" "GIMP_COLOR_MODE")
+    '("value-mode" "GIMP_VALUE_MODE")
+    '("divide-mode" "GIMP_DIVIDE_MODE")
+    '("dodge-mode" "GIMP_DODGE_MODE")
+    '("burn-mode" "GIMP_BURN_MODE")
+    '("hardlight-mode" "GIMP_HARDLIGHT_MODE")
+    '("softlight-mode" "GIMP_SOFTLIGHT_MODE")
+    '("grain-extract-mode" "GIMP_GRAIN_EXTRACT_MODE")
+    '("grain-merge-mode" "GIMP_GRAIN_MERGE_MODE")
+    '("color-erase-mode" "GIMP_COLOR_ERASE_MODE")
+    '("new-overlay-mode" "GIMP_NEW_OVERLAY_MODE")
+  )
+)
+
+(define-enum MaskApplyMode
+  (in-module "Gimp")
+  (c-name "GimpMaskApplyMode")
+  (gtype-id "GIMP_TYPE_MASK_APPLY_MODE")
+  (values
+    '("apply" "GIMP_MASK_APPLY")
+    '("discard" "GIMP_MASK_DISCARD")
+  )
+)
+
+(define-enum MergeType
+  (in-module "Gimp")
+  (c-name "GimpMergeType")
+  (gtype-id "GIMP_TYPE_MERGE_TYPE")
+  (values
+    '("expand-as-necessary" "GIMP_EXPAND_AS_NECESSARY")
+    '("clip-to-image" "GIMP_CLIP_TO_IMAGE")
+    '("clip-to-bottom-layer" "GIMP_CLIP_TO_BOTTOM_LAYER")
+    '("flatten-image" "GIMP_FLATTEN_IMAGE")
+  )
+)
+
+(define-enum OffsetType
+  (in-module "Gimp")
+  (c-name "GimpOffsetType")
+  (gtype-id "GIMP_TYPE_OFFSET_TYPE")
+  (values
+    '("background" "GIMP_OFFSET_BACKGROUND")
+    '("transparent" "GIMP_OFFSET_TRANSPARENT")
+  )
+)
+
+(define-enum OrientationType
+  (in-module "Gimp")
+  (c-name "GimpOrientationType")
+  (gtype-id "GIMP_TYPE_ORIENTATION_TYPE")
+  (values
+    '("horizontal" "GIMP_ORIENTATION_HORIZONTAL")
+    '("vertical" "GIMP_ORIENTATION_VERTICAL")
+    '("unknown" "GIMP_ORIENTATION_UNKNOWN")
+  )
+)
+
+(define-enum RotationType
+  (in-module "Gimp")
+  (c-name "GimpRotationType")
+  (gtype-id "GIMP_TYPE_ROTATION_TYPE")
+  (values
+    '("90" "GIMP_ROTATE_90")
+    '("180" "GIMP_ROTATE_180")
+    '("270" "GIMP_ROTATE_270")
+  )
+)
+
+
+;; From ../../libgimp/gimpenums.h
+
+(define-function gimp_brush_application_mode_get_type
+  (c-name "gimp_brush_application_mode_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_brush_generated_shape_get_type
+  (c-name "gimp_brush_generated_shape_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_convert_dither_type_get_type
+  (c-name "gimp_convert_dither_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_convert_palette_type_get_type
+  (c-name "gimp_convert_palette_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_convolution_type_get_type
+  (c-name "gimp_convolution_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_convolve_type_get_type
+  (c-name "gimp_convolve_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_fill_type_get_type
+  (c-name "gimp_fill_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_gradient_segment_color_get_type
+  (c-name "gimp_gradient_segment_color_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_gradient_segment_type_get_type
+  (c-name "gimp_gradient_segment_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_histogram_channel_get_type
+  (c-name "gimp_histogram_channel_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_hue_range_get_type
+  (c-name "gimp_hue_range_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_layer_mode_effects_get_type
+  (c-name "gimp_layer_mode_effects_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_mask_apply_mode_get_type
+  (c-name "gimp_mask_apply_mode_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_merge_type_get_type
+  (c-name "gimp_merge_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_offset_type_get_type
+  (c-name "gimp_offset_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_orientation_type_get_type
+  (c-name "gimp_orientation_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_rotation_type_get_type
+  (c-name "gimp_rotation_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_enums_init
+  (c-name "gimp_enums_init")
+  (return-type "none")
+)
+
+(define-function gimp_enums_get_type_names
+  (c-name "gimp_enums_get_type_names")
+  (return-type "const-gchar**")
+  (parameters
+    '("gint*" "n_type_names")
+  )
+)
+
+
diff --git a/plug-ins/pygimp/gimpenums.py b/plug-ins/pygimp/gimpenums.py
new file mode 100644
index 0000000..9e23ded
--- /dev/null
+++ b/plug-ins/pygimp/gimpenums.py
@@ -0,0 +1,50 @@
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 2005  Manish Singh  <yosh@gimp.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# gimpenums.py -- constants for use with the gimp module
+#
+# this file pulls in constants that are useful for use in
+# gimp plugins.  Just add 'from gimpenums import *' to the top
+# of the script
+
+from _gimpenums import *
+
+# This is from pygtk/gtk/__init__.py
+# Copyright (C) 1998-2003  James Henstridge
+
+class _DeprecatedConstant:
+    def __init__(self, value, name, suggestion):
+        self._v = value
+        self._name = name
+        self._suggestion = suggestion
+
+    def _deprecated(self, value):
+        import warnings
+        message = '%s is deprecated, use %s instead' % (self._name,
+                                                        self._suggestion)
+        warnings.warn(message, DeprecationWarning, 3)
+        return value
+
+    __nonzero__ = lambda self: self._deprecated(self._v == True)
+    __int__     = lambda self: self._deprecated(int(self._v))
+    __str__     = lambda self: self._deprecated(str(self._v))
+    __repr__    = lambda self: self._deprecated(repr(self._v))
+    __cmp__     = lambda self, other: self._deprecated(cmp(self._v, other))
+
+TRUE = _DeprecatedConstant(True, 'gimpenums.TRUE', 'True')
+FALSE = _DeprecatedConstant(False, 'gimpenums.FALSE', 'False')
+
+del _DeprecatedConstant
diff --git a/plug-ins/pygimp/gimpenumsmodule.c b/plug-ins/pygimp/gimpenumsmodule.c
new file mode 100644
index 0000000..2a1194c
--- /dev/null
+++ b/plug-ins/pygimp/gimpenumsmodule.c
@@ -0,0 +1,174 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <Python.h>
+
+#include <glib-object.h>
+
+#include <pygobject.h>
+
+#include "pygimp-api.h"
+#include "pygimp-util.h"
+#include "libgimp/gimpui.h"
+
+static void
+add_misc_enums(PyObject *m)
+{
+    PyModule_AddIntConstant(m, "PARASITE_PERSISTENT",
+                            GIMP_PARASITE_PERSISTENT);
+    PyModule_AddIntConstant(m, "PARASITE_UNDOABLE",
+                            GIMP_PARASITE_UNDOABLE);
+    PyModule_AddIntConstant(m, "PARASITE_ATTACH_PARENT",
+                            GIMP_PARASITE_ATTACH_PARENT);
+    PyModule_AddIntConstant(m, "PARASITE_PARENT_PERSISTENT",
+                            GIMP_PARASITE_PARENT_PERSISTENT);
+    PyModule_AddIntConstant(m, "PARASITE_PARENT_UNDOABLE",
+                            GIMP_PARASITE_PARENT_UNDOABLE);
+    PyModule_AddIntConstant(m, "PARASITE_ATTACH_GRANDPARENT",
+                            GIMP_PARASITE_ATTACH_GRANDPARENT);
+    PyModule_AddIntConstant(m, "PARASITE_GRANDPARENT_PERSISTENT",
+                            GIMP_PARASITE_GRANDPARENT_PERSISTENT);
+    PyModule_AddIntConstant(m, "PARASITE_GRANDPARENT_UNDOABLE",
+                            GIMP_PARASITE_GRANDPARENT_UNDOABLE);
+
+    PyModule_AddIntConstant(m, "UNIT_PIXEL",
+                            GIMP_UNIT_PIXEL);
+    PyModule_AddIntConstant(m, "UNIT_INCH",
+                            GIMP_UNIT_INCH);
+    PyModule_AddIntConstant(m, "UNIT_MM",
+                            GIMP_UNIT_MM);
+    PyModule_AddIntConstant(m, "UNIT_POINT",
+                            GIMP_UNIT_POINT);
+    PyModule_AddIntConstant(m, "UNIT_PICA",
+                            GIMP_UNIT_PICA);
+
+    PyModule_AddIntConstant(m, "MIN_IMAGE_SIZE",
+                            GIMP_MIN_IMAGE_SIZE);
+    PyModule_AddIntConstant(m, "MAX_IMAGE_SIZE",
+                            GIMP_MAX_IMAGE_SIZE);
+
+    PyModule_AddObject(m, "MIN_RESOLUTION",
+                       PyFloat_FromDouble(GIMP_MIN_RESOLUTION));
+    PyModule_AddObject(m, "MAX_RESOLUTION",
+                       PyFloat_FromDouble(GIMP_MAX_RESOLUTION));
+
+    PyModule_AddObject(m, "MAX_MEMSIZE",
+                       PyLong_FromUnsignedLongLong(GIMP_MAX_MEMSIZE));
+
+    PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_NONE",
+                            GIMP_PIXEL_FETCHER_EDGE_NONE);
+    PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_WRAP",
+                            GIMP_PIXEL_FETCHER_EDGE_WRAP);
+    PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_SMEAR",
+                            GIMP_PIXEL_FETCHER_EDGE_SMEAR);
+    PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_BLACK",
+                            GIMP_PIXEL_FETCHER_EDGE_BLACK);
+    PyModule_AddIntConstant(m, "PIXEL_FETCHER_EDGE_BACKGROUND",
+                            GIMP_PIXEL_FETCHER_EDGE_BACKGROUND);
+}
+
+static void
+add_compat_enums(PyObject *m)
+{
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_RGB",
+                            GIMP_EXPORT_CAN_HANDLE_RGB);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_GRAY",
+                            GIMP_EXPORT_CAN_HANDLE_GRAY);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_INDEXED",
+                            GIMP_EXPORT_CAN_HANDLE_INDEXED);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_BITMAP",
+                            GIMP_EXPORT_CAN_HANDLE_BITMAP);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_ALPHA",
+                            GIMP_EXPORT_CAN_HANDLE_ALPHA);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYERS",
+                            GIMP_EXPORT_CAN_HANDLE_LAYERS);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION",
+                            GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION);
+    PyModule_AddIntConstant(m, "EXPORT_CAN_HANDLE_LAYER_MASKS",
+                            GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS);
+    PyModule_AddIntConstant(m, "EXPORT_NEEDS_ALPHA",
+                            GIMP_EXPORT_NEEDS_ALPHA);
+
+    PyModule_AddIntConstant(m, "EXPORT_CANCEL",
+                            GIMP_EXPORT_CANCEL);
+    PyModule_AddIntConstant(m, "EXPORT_IGNORE",
+                            GIMP_EXPORT_IGNORE);
+    PyModule_AddIntConstant(m, "EXPORT_EXPORT",
+                            GIMP_EXPORT_EXPORT);
+}
+
+static void
+add_registered_enums(PyObject *m)
+{
+    gint          num_names, i;
+    const gchar **names;
+    GQuark        quark = g_quark_from_static_string ("gimp-compat-enum");
+
+    names = gimp_enums_get_type_names (&num_names);
+
+    pyg_enum_add_constants (m, GIMP_TYPE_CHECK_SIZE, "GIMP_");
+    pyg_enum_add_constants (m, GIMP_TYPE_CHECK_TYPE, "GIMP_");
+
+    for (i = 0; i < num_names; i++)
+        {
+            GType enum_type = g_type_from_name (names[i]);
+
+            pyg_enum_add_constants (m, enum_type, "GIMP_");
+
+            enum_type = (GType) g_type_get_qdata (enum_type, quark);
+
+            if (enum_type)
+                pyg_enum_add_constants (m, enum_type, "GIMP_");
+        }
+}
+
+
+/* Initialization function for the module (*must* be called initgimpenums) */
+
+static char gimpenums_doc[] =
+"This module provides interfaces to allow you to write gimp plug-ins"
+;
+
+void init_gimpenums(void);
+
+PyMODINIT_FUNC
+init_gimpenums(void)
+{
+    PyObject *m;
+
+    pygimp_init_pygobject();
+
+    init_pygimp();
+
+    gimp_enums_init();
+
+    /* Create the module and add the functions */
+    m = Py_InitModule3("_gimpenums", NULL, gimpenums_doc);
+
+    add_misc_enums(m);
+    add_compat_enums(m);
+    add_registered_enums(m);
+
+    /* Check for errors */
+    if (PyErr_Occurred())
+        Py_FatalError("can't initialize module _gimpenums");
+}
diff --git a/plug-ins/pygimp/gimpfu.py b/plug-ins/pygimp/gimpfu.py
new file mode 100644
index 0000000..266d5ae
--- /dev/null
+++ b/plug-ins/pygimp/gimpfu.py
@@ -0,0 +1,876 @@
+#   Gimp-Python - allows the writing of GIMP plug-ins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Simple interface for writing GIMP plug-ins in Python.
+
+Instead of worrying about all the user interaction, saving last used
+values and everything, the gimpfu module can take care of it for you.
+It provides a simple register() function that will register your
+plug-in if needed, and cause your plug-in function to be called when
+needed.
+
+Gimpfu will also handle showing a user interface for editing plug-in
+parameters if the plug-in is called interactively, and will also save
+the last used parameters, so the RUN_WITH_LAST_VALUES run_type will
+work correctly.  It will also make sure that the displays are flushed
+on completion if the plug-in was run interactively.
+
+When registering the plug-in, you do not need to worry about
+specifying the run_type parameter.
+
+A typical gimpfu plug-in would look like this:
+  from gimpfu import *
+
+  def plugin_func(image, drawable, args):
+              # do what plugins do best
+  register(
+              "plugin_func",
+              "blurb",
+              "help message",
+              "author",
+              "copyright",
+              "year",
+              "My plug-in",
+              "*",
+              [
+                  (PF_IMAGE, "image", "Input image", None),
+                  (PF_DRAWABLE, "drawable", "Input drawable", None),
+                  (PF_STRING, "arg", "The argument", "default-value")
+              ],
+              [],
+              plugin_func, menu="<Image>/Somewhere")
+  main()
+
+The call to "from gimpfu import *" will import all the gimp constants
+into the plug-in namespace, and also import the symbols gimp, pdb,
+register and main.  This should be just about all any plug-in needs.
+
+You can use any of the PF_* constants below as parameter types, and an
+appropriate user interface element will be displayed when the plug-in
+is run in interactive mode.  Note that the the PF_SPINNER and
+PF_SLIDER types expect a fifth element in their description tuple -- a
+3-tuple of the form (lower,upper,step), which defines the limits for
+the slider or spinner.
+
+If want to localize your plug-in, add an optional domain parameter to
+the register call. It can be the name of the translation domain or a
+tuple that consists of the translation domain and the directory where
+the translations are installed.
+"""
+
+import string as _string
+import math
+import gimp
+import gimpcolor
+from gimpenums import *
+pdb = gimp.pdb
+
+import gettext
+t = gettext.translation("gimp20-python", gimp.locale_directory, fallback=True)
+_ = t.ugettext
+
+class error(RuntimeError): pass
+class CancelError(RuntimeError): pass
+
+PF_INT8        = PDB_INT8
+PF_INT16       = PDB_INT16
+PF_INT32       = PDB_INT32
+PF_INT         = PF_INT32
+PF_FLOAT       = PDB_FLOAT
+PF_STRING      = PDB_STRING
+PF_VALUE       = PF_STRING
+#PF_INT8ARRAY   = PDB_INT8ARRAY
+#PF_INT16ARRAY  = PDB_INT16ARRAY
+#PF_INT32ARRAY  = PDB_INT32ARRAY
+#PF_INTARRAY    = PF_INT32ARRAY
+#PF_FLOATARRAY  = PDB_FLOATARRAY
+#PF_STRINGARRAY = PDB_STRINGARRAY
+PF_COLOR       = PDB_COLOR
+PF_COLOUR      = PF_COLOR
+PF_ITEM        = PDB_ITEM
+PF_DISPLAY     = PDB_DISPLAY
+PF_IMAGE       = PDB_IMAGE
+PF_LAYER       = PDB_LAYER
+PF_CHANNEL     = PDB_CHANNEL
+PF_DRAWABLE    = PDB_DRAWABLE
+PF_VECTORS     = PDB_VECTORS
+#PF_SELECTION   = PDB_SELECTION
+#PF_BOUNDARY    = PDB_BOUNDARY
+#PF_PATH        = PDB_PATH
+#PF_STATUS      = PDB_STATUS
+
+PF_TOGGLE      = 1000
+PF_BOOL        = PF_TOGGLE
+PF_SLIDER      = 1001
+PF_SPINNER     = 1002
+PF_ADJUSTMENT  = PF_SPINNER
+
+PF_FONT        = 1003
+PF_FILE        = 1004
+PF_BRUSH       = 1005
+PF_PATTERN     = 1006
+PF_GRADIENT    = 1007
+PF_RADIO       = 1008
+PF_TEXT        = 1009
+PF_PALETTE     = 1010
+PF_FILENAME    = 1011
+PF_DIRNAME     = 1012
+PF_OPTION      = 1013
+
+_type_mapping = {
+    PF_INT8        : PDB_INT8,
+    PF_INT16       : PDB_INT16,
+    PF_INT32       : PDB_INT32,
+    PF_FLOAT       : PDB_FLOAT,
+    PF_STRING      : PDB_STRING,
+    #PF_INT8ARRAY   : PDB_INT8ARRAY,
+    #PF_INT16ARRAY  : PDB_INT16ARRAY,
+    #PF_INT32ARRAY  : PDB_INT32ARRAY,
+    #PF_FLOATARRAY  : PDB_FLOATARRAY,
+    #PF_STRINGARRAY : PDB_STRINGARRAY,
+    PF_COLOR       : PDB_COLOR,
+    PF_ITEM        : PDB_ITEM,
+    PF_DISPLAY     : PDB_DISPLAY,
+    PF_IMAGE       : PDB_IMAGE,
+    PF_LAYER       : PDB_LAYER,
+    PF_CHANNEL     : PDB_CHANNEL,
+    PF_DRAWABLE    : PDB_DRAWABLE,
+    PF_VECTORS     : PDB_VECTORS,
+
+    PF_TOGGLE      : PDB_INT32,
+    PF_SLIDER      : PDB_FLOAT,
+    PF_SPINNER     : PDB_INT32,
+
+    PF_FONT        : PDB_STRING,
+    PF_FILE        : PDB_STRING,
+    PF_BRUSH       : PDB_STRING,
+    PF_PATTERN     : PDB_STRING,
+    PF_GRADIENT    : PDB_STRING,
+    PF_RADIO       : PDB_STRING,
+    PF_TEXT        : PDB_STRING,
+    PF_PALETTE     : PDB_STRING,
+    PF_FILENAME    : PDB_STRING,
+    PF_DIRNAME     : PDB_STRING,
+    PF_OPTION      : PDB_INT32,
+}
+
+_obj_mapping = {
+    PF_INT8        : int,
+    PF_INT16       : int,
+    PF_INT32       : int,
+    PF_FLOAT       : float,
+    PF_STRING      : str,
+    #PF_INT8ARRAY   : list,
+    #PF_INT16ARRAY  : list,
+    #PF_INT32ARRAY  : list,
+    #PF_FLOATARRAY  : list,
+    #PF_STRINGARRAY : list,
+    PF_COLOR       : gimpcolor.RGB,
+    PF_ITEM        : int,
+    PF_DISPLAY     : gimp.Display,
+    PF_IMAGE       : gimp.Image,
+    PF_LAYER       : gimp.Layer,
+    PF_CHANNEL     : gimp.Channel,
+    PF_DRAWABLE    : gimp.Drawable,
+    PF_VECTORS     : gimp.Vectors,
+
+    PF_TOGGLE      : bool,
+    PF_SLIDER      : float,
+    PF_SPINNER     : int,
+
+    PF_FONT        : str,
+    PF_FILE        : str,
+    PF_BRUSH       : str,
+    PF_PATTERN     : str,
+    PF_GRADIENT    : str,
+    PF_RADIO       : str,
+    PF_TEXT        : str,
+    PF_PALETTE     : str,
+    PF_FILENAME    : str,
+    PF_DIRNAME     : str,
+    PF_OPTION      : int,
+}
+
+_registered_plugins_ = {}
+
+def register(proc_name, blurb, help, author, copyright, date, label,
+             imagetypes, params, results, function,
+             menu=None, domain=None, on_query=None, on_run=None, run_mode_param=True):
+    """This is called to register a new plug-in."""
+
+    # First perform some sanity checks on the data
+    def letterCheck(str):
+        allowed = _string.letters + _string.digits + "_" + "-"
+        for ch in str:
+            if not ch in allowed:
+                return 0
+        else:
+            return 1
+
+    if not letterCheck(proc_name):
+        raise error, "procedure name contains illegal characters"
+
+    for ent in params:
+        if len(ent) < 4:
+            raise error, ("parameter definition must contain at least 4 "
+                          "elements (%s given: %s)" % (len(ent), ent))
+
+        if type(ent[0]) != int:
+            raise error, "parameter types must be integers"
+
+        if not letterCheck(ent[1]):
+            raise error, "parameter name contains illegal characters"
+
+    for ent in results:
+        if len(ent) < 3:
+            raise error, ("result definition must contain at least 3 elements "
+                          "(%s given: %s)" % (len(ent), ent))
+
+        if type(ent[0]) != type(42):
+            raise error, "result types must be integers"
+
+        if not letterCheck(ent[1]):
+            raise error, "result name contains illegal characters"
+
+    plugin_type = PLUGIN
+
+    if (not proc_name.startswith("python-") and
+        not proc_name.startswith("python_") and
+        not proc_name.startswith("extension-") and
+        not proc_name.startswith("extension_") and
+        not proc_name.startswith("plug-in-") and
+        not proc_name.startswith("plug_in_") and
+        not proc_name.startswith("file-") and
+        not proc_name.startswith("file_")):
+           proc_name = "python-fu-" + proc_name
+
+    # if menu is not given, derive it from label
+    need_compat_params = False
+    if menu is None and label:
+        fields = label.split("/")
+        if fields:
+            label = fields.pop()
+            menu = "/".join(fields)
+            need_compat_params = True
+
+            import warnings
+            message = ("%s: passing the full menu path for the menu label is "
+                       "deprecated, use the 'menu' parameter instead"
+                       % (proc_name))
+            warnings.warn(message, DeprecationWarning, 3)
+
+        if need_compat_params and plugin_type == PLUGIN:
+            file_params = [(PDB_STRING, "filename", "The name of the file", ""),
+                           (PDB_STRING, "raw-filename", "The name of the file", "")]
+
+            if menu is None:
+                pass
+            elif menu.startswith("<Load>"):
+                params[0:0] = file_params
+            elif menu.startswith("<Image>") or menu.startswith("<Save>"):
+                params.insert(0, (PDB_IMAGE, "image", "Input image", None))
+                params.insert(1, (PDB_DRAWABLE, "drawable", "Input drawable", None))
+                if menu.startswith("<Save>"):
+                    params[2:2] = file_params
+
+    _registered_plugins_[proc_name] = (blurb, help, author, copyright,
+                                       date, label, imagetypes,
+                                       plugin_type, params, results,
+                                       function, menu, domain,
+                                       on_query, on_run, run_mode_param)
+
+def _query():
+    for plugin in _registered_plugins_.keys():
+        (blurb, help, author, copyright, date,
+         label, imagetypes, plugin_type,
+         params, results, function, menu, domain,
+         on_query, on_run, has_param_run_mode) = _registered_plugins_[plugin]
+
+        def make_params(params):
+            return [(_type_mapping[x[0]],
+                     x[1],
+                     _string.replace(x[2], "_", "")) for x in params]
+
+        params = make_params(params)
+        # add the run mode argument ...
+        if has_param_run_mode:
+            params.insert(0, (PDB_INT32, "run-mode",
+                                         "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }"))
+
+        results = make_params(results)
+
+        if domain:
+            try:
+                (domain, locale_dir) = domain
+                gimp.domain_register(domain, locale_dir)
+            except ValueError:
+                gimp.domain_register(domain)
+
+        gimp.install_procedure(plugin, blurb, help, author, copyright,
+                               date, label, imagetypes, plugin_type,
+                               params, results)
+
+        if menu:
+            gimp.menu_register(plugin, menu)
+        if on_query:
+            on_query()
+
+def _get_defaults(proc_name):
+    import gimpshelf
+
+    (blurb, help, author, copyright, date,
+     label, imagetypes, plugin_type,
+     params, results, function, menu, domain,
+     on_query, on_run, has_run_mode) = _registered_plugins_[proc_name]
+
+    key = "python-fu-save--" + proc_name
+
+    if gimpshelf.shelf.has_key(key):
+        return gimpshelf.shelf[key]
+    else:
+        # return the default values
+        return [x[3] for x in params]
+
+def _set_defaults(proc_name, defaults):
+    import gimpshelf
+
+    key = "python-fu-save--" + proc_name
+    gimpshelf.shelf[key] = defaults
+
+def _interact(proc_name, start_params):
+    (blurb, help, author, copyright, date,
+     label, imagetypes, plugin_type,
+     params, results, function, menu, domain,
+     on_query, on_run, has_run_mode) = _registered_plugins_[proc_name]
+
+    def run_script(run_params):
+        params = start_params + tuple(run_params)
+        _set_defaults(proc_name, params)
+        return apply(function, params)
+
+    params = params[len(start_params):]
+
+    # short circuit for no parameters ...
+    if len(params) == 0:
+         return run_script([])
+
+    import pygtk
+    pygtk.require('2.0')
+
+    import gimpui
+    import gtk
+#    import pango
+    gimpui.gimp_ui_init ()
+
+    defaults = _get_defaults(proc_name)
+    defaults = defaults[len(start_params):]
+
+    class EntryValueError(Exception):
+        pass
+
+    def warning_dialog(parent, primary, secondary=None):
+        dlg = gtk.MessageDialog(parent, gtk.DIALOG_DESTROY_WITH_PARENT,
+                                        gtk.MESSAGE_WARNING, gtk.BUTTONS_CLOSE,
+                                        primary)
+        if secondary:
+            dlg.format_secondary_text(secondary)
+        dlg.run()
+        dlg.destroy()
+
+    def error_dialog(parent, proc_name):
+        import sys, traceback
+
+        exc_str = exc_only_str = _("Missing exception information")
+
+        try:
+            etype, value, tb = sys.exc_info()
+            exc_str = "".join(traceback.format_exception(etype, value, tb))
+            exc_only_str = "".join(traceback.format_exception_only(etype, value))
+        finally:
+            etype = value = tb = None
+
+        title = _("An error occurred running %s") % proc_name
+        dlg = gtk.MessageDialog(parent, gtk.DIALOG_DESTROY_WITH_PARENT,
+                                        gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE,
+                                        title)
+        dlg.format_secondary_text(exc_only_str)
+
+        alignment = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
+        alignment.set_padding(0, 0, 12, 12)
+        dlg.vbox.pack_start(alignment)
+        alignment.show()
+
+        expander = gtk.Expander(_("_More Information"));
+        expander.set_use_underline(True)
+        expander.set_spacing(6)
+        alignment.add(expander)
+        expander.show()
+
+        scrolled = gtk.ScrolledWindow()
+        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled.set_size_request(-1, 200)
+        expander.add(scrolled)
+        scrolled.show()
+
+
+        label = gtk.Label(exc_str)
+        label.set_alignment(0.0, 0.0)
+        label.set_padding(6, 6)
+        label.set_selectable(True)
+        scrolled.add_with_viewport(label)
+        label.show()
+
+        def response(widget, id):
+            widget.destroy()
+
+        dlg.connect("response", response)
+        dlg.set_resizable(True)
+        dlg.show()
+
+    # define a mapping of param types to edit objects ...
+    class StringEntry(gtk.Entry):
+        def __init__(self, default=""):
+            gtk.Entry.__init__(self)
+            self.set_text(str(default))
+            self.set_activates_default(True)
+
+        def get_value(self):
+            return self.get_text()
+
+    class TextEntry(gtk.ScrolledWindow):
+        def __init__ (self, default=""):
+            gtk.ScrolledWindow.__init__(self)
+            self.set_shadow_type(gtk.SHADOW_IN)
+
+            self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+            self.set_size_request(100, -1)
+
+            self.view = gtk.TextView()
+            self.add(self.view)
+            self.view.show()
+
+            self.buffer = self.view.get_buffer()
+
+            self.set_value(str(default))
+
+        def set_value(self, text):
+            self.buffer.set_text(text)
+
+        def get_value(self):
+            return self.buffer.get_text(self.buffer.get_start_iter(),
+                                        self.buffer.get_end_iter())
+
+    class IntEntry(StringEntry):
+        def get_value(self):
+            try:
+                return int(self.get_text())
+            except ValueError, e:
+                raise EntryValueError, e.args
+
+    class FloatEntry(StringEntry):
+            def get_value(self):
+                try:
+                    return float(self.get_text())
+                except ValueError, e:
+                    raise EntryValueError, e.args
+
+#    class ArrayEntry(StringEntry):
+#            def get_value(self):
+#                return eval(self.get_text(), {}, {})
+
+
+    def precision(step):
+        # calculate a reasonable precision from a given step size
+        if math.fabs(step) >= 1.0 or step == 0.0:
+            digits = 0
+        else:
+            digits = abs(math.floor(math.log10(math.fabs(step))));
+        if digits > 20:
+            digits = 20
+        return int(digits)
+
+    class SliderEntry(gtk.HScale):
+        # bounds is (upper, lower, step)
+        def __init__(self, default=0, bounds=(0, 100, 5)):
+            step = bounds[2]
+            self.adj = gtk.Adjustment(default, bounds[0], bounds[1],
+                                      step, 10 * step, 0)
+            gtk.HScale.__init__(self, self.adj)
+            self.set_digits(precision(step))
+
+        def get_value(self):
+            return self.adj.value
+
+    class SpinnerEntry(gtk.SpinButton):
+        # bounds is (upper, lower, step)
+        def __init__(self, default=0, bounds=(0, 100, 5)):
+            step = bounds[2]
+            self.adj = gtk.Adjustment(default, bounds[0], bounds[1],
+                                      step, 10 * step, 0)
+            gtk.SpinButton.__init__(self, self.adj, step, precision(step))
+
+    class ToggleEntry(gtk.ToggleButton):
+        def __init__(self, default=0):
+            gtk.ToggleButton.__init__(self)
+
+            self.label = gtk.Label(_("No"))
+            self.add(self.label)
+            self.label.show()
+
+            self.connect("toggled", self.changed)
+
+            self.set_active(default)
+
+        def changed(self, tog):
+            if tog.get_active():
+                self.label.set_text(_("Yes"))
+            else:
+                self.label.set_text(_("No"))
+
+        def get_value(self):
+            return self.get_active()
+
+    class RadioEntry(gtk.VBox):
+        def __init__(self, default=0, items=((_("Yes"), 1), (_("No"), 0))):
+            gtk.VBox.__init__(self, homogeneous=False, spacing=2)
+
+            button = None
+
+            for (label, value) in items:
+                button = gtk.RadioButton(button, label)
+                self.pack_start(button)
+                button.show()
+
+                button.connect("toggled", self.changed, value)
+
+                if value == default:
+                    button.set_active(True)
+                    self.active_value = value
+
+        def changed(self, radio, value):
+            if radio.get_active():
+                self.active_value = value
+
+        def get_value(self):
+            return self.active_value
+
+    class ComboEntry(gtk.ComboBox):
+        def __init__(self, default=0, items=()):
+            store = gtk.ListStore(str)
+            for item in items:
+                store.append([item])
+
+            gtk.ComboBox.__init__(self, model=store)
+
+            cell = gtk.CellRendererText()
+            self.pack_start(cell)
+            self.set_attributes(cell, text=0)
+
+            self.set_active(default)
+
+        def get_value(self):
+            return self.get_active()
+
+    def FileSelector(default="", title=None):
+        # FIXME: should this be os.path.separator?  If not, perhaps explain why?
+        if default and default.endswith("/"):
+            if default == "/": default = ""
+            return DirnameSelector(default)
+        else:
+            return FilenameSelector(default, title=title, save_mode=False)
+
+    class FilenameSelector(gtk.HBox):
+        #gimpfu.FileChooserButton
+        def __init__(self, default, save_mode=True, title=None):
+            super(FilenameSelector, self).__init__()
+            if not title:
+                self.title = _("Python-Fu File Selection")
+            else:
+                self.title = title
+            self.save_mode = save_mode
+            box = self
+            self.entry = gtk.Entry()
+            image = gtk.Image()
+            image.set_from_stock(gtk.STOCK_FILE, gtk.ICON_SIZE_BUTTON)
+            self.button = gtk.Button()
+            self.button.set_image(image)
+            box.pack_start(self.entry)
+            box.pack_start(self.button, expand=False)
+            self.button.connect("clicked", self.pick_file)
+            if default:
+                self.entry.set_text(default)
+
+        def show(self):
+            super(FilenameSelector, self).show()
+            self.button.show()
+            self.entry.show()
+
+        def pick_file(self, widget):
+            entry = self.entry
+            dialog = gtk.FileChooserDialog(
+                         title=self.title,
+                         action=(gtk.FILE_CHOOSER_ACTION_SAVE
+                                     if self.save_mode else
+                                 gtk.FILE_CHOOSER_ACTION_OPEN),
+                         buttons=(gtk.STOCK_CANCEL,
+                                gtk.RESPONSE_CANCEL,
+                                gtk.STOCK_SAVE
+                                     if self.save_mode else
+                                gtk.STOCK_OPEN,
+                                gtk.RESPONSE_OK)
+                        )
+            dialog.set_alternative_button_order ((gtk.RESPONSE_OK, gtk.RESPONSE_CANCEL))
+            dialog.show_all()
+            response = dialog.run()
+            if response == gtk.RESPONSE_OK:
+                entry.set_text(dialog.get_filename())
+            dialog.destroy()
+
+        def get_value(self):
+            return self.entry.get_text()
+
+
+    class DirnameSelector(gtk.FileChooserButton):
+        def __init__(self, default=""):
+            gtk.FileChooserButton.__init__(self,
+                                           _("Python-Fu Folder Selection"))
+            self.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
+            if default:
+                self.set_filename(default)
+
+        def get_value(self):
+            return self.get_filename()
+
+    _edit_mapping = {
+            PF_INT8        : IntEntry,
+            PF_INT16       : IntEntry,
+            PF_INT32       : IntEntry,
+            PF_FLOAT       : FloatEntry,
+            PF_STRING      : StringEntry,
+            #PF_INT8ARRAY   : ArrayEntry,
+            #PF_INT16ARRAY  : ArrayEntry,
+            #PF_INT32ARRAY  : ArrayEntry,
+            #PF_FLOATARRAY  : ArrayEntry,
+            #PF_STRINGARRAY : ArrayEntry,
+            PF_COLOR       : gimpui.ColorSelector,
+            PF_ITEM        : IntEntry,  # should handle differently ...
+            PF_IMAGE       : gimpui.ImageSelector,
+            PF_LAYER       : gimpui.LayerSelector,
+            PF_CHANNEL     : gimpui.ChannelSelector,
+            PF_DRAWABLE    : gimpui.DrawableSelector,
+            PF_VECTORS     : gimpui.VectorsSelector,
+
+            PF_TOGGLE      : ToggleEntry,
+            PF_SLIDER      : SliderEntry,
+            PF_SPINNER     : SpinnerEntry,
+            PF_RADIO       : RadioEntry,
+            PF_OPTION      : ComboEntry,
+
+            PF_FONT        : gimpui.FontSelector,
+            PF_FILE        : FileSelector,
+            PF_FILENAME    : FilenameSelector,
+            PF_DIRNAME     : DirnameSelector,
+            PF_BRUSH       : gimpui.BrushSelector,
+            PF_PATTERN     : gimpui.PatternSelector,
+            PF_GRADIENT    : gimpui.GradientSelector,
+            PF_PALETTE     : gimpui.PaletteSelector,
+            PF_TEXT        : TextEntry
+    }
+
+    if on_run:
+        on_run()
+
+    dialog = gimpui.Dialog(proc_name, "python-fu", None, 0, None, proc_name,
+                           (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                            gtk.STOCK_OK, gtk.RESPONSE_OK))
+
+    dialog.set_alternative_button_order((gtk.RESPONSE_OK, gtk.RESPONSE_CANCEL))
+
+    dialog.set_transient()
+
+    vbox = gtk.VBox(False, 12)
+    vbox.set_border_width(12)
+    dialog.vbox.pack_start(vbox)
+    vbox.show()
+
+    if blurb:
+        if domain:
+            try:
+                (domain, locale_dir) = domain
+                trans = gettext.translation(domain, locale_dir, fallback=True)
+            except ValueError:
+                trans = gettext.translation(domain, fallback=True)
+            blurb = trans.ugettext(blurb)
+        box = gimpui.HintBox(blurb)
+        vbox.pack_start(box, expand=False)
+        box.show()
+
+    table = gtk.Table(len(params), 2, False)
+    table.set_row_spacings(6)
+    table.set_col_spacings(6)
+    vbox.pack_start(table, expand=False)
+    table.show()
+
+    def response(dlg, id):
+        if id == gtk.RESPONSE_OK:
+            dlg.set_response_sensitive(gtk.RESPONSE_OK, False)
+            dlg.set_response_sensitive(gtk.RESPONSE_CANCEL, False)
+
+            params = []
+
+            try:
+                for wid in edit_wids:
+                    params.append(wid.get_value())
+            except EntryValueError:
+                warning_dialog(dialog, _("Invalid input for '%s'") % wid.desc)
+            else:
+                try:
+                    dialog.res = run_script(params)
+                except CancelError:
+                    pass
+                except Exception:
+                    dlg.set_response_sensitive(gtk.RESPONSE_CANCEL, True)
+                    error_dialog(dialog, proc_name)
+                    raise
+
+        gtk.main_quit()
+
+    dialog.connect("response", response)
+
+    edit_wids = []
+    for i in range(len(params)):
+        pf_type = params[i][0]
+        name = params[i][1]
+        desc = params[i][2]
+        def_val = defaults[i]
+
+        label = gtk.Label(desc)
+        label.set_use_underline(True)
+        label.set_alignment(0.0, 0.5)
+        table.attach(label, 1, 2, i, i+1, xoptions=gtk.FILL)
+        label.show()
+
+        # Remove accelerator markers from tooltips
+        tooltip_text = desc.replace("_", "")
+
+        if pf_type in (PF_SPINNER, PF_SLIDER, PF_RADIO, PF_OPTION):
+            wid = _edit_mapping[pf_type](def_val, params[i][4])
+        elif pf_type in (PF_FILE, PF_FILENAME):
+            wid = _edit_mapping[pf_type](def_val, title= "%s - %s" %
+                                          (proc_name, tooltip_text))
+        else:
+            wid = _edit_mapping[pf_type](def_val)
+
+
+        label.set_mnemonic_widget(wid)
+
+        table.attach(wid, 2,3, i,i+1, yoptions=0)
+
+        if pf_type != PF_TEXT:
+            wid.set_tooltip_text(tooltip_text)
+        else:
+            # Attach tip to TextView, not to ScrolledWindow
+            wid.view.set_tooltip_text(tooltip_text)
+        wid.show()
+
+        wid.desc = desc
+        edit_wids.append(wid)
+
+    progress_vbox = gtk.VBox(False, 6)
+    vbox.pack_end(progress_vbox, expand=False)
+    progress_vbox.show()
+
+    progress = gimpui.ProgressBar()
+    progress_vbox.pack_start(progress)
+    progress.show()
+
+#    progress_label = gtk.Label()
+#    progress_label.set_alignment(0.0, 0.5)
+#    progress_label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+
+#    attrs = pango.AttrList()
+#    attrs.insert(pango.AttrStyle(pango.STYLE_ITALIC, 0, -1))
+#    progress_label.set_attributes(attrs)
+
+#    progress_vbox.pack_start(progress_label)
+#    progress_label.show()
+
+    dialog.show()
+
+    gtk.main()
+
+    if hasattr(dialog, "res"):
+        res = dialog.res
+        dialog.destroy()
+        return res
+    else:
+        dialog.destroy()
+        raise CancelError
+
+def _run(proc_name, params):
+    run_mode = params[0]
+    func = _registered_plugins_[proc_name][10]
+
+    if run_mode == RUN_NONINTERACTIVE:
+        return apply(func, params[1:])
+
+    script_params = _registered_plugins_[proc_name][8]
+    has_param_run_mode  = _registered_plugins_[proc_name][15]
+
+    min_args = 0
+    start_param_idx = 1 if has_param_run_mode else 0
+    if len(params) > start_param_idx:
+        for i in range(start_param_idx, len(params)):
+            param_type = _obj_mapping[script_params[i - start_param_idx][0]]
+            if not isinstance(params[i], param_type):
+                break
+
+        min_args = i
+
+    if len(script_params) > min_args:
+        start_params = params[:min_args + 1]
+
+        if run_mode == RUN_WITH_LAST_VALS:
+            default_params = _get_defaults(proc_name)
+            params = start_params + default_params[min_args:]
+        else:
+            params = start_params
+    else:
+       run_mode = RUN_NONINTERACTIVE
+
+    if run_mode == RUN_INTERACTIVE:
+        try:
+            res = _interact(proc_name, params[start_param_idx:])
+        except CancelError:
+            return
+    else:
+        res = apply(func, params[start_param_idx:])
+
+    gimp.displays_flush()
+
+    return res
+
+def main():
+    """This should be called after registering the plug-in."""
+    gimp.main(None, None, _query, _run)
+
+def fail(msg):
+    """Display an error message and quit"""
+    gimp.message(msg)
+    raise error, msg
+
+def N_(message):
+    return message
diff --git a/plug-ins/pygimp/gimpmodule.c b/plug-ins/pygimp/gimpmodule.c
new file mode 100644
index 0000000..36a1b88
--- /dev/null
+++ b/plug-ins/pygimp/gimpmodule.c
@@ -0,0 +1,2071 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#undef GIMP_DISABLE_DEPRECATED
+#define GIMP_DISABLE_DEPRECATION_WARNINGS
+#include "pygimp.h"
+
+#include "pygimpcolor-api.h"
+
+#include <sysmodule.h>
+
+#include <glib-object.h>
+
+#include <pygobject.h>
+
+#include "pygimp-util.h"
+
+#include "pygimp-intl.h"
+
+#include "libgimp/gimpui.h"
+
+#include <gtk/gtk.h>
+
+#include <gegl.h>
+
+
+PyObject *pygimp_error;
+
+#ifndef PG_DEBUG
+# define PG_DEBUG 0
+#endif
+
+
+/* End of code for pdbFunc objects */
+/* -------------------------------------------------------- */
+
+GimpPlugInInfo PLUG_IN_INFO = {
+    NULL, /* init_proc */
+    NULL, /* quit_proc */
+    NULL, /* query_proc */
+    NULL  /* run_proc */
+};
+
+static PyObject *callbacks[] = {
+    NULL, NULL, NULL, NULL
+};
+
+typedef struct _ProgressData ProgressData;
+
+struct _ProgressData
+{
+  PyObject *start, *end, *text, *value;
+  PyObject *user_data;
+};
+
+
+static void
+pygimp_init_proc(void)
+{
+    PyObject *r;
+
+    r = PyObject_CallFunction(callbacks[0], "()");
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_quit_proc(void)
+{
+    PyObject *r;
+
+    r = PyObject_CallFunction(callbacks[1], "()");
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_query_proc(void)
+{
+    PyObject *r;
+
+    r = PyObject_CallFunction(callbacks[2], "()");
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_run_proc(const char *name, int nparams, const GimpParam *params,
+                int *nreturn_vals, GimpParam **return_vals)
+{
+    PyObject *args, *ret;
+    GimpParamDef *pd, *rv;
+    GimpPDBProcType t;
+    char *b, *h, *a, *c, *d;
+    int np, nrv;
+
+    gimp_procedural_db_proc_info(name, &b, &h, &a, &c, &d, &t, &np, &nrv,
+                                 &pd, &rv);
+    g_free(b); g_free(h); g_free(a); g_free(c); g_free(d); g_free(pd);
+
+#if PG_DEBUG > 0
+    g_printerr("Params for %s:", name);
+    print_GParam(nparams, params);
+#endif
+
+    args = pygimp_param_to_tuple(nparams, params);
+
+    if (args == NULL) {
+        PyErr_Clear();
+
+        *nreturn_vals = 1;
+        *return_vals = g_new(GimpParam, 1);
+        (*return_vals)[0].type = GIMP_PDB_STATUS;
+        (*return_vals)[0].data.d_status = GIMP_PDB_CALLING_ERROR;
+
+        return;
+    }
+
+    ret = PyObject_CallFunction(callbacks[3], "(sO)", name, args);
+    Py_DECREF(args);
+
+    if (ret == NULL) {
+        PyErr_Print();
+        PyErr_Clear();
+
+        *nreturn_vals = 1;
+        *return_vals = g_new(GimpParam, 1);
+        (*return_vals)[0].type = GIMP_PDB_STATUS;
+        (*return_vals)[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+        return;
+    }
+
+    *return_vals = pygimp_param_from_tuple(ret, rv, nrv);
+    g_free(rv);
+
+    if (*return_vals == NULL) {
+        PyErr_Clear();
+
+        *nreturn_vals = 1;
+        *return_vals = g_new(GimpParam, 1);
+        (*return_vals)[0].type = GIMP_PDB_STATUS;
+        (*return_vals)[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+        return;
+    }
+
+    Py_DECREF(ret);
+
+    *nreturn_vals = nrv + 1;
+    (*return_vals)[0].type = GIMP_PDB_STATUS;
+    (*return_vals)[0].data.d_status = GIMP_PDB_SUCCESS;
+}
+
+static PyObject *
+pygimp_main(PyObject *self, PyObject *args)
+{
+    PyObject *av;
+    int argc, i;
+    char **argv;
+    PyObject *ip;  // init proc
+    PyObject *qp;  // quit proc
+    PyObject *query;  // query proc
+    PyObject *rp;  // run proc
+
+    if (!PyArg_ParseTuple(args, "OOOO:main", &ip, &qp, &query, &rp))
+        return NULL;
+
+#define Arg_Check(v) (PyCallable_Check(v) || (v) == Py_None)
+
+    if (!Arg_Check(ip) || !Arg_Check(qp) || !Arg_Check(query) ||
+        !Arg_Check(rp)) {
+        PyErr_SetString(pygimp_error, "arguments must be callable");
+        return NULL;
+    }
+
+#undef Arg_Check
+
+    if (query == Py_None) {
+        PyErr_SetString(pygimp_error, "a query procedure must be provided");
+        return NULL;
+    }
+
+    if (ip != Py_None) {
+        callbacks[0] = ip;
+        PLUG_IN_INFO.init_proc = pygimp_init_proc;
+    }
+
+    if (qp != Py_None) {
+        callbacks[1] = qp;
+        PLUG_IN_INFO.quit_proc = pygimp_quit_proc;
+    }
+
+    if (query != Py_None) {
+        callbacks[2] = query;
+        PLUG_IN_INFO.query_proc = pygimp_query_proc;
+    }
+
+    if (rp != Py_None) {
+        callbacks[3] = rp;
+        PLUG_IN_INFO.run_proc = pygimp_run_proc;
+    }
+
+    av = PySys_GetObject("argv");
+
+    argc = PyList_Size(av);
+    argv = g_new(char *, argc);
+
+    for (i = 0; i < argc; i++)
+        argv[i] = g_strdup(PyString_AsString(PyList_GetItem(av, i)));
+
+    gimp_main(&PLUG_IN_INFO, argc, argv);
+
+    if (argv != NULL) {
+        for (i = 0; i < argc; i++)
+            if (argv[i] != NULL)
+                g_free(argv[i]);
+
+        g_free(argv);
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_quit(PyObject *self)
+{
+    gimp_quit();
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_message(PyObject *self, PyObject *args)
+{
+    char *msg;
+
+    if (!PyArg_ParseTuple(args, "s:message", &msg))
+        return NULL;
+
+    gimp_message(msg);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_exit(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    gboolean force = FALSE;
+    int nreturn_vals;
+    GimpParam *return_vals;
+
+    static char *kwlist[] = { "force", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:exit", kwlist, &force))
+        return NULL;
+
+    return_vals = gimp_run_procedure("gimp-quit",
+                                     &nreturn_vals,
+                                     GIMP_PDB_INT32, force,
+                                     GIMP_PDB_END);
+
+    if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS) {
+        PyErr_SetString(pygimp_error, "error while exiting");
+        return NULL;
+    }
+
+    gimp_destroy_params(return_vals, nreturn_vals);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_set_data(PyObject *self, PyObject *args)
+{
+    char *id, *data;
+    int bytes, nreturn_vals;
+    GimpParam *return_vals;
+
+    if (!PyArg_ParseTuple(args, "ss#:set_data", &id, &data, &bytes))
+        return NULL;
+
+    return_vals = gimp_run_procedure("gimp-procedural-db-set-data",
+                                     &nreturn_vals,
+                                     GIMP_PDB_STRING, id,
+                                     GIMP_PDB_INT32, bytes,
+                                     GIMP_PDB_INT8ARRAY, data,
+                                     GIMP_PDB_END);
+
+    if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS) {
+        PyErr_SetString(pygimp_error, "error occurred while storing");
+        return NULL;
+    }
+
+    gimp_destroy_params(return_vals, nreturn_vals);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_get_data(PyObject *self, PyObject *args)
+{
+    char *id;
+    int nreturn_vals;
+    GimpParam *return_vals;
+    PyObject *s;
+
+    if (!PyArg_ParseTuple(args, "s:get_data", &id))
+        return NULL;
+
+    return_vals = gimp_run_procedure("gimp-procedural-db-get-data",
+                                     &nreturn_vals,
+                                     GIMP_PDB_STRING, id,
+                                     GIMP_PDB_END);
+
+    if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS) {
+        PyErr_SetString(pygimp_error, "no data for id");
+        return NULL;
+    }
+
+    s = PyString_FromStringAndSize((char *)return_vals[2].data.d_int8array,
+                                   return_vals[1].data.d_int32);
+    gimp_destroy_params(return_vals, nreturn_vals);
+
+    return s;
+}
+
+static PyObject *
+pygimp_progress_init(PyObject *self, PyObject *args)
+{
+    char *msg = NULL;
+
+    if (!PyArg_ParseTuple(args, "|s:progress_init", &msg))
+        return NULL;
+
+    gimp_progress_init(msg);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_progress_update(PyObject *self, PyObject *args)
+{
+    double p;
+
+    if (!PyArg_ParseTuple(args, "d:progress_update", &p))
+        return NULL;
+
+    gimp_progress_update(p);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static void
+pygimp_progress_start(const gchar *message, gboolean cancelable, gpointer data)
+{
+    ProgressData *pdata = data;
+    PyObject *r;
+
+    if (pdata->user_data) {
+        r = PyObject_CallFunction(pdata->start, "siO", message, cancelable,
+                                  pdata->user_data);
+        Py_DECREF(pdata->user_data);
+    } else
+        r = PyObject_CallFunction(pdata->start, "si", message, cancelable);
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_progress_end(gpointer data)
+{
+    ProgressData *pdata = data;
+    PyObject *r;
+
+    if (pdata->user_data) {
+        r = PyObject_CallFunction(pdata->end, "O", pdata->user_data);
+        Py_DECREF(pdata->user_data);
+    } else
+        r = PyObject_CallFunction(pdata->end, NULL);
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_progress_text(const gchar *message, gpointer data)
+{
+    ProgressData *pdata = data;
+    PyObject *r;
+
+    if (pdata->user_data) {
+        r = PyObject_CallFunction(pdata->text, "sO", message, pdata->user_data);
+        Py_DECREF(pdata->user_data);
+    } else
+        r = PyObject_CallFunction(pdata->text, "s", message);
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static void
+pygimp_progress_value(gdouble percentage, gpointer data)
+{
+    ProgressData *pdata = data;
+    PyObject *r;
+
+    if (pdata->user_data) {
+        r = PyObject_CallFunction(pdata->value, "dO", percentage,
+                                  pdata->user_data);
+        Py_DECREF(pdata->user_data);
+    } else
+        r = PyObject_CallFunction(pdata->value, "d", percentage);
+
+    if (!r) {
+        PyErr_Print();
+        PyErr_Clear();
+        return;
+    }
+
+    Py_DECREF(r);
+}
+
+static PyObject *
+pygimp_progress_install(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    GimpProgressVtable vtable = { 0, };
+    const gchar *ret;
+    ProgressData *pdata;
+    static char *kwlist[] = { "start", "end", "text", "value", "data", NULL };
+
+    pdata = g_new0(ProgressData, 1);
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:progress_install",
+                                     kwlist,
+                                     &pdata->start, &pdata->end,
+                                     &pdata->text, &pdata->value,
+                                     &pdata->user_data))
+        goto cleanup;
+
+#define PROCESS_FUNC(n) G_STMT_START {                                  \
+    if (!PyCallable_Check(pdata->n)) {                                  \
+        PyErr_SetString(pygimp_error, #n "argument must be callable");  \
+        goto cleanup;                                                   \
+    }                                                                   \
+    Py_INCREF(pdata->n);                                                \
+} G_STMT_END
+
+    PROCESS_FUNC(start);
+    PROCESS_FUNC(end);
+    PROCESS_FUNC(text);
+    PROCESS_FUNC(value);
+
+    Py_XINCREF(pdata->user_data);
+
+#undef PROCESS_FUNC
+
+    vtable.start     = pygimp_progress_start;
+    vtable.end       = pygimp_progress_end;
+    vtable.set_text  = pygimp_progress_text;
+    vtable.set_value = pygimp_progress_value;
+
+    ret = gimp_progress_install_vtable(&vtable, pdata);
+
+    if (!ret) {
+        PyErr_SetString(pygimp_error,
+                        "error occurred while installing progress functions");
+
+        Py_DECREF(pdata->start);
+        Py_DECREF(pdata->end);
+        Py_DECREF(pdata->text);
+        Py_DECREF(pdata->value);
+
+        goto cleanup;
+    }
+
+    return PyString_FromString(ret);
+
+cleanup:
+    g_free(pdata);
+    return NULL;
+}
+
+static PyObject *
+pygimp_progress_uninstall(PyObject *self, PyObject *args)
+{
+    ProgressData *pdata;
+    gchar *callback;
+
+    if (!PyArg_ParseTuple(args, "s:progress_uninstall", &callback))
+        return NULL;
+
+    pdata = gimp_progress_uninstall(callback);
+
+    if (!pdata) {
+        PyErr_SetString(pygimp_error,
+                        "error occurred while uninstalling progress functions");
+        return NULL;
+    }
+
+    Py_DECREF(pdata->start);
+    Py_DECREF(pdata->end);
+    Py_DECREF(pdata->text);
+    Py_DECREF(pdata->value);
+
+    Py_XDECREF(pdata->user_data);
+
+    g_free(pdata);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_image_list(PyObject *self)
+{
+    gint32 *imgs;
+    int nimgs, i;
+    PyObject *ret;
+
+    imgs = gimp_image_list(&nimgs);
+    ret = PyList_New(nimgs);
+
+    for (i = 0; i < nimgs; i++)
+        PyList_SetItem(ret, i, (PyObject *)pygimp_image_new(imgs[i]));
+
+    g_free(imgs);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_install_procedure(PyObject *self, PyObject *args)
+{
+    char *name, *blurb, *help, *author, *copyright, *date, *menu_path,
+         *image_types, *n, *d;
+    GimpParamDef *params, *return_vals;
+    int type, nparams, nreturn_vals, i;
+    PyObject *pars, *rets;
+
+    if (!PyArg_ParseTuple(args, "sssssszziOO:install_procedure",
+                          &name, &blurb, &help,
+                          &author, &copyright, &date, &menu_path, &image_types,
+                          &type, &pars, &rets))
+        return NULL;
+
+    if (!PySequence_Check(pars) || !PySequence_Check(rets)) {
+        PyErr_SetString(PyExc_TypeError, "last two args must be sequences");
+        return NULL;
+    }
+
+    nparams = PySequence_Length(pars);
+    nreturn_vals = PySequence_Length(rets);
+    params = g_new(GimpParamDef, nparams);
+
+    for (i = 0; i < nparams; i++) {
+        if (!PyArg_ParseTuple(PySequence_GetItem(pars, i), "iss",
+                              &(params[i].type), &n, &d)) {
+            g_free(params);
+            return NULL;
+        }
+
+        params[i].name = g_strdup(n);
+        params[i].description = g_strdup(d);
+    }
+
+    return_vals = g_new(GimpParamDef, nreturn_vals);
+
+    for (i = 0; i < nreturn_vals; i++) {
+        if (!PyArg_ParseTuple(PySequence_GetItem(rets, i), "iss",
+                              &(return_vals[i].type), &n, &d)) {
+            g_free(params); g_free(return_vals);
+            return NULL;
+        }
+
+        return_vals[i].name = g_strdup(n);
+        return_vals[i].description = g_strdup(d);
+    }
+
+    gimp_install_procedure(name, blurb, help, author, copyright, date,
+                           menu_path, image_types, type, nparams, nreturn_vals,
+                           params, return_vals);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_install_temp_proc(PyObject *self, PyObject *args)
+{
+    char *name, *blurb, *help, *author, *copyright, *date, *menu_path,
+        *image_types, *n, *d;
+    GimpParamDef *params, *return_vals;
+    int type, nparams, nreturn_vals, i;
+    PyObject *pars, *rets;
+
+    if (!PyArg_ParseTuple(args, "sssssszziOO:install_temp_proc",
+                          &name, &blurb, &help,
+                          &author, &copyright, &date, &menu_path, &image_types,
+                          &type, &pars, &rets))
+        return NULL;
+
+    if (!PySequence_Check(pars) || !PySequence_Check(rets)) {
+        PyErr_SetString(PyExc_TypeError, "last two args must be sequences");
+        return NULL;
+    }
+
+    nparams = PySequence_Length(pars);
+    nreturn_vals = PySequence_Length(rets);
+    params = g_new(GimpParamDef, nparams);
+
+    for (i = 0; i < nparams; i++) {
+        if (!PyArg_ParseTuple(PySequence_GetItem(pars, i), "iss",
+                              &(params[i].type), &n, &d)) {
+            g_free(params);
+            return NULL;
+        }
+
+        params[i].name = g_strdup(n);
+        params[i].description = g_strdup(d);
+    }
+
+    return_vals = g_new(GimpParamDef, nreturn_vals);
+
+    for (i = 0; i < nreturn_vals; i++) {
+        if (!PyArg_ParseTuple(PySequence_GetItem(rets, i), "iss",
+                              &(return_vals[i].type), &n, &d)) {
+            g_free(params); g_free(return_vals);
+            return NULL;
+        }
+
+        return_vals[i].name = g_strdup(n);
+        return_vals[i].description = g_strdup(d);
+    }
+
+    gimp_install_temp_proc(name, blurb, help, author, copyright, date,
+                           menu_path, image_types, type,
+                           nparams, nreturn_vals, params, return_vals,
+                           pygimp_run_proc);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_uninstall_temp_proc(PyObject *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:uninstall_temp_proc", &name))
+        return NULL;
+
+    gimp_uninstall_temp_proc(name);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_register_magic_load_handler(PyObject *self, PyObject *args)
+{
+    char *name, *extensions, *prefixes, *magics;
+
+    if (!PyArg_ParseTuple(args, "ssss:register_magic_load_handler",
+                          &name, &extensions, &prefixes, &magics))
+        return NULL;
+
+    gimp_register_magic_load_handler(name, extensions, prefixes, magics);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_register_load_handler(PyObject *self, PyObject *args)
+{
+    char *name, *extensions, *prefixes;
+
+    if (!PyArg_ParseTuple(args, "sss:register_load_handler",
+                          &name, &extensions, &prefixes))
+        return NULL;
+
+    gimp_register_load_handler(name, extensions, prefixes);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_register_save_handler(PyObject *self, PyObject *args)
+{
+    char *name, *extensions, *prefixes;
+
+    if (!PyArg_ParseTuple(args, "sss:register_save_handler",
+                          &name, &extensions, &prefixes))
+        return NULL;
+
+    gimp_register_save_handler(name, extensions, prefixes);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_domain_register(PyObject *self, PyObject *args)
+{
+    char *name, *path = NULL;
+
+    if (!PyArg_ParseTuple(args, "s|s:domain_register", &name, &path))
+        return NULL;
+
+    gimp_plugin_domain_register(name, path);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_menu_register(PyObject *self, PyObject *args)
+{
+    char *name, *path;
+
+    if (!PyArg_ParseTuple(args, "ss:menu_register", &name, &path))
+        return NULL;
+
+    gimp_plugin_menu_register(name, path);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_gamma(PyObject *self)
+{
+    return PyFloat_FromDouble(gimp_gamma());
+}
+
+static PyObject *
+pygimp_gtkrc(PyObject *self)
+{
+    return PyString_FromString(gimp_gtkrc());
+}
+
+static PyObject *
+pygimp_personal_rc_file(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *basename, *filename;
+    PyObject *ret;
+
+    static char *kwlist[] = { "basename", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "s:personal_rc_file", kwlist,
+                                     &basename))
+        return NULL;
+
+    filename = gimp_personal_rc_file(basename);
+    ret = PyString_FromString(filename);
+    g_free(filename);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_context_push(PyObject *self)
+{
+    gimp_context_push();
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_context_pop(PyObject *self)
+{
+    gimp_context_pop();
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_get_background(PyObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_context_get_background(&rgb);
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_get_foreground(PyObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_context_get_foreground(&rgb);
+    return pygimp_rgb_new(&rgb);
+}
+
+static PyObject *
+pygimp_set_background(PyObject *self, PyObject *args)
+{
+    PyObject *color;
+    GimpRGB rgb;
+
+    if (PyArg_ParseTuple(args, "O:set_background", &color)) {
+        if (!pygimp_rgb_from_pyobject(color, &rgb))
+            return NULL;
+    } else {
+        PyErr_Clear();
+        if (!pygimp_rgb_from_pyobject(args, &rgb))
+            return NULL;
+    }
+
+    gimp_context_set_background(&rgb);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_set_foreground(PyObject *self, PyObject *args)
+{
+    PyObject *color;
+    GimpRGB rgb;
+
+    if (PyArg_ParseTuple(args, "O:set_foreground", &color)) {
+        if (!pygimp_rgb_from_pyobject(color, &rgb))
+            return NULL;
+    } else {
+        PyErr_Clear();
+        if (!pygimp_rgb_from_pyobject(args, &rgb))
+            return NULL;
+    }
+
+    gimp_context_set_foreground(&rgb);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_gradients_get_list(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char **list, *filter = NULL;
+    int num, i;
+    PyObject *ret;
+
+    static char *kwlist[] = { "filter", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|s:gradients_get_list", kwlist,
+                                     &filter))
+        return NULL;
+
+    list = gimp_gradients_get_list(filter, &num);
+
+    ret = PyList_New(num);
+
+    for (i = 0; i < num; i++) {
+        PyList_SetItem(ret, i, PyString_FromString(list[i]));
+    }
+
+    g_strfreev(list);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_context_get_gradient(PyObject *self)
+{
+    char *name;
+    PyObject *ret;
+
+    name = gimp_context_get_gradient();
+    ret = PyString_FromString(name);
+    g_free(name);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_gradients_get_gradient(PyObject *self)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimp.context_get_gradient") < 0)
+        return NULL;
+
+    return pygimp_context_get_gradient(self);
+}
+
+static PyObject *
+pygimp_context_set_gradient(PyObject *self, PyObject *args)
+{
+    char *actv;
+
+    if (!PyArg_ParseTuple(args, "s:gradients_set_gradient", &actv))
+        return NULL;
+
+    gimp_context_set_gradient(actv);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_gradients_set_gradient(PyObject *self, PyObject *args)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimp.context_set_gradient") < 0)
+        return NULL;
+
+    return pygimp_context_set_gradient(self, args);
+}
+
+static PyObject *
+pygimp_gradient_get_uniform_samples(PyObject *self, PyObject *args)
+{
+    int num, reverse = FALSE;
+    char *name;
+    int nsamp;
+    double *samp;
+    int i, j;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, "si|i:gradient_get_uniform_samples",
+                          &name, &num, &reverse))
+        return NULL;
+
+    if (!gimp_gradient_get_uniform_samples(name, num, reverse, &nsamp, &samp)) {
+        PyErr_SetString(pygimp_error, "gradient_get_uniform_samples failed");
+        return NULL;
+    }
+
+    ret = PyList_New(num);
+    for (i = 0, j = 0; i < num; i++, j += 4)
+        PyList_SetItem(ret, i, Py_BuildValue("(dddd)", samp[j],
+                                             samp[j+1], samp[j+2], samp[j+3]));
+
+    g_free(samp);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_gradient_get_custom_samples(PyObject *self, PyObject *args)
+{
+    int num, reverse = FALSE;
+    char *name;
+    int nsamp;
+    double *pos, *samp;
+    int i, j;
+    PyObject *ret, *item;
+    gboolean success;
+
+    if (!PyArg_ParseTuple(args, "sO|i:gradient_get_custom_samples",
+                          &name, &ret, &reverse))
+        return NULL;
+
+    if (!PySequence_Check(ret)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "second arg must be a sequence");
+        return NULL;
+    }
+
+    num = PySequence_Length(ret);
+    pos = g_new(gdouble, num);
+
+    for (i = 0; i < num; i++) {
+        item = PySequence_GetItem(ret, i);
+
+        if (!PyFloat_Check(item)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "second arg must be a sequence of floats");
+            g_free(pos);
+            return NULL;
+        }
+
+        pos[i] = PyFloat_AsDouble(item);
+    }
+
+    success = gimp_gradient_get_custom_samples(name, num, pos, reverse,
+                                               &nsamp, &samp);
+    g_free(pos);
+
+    if (!success) {
+        PyErr_SetString(pygimp_error, "gradient_get_custom_samples failed");
+        return NULL;
+    }
+
+    ret = PyList_New(num);
+    for (i = 0, j = 0; i < num; i++, j += 4)
+        PyList_SetItem(ret, i, Py_BuildValue("(dddd)", samp[j],
+                                             samp[j+1], samp[j+2], samp[j+3]));
+
+    g_free(samp);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_gradients_sample_uniform(PyObject *self, PyObject *args)
+{
+    char *name;
+    PyObject *arg_list, *str, *new_args, *ret;
+
+    if (PyErr_Warn(PyExc_DeprecationWarning,
+                   "use gimp.gradient_get_uniform_samples") < 0)
+        return NULL;
+
+    arg_list = PySequence_List(args);
+
+    name = gimp_context_get_gradient();
+
+    str = PyString_FromString(name);
+    g_free(name);
+
+    PyList_Insert(arg_list, 0, str);
+    Py_XDECREF(str);
+
+    new_args = PyList_AsTuple(arg_list);
+    Py_XDECREF(arg_list);
+
+    ret = pygimp_gradient_get_uniform_samples(self, new_args);
+    Py_XDECREF(new_args);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_gradients_sample_custom(PyObject *self, PyObject *args)
+{
+    char *name;
+    PyObject *arg_list, *str, *new_args, *ret;
+
+    if (PyErr_Warn(PyExc_DeprecationWarning,
+                   "use gimp.gradient_get_custom_samples") < 0)
+        return NULL;
+
+    arg_list = PySequence_List(args);
+
+    name = gimp_context_get_gradient();
+
+    str = PyString_FromString(name);
+    g_free(name);
+
+    PyList_Insert(arg_list, 0, str);
+    Py_XDECREF(str);
+
+    new_args = PyList_AsTuple(arg_list);
+    Py_XDECREF(arg_list);
+
+    ret = pygimp_gradient_get_custom_samples(self, new_args);
+
+    return ret;
+}
+
+static PyObject *
+pygimp_delete(PyObject *self, PyObject *args)
+{
+    PyGimpImage *img;
+
+    if (!PyArg_ParseTuple(args, "O:delete", &img))
+        return NULL;
+
+    if (pygimp_image_check(img))
+        gimp_image_delete(img->ID);
+    else if (pygimp_drawable_check(img))
+        gimp_item_delete(img->ID);
+    else if (pygimp_display_check(img))
+        gimp_display_delete(img->ID);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+pygimp_displays_flush(PyObject *self)
+{
+    gimp_displays_flush();
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_displays_reconnect(PyObject *self, PyObject *args)
+{
+    PyGimpImage *old_img, *new_img;
+
+    if (!PyArg_ParseTuple(args, "O!O!:displays_reconnect",
+                          &PyGimpImage_Type, &old_img,
+                          &PyGimpImage_Type, &new_img))
+        return NULL;
+
+    if (!gimp_displays_reconnect (old_img->ID, new_img->ID)) {
+        PyErr_Format(pygimp_error,
+                     "could not reconnect the displays of image (ID %d) "
+                     "to image (ID %d)",
+                     old_img->ID, new_img->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_tile_cache_size(PyObject *self, PyObject *args)
+{
+    unsigned long k;
+
+    if (!PyArg_ParseTuple(args, "l:tile_cache_size", &k))
+        return NULL;
+
+    gimp_tile_cache_size(k);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+pygimp_tile_cache_ntiles(PyObject *self, PyObject *args)
+{
+    unsigned long n;
+
+    if (!PyArg_ParseTuple(args, "l:tile_cache_ntiles", &n))
+        return NULL;
+
+    gimp_tile_cache_ntiles(n);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+pygimp_tile_width(PyObject *self)
+{
+    return PyInt_FromLong(gimp_tile_width());
+}
+
+
+static PyObject *
+pygimp_tile_height(PyObject *self)
+{
+    return PyInt_FromLong(gimp_tile_height());
+}
+
+static PyObject *
+pygimp_extension_ack(PyObject *self)
+{
+    gimp_extension_ack();
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_extension_enable(PyObject *self)
+{
+    gimp_extension_enable();
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_extension_process(PyObject *self, PyObject *args)
+{
+    guint timeout;
+
+    if (!PyArg_ParseTuple(args, "I:extension_process", &timeout))
+        return NULL;
+
+    gimp_extension_process(timeout);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_parasite_find(PyObject *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_find", &name))
+        return NULL;
+
+    return pygimp_parasite_new(gimp_get_parasite(name));
+}
+
+static PyObject *
+pygimp_parasite_attach(PyObject *self, PyObject *args)
+{
+    PyGimpParasite *parasite;
+
+    if (!PyArg_ParseTuple(args, "O!:parasite_attach",
+                          &PyGimpParasite_Type, &parasite))
+        return NULL;
+
+    if (!gimp_attach_parasite(parasite->para)) {
+        PyErr_Format(pygimp_error, "could not attach parasite '%s'",
+                     gimp_parasite_name(parasite->para));
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_attach_new_parasite(PyObject *self, PyObject *args)
+{
+    GimpParasite *parasite;
+    char *name, *data;
+    int flags, size;
+
+    if (!PyArg_ParseTuple(args, "sis#:attach_new_parasite", &name, &flags,
+                          &data, &size))
+        return NULL;
+
+    parasite = gimp_parasite_new (name, flags, size, data);
+
+    if (!gimp_attach_parasite (parasite)) {
+        PyErr_Format(pygimp_error, "could not attach new parasite '%s'", name);
+        gimp_parasite_free (parasite);
+        return NULL;
+    }
+
+    gimp_parasite_free (parasite);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_parasite_detach(PyObject *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_detach", &name))
+        return NULL;
+
+    if (!gimp_detach_parasite(name)) {
+        PyErr_Format(pygimp_error, "could not detach parasite '%s'", name);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_parasite_list(PyObject *self)
+{
+    gint num_parasites;
+    gchar **parasites;
+    PyObject *ret;
+    gint i;
+
+    parasites = gimp_get_parasite_list (&num_parasites);
+
+    ret = PyTuple_New(num_parasites);
+
+    for (i = 0; i < num_parasites; i++)
+        PyTuple_SetItem(ret, i, PyString_FromString(parasites[i]));
+
+    g_strfreev(parasites);
+    return ret;
+}
+
+static PyObject *
+pygimp_show_tool_tips(PyObject *self)
+{
+    return PyBool_FromLong(gimp_show_tool_tips());
+}
+
+static PyObject *
+pygimp_show_help_button(PyObject *self)
+{
+    return PyBool_FromLong(gimp_show_help_button());
+}
+
+static PyObject *
+pygimp_check_size(PyObject *self)
+{
+    return PyInt_FromLong(gimp_check_size());
+}
+
+static PyObject *
+pygimp_check_type(PyObject *self)
+{
+    return PyInt_FromLong(gimp_check_type());
+}
+
+static PyObject *
+pygimp_default_display(PyObject *self)
+{
+    return pygimp_display_new(gimp_default_display());
+}
+
+static PyObject *
+pygimp_wm_class(PyObject *self)
+{
+    return PyString_FromString(gimp_wm_class());
+}
+
+static PyObject *
+pygimp_display_name(PyObject *self)
+{
+    return PyString_FromString(gimp_display_name());
+}
+
+static PyObject *
+pygimp_monitor_number(PyObject *self)
+{
+    return PyInt_FromLong(gimp_monitor_number());
+}
+
+static PyObject *
+pygimp_get_progname(PyObject *self)
+{
+    return PyString_FromString(gimp_get_progname());
+}
+
+static PyObject *
+pygimp_user_directory(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    GimpUserDirectory type;
+    const char *user_dir;
+    PyObject *py_type, *ret;
+
+    static char *kwlist[] = { "type", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O:user_directory", kwlist,
+                                     &py_type))
+        return NULL;
+
+    if (pyg_enum_get_value(GIMP_TYPE_USER_DIRECTORY, py_type, (gpointer)&type))
+        return NULL;
+
+    /* GimpUserDirectory and GUserDirectory are compatible */
+    user_dir = g_get_user_special_dir((GUserDirectory)type);
+
+    if (user_dir) {
+        ret = PyString_FromString(user_dir);
+    } else {
+        Py_INCREF(Py_None);
+	ret = Py_None;
+    }
+
+    return ret;
+}
+
+static PyObject *
+pygimp_fonts_refresh(PyObject *self)
+{
+    if (!gimp_fonts_refresh()) {
+        PyErr_SetString(pygimp_error, "could not refresh fonts");
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_checks_get_shades(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    int type;
+    guchar light, dark;
+    static char *kwlist[] = { "type", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "i:checks_get_shades", kwlist,
+                                     &type))
+        return NULL;
+
+    if (type < GIMP_CHECK_TYPE_LIGHT_CHECKS ||
+        type > GIMP_CHECK_TYPE_BLACK_ONLY) {
+        PyErr_SetString(PyExc_ValueError, "Invalid check type");
+        return NULL;
+    }
+
+    gimp_checks_get_shades(type, &light, &dark);
+
+    return Py_BuildValue("(ii)", light, dark);
+}
+
+static PyObject *
+pygimp_fonts_get_list(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char **list, *filter = NULL;
+    int num, i;
+    PyObject *ret;
+
+    static char *kwlist[] = { "filter", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|s:fonts_get_list", kwlist,
+                                     &filter))
+        return NULL;
+
+    list = gimp_fonts_get_list(filter, &num);
+
+    if (num == 0) {
+        PyErr_SetString(pygimp_error, "could not get font list");
+        return NULL;
+    }
+
+    ret = PyList_New(num);
+
+    for (i = 0; i < num; i++) {
+        PyList_SetItem(ret, i, PyString_FromString(list[i]));
+    }
+
+    g_strfreev(list);
+
+    return ret;
+}
+
+static PyObject *
+vectors_to_objects(int num_vectors, int *vectors)
+{
+    PyObject *ret;
+    int i;
+
+    ret = PyList_New(num_vectors);
+    if (ret == NULL)
+        goto done;
+
+    for (i = 0; i < num_vectors; i++)
+        PyList_SetItem(ret, i, pygimp_vectors_new(vectors[i]));
+
+done:
+    g_free(vectors);
+    return ret;
+}
+
+static PyObject *
+pygimp_vectors_import_from_file(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    PyObject *py_file;
+    gboolean merge = FALSE, scale = FALSE;
+    int *vectors, num_vectors;
+    gboolean success;
+
+    static char *kwlist[] = { "image", "svg_file", "merge", "scale", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!O|ii:vectors_import_from_file", kwlist,
+                                     &PyGimpImage_Type, &img, &py_file,
+                                     &merge, &scale))
+        return NULL;
+
+    if (PyString_Check(py_file)) {
+        success = gimp_vectors_import_from_file(img->ID,
+                                                PyString_AsString(py_file),
+                                                merge, scale,
+                                                &num_vectors, &vectors);
+    } else {
+        PyObject *chunk_size, *buffer, *read_method;
+
+        chunk_size = PyInt_FromLong(16 * 1024);
+        if (chunk_size == NULL)
+            return NULL;
+
+        buffer = PyString_FromString("");
+        if (buffer == NULL) {
+            Py_DECREF(chunk_size);
+            return NULL;
+        }
+
+        read_method = PyString_FromString("read");
+        if (read_method == NULL || !PyCallable_Check(read_method)) {
+            Py_XDECREF(read_method);
+            PyErr_SetString(PyExc_TypeError,
+                            "svg_file must be an object that has a \"read\" "
+                            "method, or a filename (str)");
+            return NULL;
+        }
+
+        while (1) {
+            PyObject *chunk;
+            chunk = PyObject_CallMethodObjArgs(py_file, read_method,
+                                               chunk_size, NULL);
+
+            if (!chunk || !PyString_Check(chunk)) {
+                Py_XDECREF(chunk);
+                Py_DECREF(chunk_size);
+                Py_DECREF(buffer);
+                Py_DECREF(read_method);
+                return NULL;
+            }
+
+            if (PyString_GET_SIZE(chunk) != 0) {
+                PyString_ConcatAndDel(&buffer, chunk);
+                if (buffer == NULL) {
+                    Py_DECREF(chunk_size);
+                    Py_DECREF(read_method);
+                    return NULL;
+                }
+            } else {
+                Py_DECREF(chunk);
+                break;
+            }
+        }
+
+        success = gimp_vectors_import_from_string(img->ID,
+                                                  PyString_AsString(buffer),
+                                                  PyString_Size(buffer),
+                                                  merge, scale,
+                                                  &num_vectors, &vectors);
+
+        Py_DECREF(chunk_size);
+        Py_DECREF(buffer);
+        Py_DECREF(read_method);
+    }
+
+    if (!success) {
+        PyErr_Format(pygimp_error,
+                     "Vectors import failed: %s", gimp_get_pdb_error());
+        return NULL;
+    }
+
+    return vectors_to_objects(num_vectors, vectors);
+}
+
+static PyObject *
+pygimp_vectors_import_from_string(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    const char *svg_string;
+    int length;
+    gboolean merge = FALSE, scale = FALSE;
+    int *vectors, num_vectors;
+    gboolean success;
+
+    static char *kwlist[] = { "image", "svg_string", "merge", "scale", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!s#|ii:vectors_import_from_string", kwlist,
+                                     &PyGimpImage_Type, &img,
+                                     &svg_string, &length,
+                                     &merge, &scale))
+        return NULL;
+
+    success = gimp_vectors_import_from_string(img->ID, svg_string, length,
+                                              merge, scale,
+                                              &num_vectors, &vectors);
+
+    if (!success) {
+        PyErr_Format(pygimp_error,
+                     "Vectors import failed: %s", gimp_get_pdb_error());
+        return NULL;
+    }
+
+    return vectors_to_objects(num_vectors, vectors);
+}
+
+static PyObject *
+id2image(PyObject *self, PyObject *args)
+{
+    int id;
+
+    if (!PyArg_ParseTuple(args, "i:_id2image", &id))
+        return NULL;
+
+    if (id >= 0)
+        return pygimp_image_new(id);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+id2drawable(PyObject *self, PyObject *args)
+{
+    int id;
+
+    if (!PyArg_ParseTuple(args, "i:_id2drawable", &id))
+        return NULL;
+
+    if (id >= 0)
+        return pygimp_drawable_new(NULL, id);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+id2display(PyObject *self, PyObject *args)
+{
+    int id;
+
+    if (!PyArg_ParseTuple(args, "i:_id2display", &id))
+        return NULL;
+
+    if (id >= 0)
+        return pygimp_display_new(id);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+id2vectors(PyObject *self, PyObject *args)
+{
+    int id;
+
+    if (!PyArg_ParseTuple(args, "i:_id2vectors", &id))
+        return NULL;
+
+    if (id >= 0)
+        return pygimp_vectors_new(id);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+pygimp_export_image (PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    PyGimpDrawable *drw = NULL;
+    gchar *format_name = NULL;
+    unsigned int capabilities = -1;
+    GimpExportReturn result;
+    gint32  img_id;
+    gint32  drw_id;
+    PyObject *return_values;
+
+    static char *kwlist[] = { "image", "drawable", "format_name", "capabilities", NULL };
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|OsI:export_image", kwlist,
+                                    &PyGimpImage_Type, &img,
+                                    &drw,
+                                    &format_name,
+                                    &capabilities))
+        return NULL;
+    if (capabilities == -1) {
+         PyErr_SetString(PyExc_TypeError,
+                         "the \"capabilities\" (4th) parameter must be set with "
+                         "a combination of the "
+                         "EXPORT_CAN_HANDLE_*/EXPORT_NEEDS_ALPHA values. "
+                         "(check developer documentation on the C function "
+                         "gimp_export_image for details)"
+                         );
+        return NULL;
+    }
+
+    /* If no drawable is given, assume the active drawable */
+    if (drw == NULL) {
+        drw = (PyGimpDrawable *)PyObject_GetAttrString((PyObject *)img,
+                                                       "active_drawable");
+        if ((PyObject *)drw == Py_None) {
+            PyErr_SetString(PyExc_ValueError,
+                            "No active drawable in the image and no drawable "
+                            " specified for export."
+                           );
+            return NULL;
+        }
+    }
+    img_id = img->ID;
+    drw_id = drw->ID;
+
+    result = gimp_export_image(&img_id, &drw_id, format_name, capabilities);
+
+    if (img_id != img->ID) {
+        img = (PyGimpImage *)pygimp_image_new(img_id);
+    }
+    else {
+        Py_INCREF(img);
+    }
+    if (drw_id != drw->ID) {
+        drw = (PyGimpDrawable *)pygimp_drawable_new(NULL, drw_id);
+    }
+    else {
+        Py_INCREF(drw);
+    }
+
+    return_values = PyTuple_New(3);
+    PyTuple_SetItem(return_values, 0, PyInt_FromLong(result));
+    PyTuple_SetItem(return_values, 1, (PyObject *)img);
+    PyTuple_SetItem(return_values, 2, (PyObject *)drw);
+
+    return return_values;
+}
+
+static PyObject *
+pygimp_export_dialog_new (PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *format_name;
+    gchar *role = NULL;
+    gchar *help_id = NULL;
+    GtkWidget *dialog = NULL;
+
+    static char *kwlist[] = { "format_name", "role", "help_id", NULL };
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ss:export_dialog", kwlist,
+                                     &format_name,
+                                     &role,
+                                     &help_id))
+        return NULL;
+
+    if (role == NULL) {
+        role = "gimp_export_image";
+    }
+
+    dialog = gimp_export_dialog_new(format_name, role, help_id);
+
+    /* pyobject_new handles NULL values */
+
+    return pygobject_new((GObject *)dialog);
+
+}
+
+/* No need to expose "gimp_export_dialog_get_content_area",
+ * because one just have to call the "get_content_area" method
+ * on the returned export_dialog
+ */
+
+
+/* List of methods defined in the module */
+
+static struct PyMethodDef gimp_methods[] = {
+    {"main",    (PyCFunction)pygimp_main,       METH_VARARGS},
+    {"quit",    (PyCFunction)pygimp_quit,       METH_NOARGS},
+    {"message", (PyCFunction)pygimp_message,    METH_VARARGS},
+    {"exit",    (PyCFunction)pygimp_exit,       METH_VARARGS | METH_KEYWORDS},
+    {"set_data",        (PyCFunction)pygimp_set_data,   METH_VARARGS},
+    {"get_data",        (PyCFunction)pygimp_get_data,   METH_VARARGS},
+    {"progress_init",   (PyCFunction)pygimp_progress_init,      METH_VARARGS},
+    {"progress_update", (PyCFunction)pygimp_progress_update,    METH_VARARGS},
+    {"progress_install",        (PyCFunction)pygimp_progress_install,   METH_VARARGS | METH_KEYWORDS},
+    {"progress_uninstall",      (PyCFunction)pygimp_progress_uninstall, METH_VARARGS},
+    {"image_list",      (PyCFunction)pygimp_image_list, METH_NOARGS},
+    {"install_procedure",       (PyCFunction)pygimp_install_procedure,  METH_VARARGS},
+    {"install_temp_proc",       (PyCFunction)pygimp_install_temp_proc,  METH_VARARGS},
+    {"uninstall_temp_proc",     (PyCFunction)pygimp_uninstall_temp_proc,        METH_VARARGS},
+    {"register_magic_load_handler",     (PyCFunction)pygimp_register_magic_load_handler,        METH_VARARGS},
+    {"register_load_handler",   (PyCFunction)pygimp_register_load_handler,      METH_VARARGS},
+    {"register_save_handler",   (PyCFunction)pygimp_register_save_handler,      METH_VARARGS},
+    {"domain_register",         (PyCFunction)pygimp_domain_register,    METH_VARARGS},
+    {"menu_register",           (PyCFunction)pygimp_menu_register,      METH_VARARGS},
+    {"gamma",   (PyCFunction)pygimp_gamma,      METH_NOARGS},
+    {"gtkrc",   (PyCFunction)pygimp_gtkrc,      METH_NOARGS},
+    {"personal_rc_file",        (PyCFunction)pygimp_personal_rc_file, METH_VARARGS | METH_KEYWORDS},
+    {"context_push", (PyCFunction)pygimp_context_push, METH_NOARGS},
+    {"context_pop", (PyCFunction)pygimp_context_pop, METH_NOARGS},
+    {"get_background",  (PyCFunction)pygimp_get_background,     METH_NOARGS},
+    {"get_foreground",  (PyCFunction)pygimp_get_foreground,     METH_NOARGS},
+    {"set_background",  (PyCFunction)pygimp_set_background,     METH_VARARGS},
+    {"set_foreground",  (PyCFunction)pygimp_set_foreground,     METH_VARARGS},
+    {"gradients_get_list",      (PyCFunction)pygimp_gradients_get_list, METH_VARARGS | METH_KEYWORDS},
+    {"context_get_gradient",    (PyCFunction)pygimp_context_get_gradient,       METH_NOARGS},
+    {"context_set_gradient",    (PyCFunction)pygimp_context_set_gradient,       METH_VARARGS},
+    {"gradients_get_gradient",  (PyCFunction)pygimp_gradients_get_gradient,     METH_NOARGS},
+    {"gradients_set_gradient",  (PyCFunction)pygimp_gradients_set_gradient,     METH_VARARGS},
+    {"gradient_get_uniform_samples",    (PyCFunction)pygimp_gradient_get_uniform_samples,       METH_VARARGS},
+    {"gradient_get_custom_samples",     (PyCFunction)pygimp_gradient_get_custom_samples,        METH_VARARGS},
+    {"gradients_sample_uniform",        (PyCFunction)pygimp_gradients_sample_uniform,   METH_VARARGS},
+    {"gradients_sample_custom", (PyCFunction)pygimp_gradients_sample_custom,    METH_VARARGS},
+    {"delete", (PyCFunction)pygimp_delete, METH_VARARGS},
+    {"displays_flush", (PyCFunction)pygimp_displays_flush, METH_NOARGS},
+    {"displays_reconnect", (PyCFunction)pygimp_displays_reconnect, METH_VARARGS},
+    {"tile_cache_size", (PyCFunction)pygimp_tile_cache_size, METH_VARARGS},
+    {"tile_cache_ntiles", (PyCFunction)pygimp_tile_cache_ntiles, METH_VARARGS},
+    {"tile_width", (PyCFunction)pygimp_tile_width, METH_NOARGS},
+    {"tile_height", (PyCFunction)pygimp_tile_height, METH_NOARGS},
+    {"extension_ack", (PyCFunction)pygimp_extension_ack, METH_NOARGS},
+    {"extension_enable", (PyCFunction)pygimp_extension_enable, METH_NOARGS},
+    {"extension_process", (PyCFunction)pygimp_extension_process, METH_VARARGS},
+    {"parasite_find",      (PyCFunction)pygimp_parasite_find,      METH_VARARGS},
+    {"parasite_attach",    (PyCFunction)pygimp_parasite_attach,    METH_VARARGS},
+    {"attach_new_parasite",(PyCFunction)pygimp_attach_new_parasite,METH_VARARGS},
+    {"parasite_detach",    (PyCFunction)pygimp_parasite_detach,    METH_VARARGS},
+    {"parasite_list",    (PyCFunction)pygimp_parasite_list,    METH_NOARGS},
+    {"show_tool_tips",  (PyCFunction)pygimp_show_tool_tips,  METH_NOARGS},
+    {"show_help_button",  (PyCFunction)pygimp_show_help_button,  METH_NOARGS},
+    {"check_size",  (PyCFunction)pygimp_check_size,  METH_NOARGS},
+    {"check_type",  (PyCFunction)pygimp_check_type,  METH_NOARGS},
+    {"default_display",  (PyCFunction)pygimp_default_display,  METH_NOARGS},
+    {"wm_class", (PyCFunction)pygimp_wm_class,  METH_NOARGS},
+    {"display_name", (PyCFunction)pygimp_display_name,  METH_NOARGS},
+    {"monitor_number", (PyCFunction)pygimp_monitor_number,      METH_NOARGS},
+    {"get_progname", (PyCFunction)pygimp_get_progname,  METH_NOARGS},
+    {"user_directory", (PyCFunction)pygimp_user_directory, METH_VARARGS | METH_KEYWORDS},
+    {"fonts_refresh", (PyCFunction)pygimp_fonts_refresh,        METH_NOARGS},
+    {"fonts_get_list", (PyCFunction)pygimp_fonts_get_list,      METH_VARARGS | METH_KEYWORDS},
+    {"checks_get_shades", (PyCFunction)pygimp_checks_get_shades, METH_VARARGS | METH_KEYWORDS},
+    {"vectors_import_from_file", (PyCFunction)pygimp_vectors_import_from_file, METH_VARARGS | METH_KEYWORDS},
+    {"vectors_import_from_string", (PyCFunction)pygimp_vectors_import_from_string, METH_VARARGS | METH_KEYWORDS},
+    {"_id2image", (PyCFunction)id2image, METH_VARARGS},
+    {"_id2drawable", (PyCFunction)id2drawable, METH_VARARGS},
+    {"_id2display", (PyCFunction)id2display, METH_VARARGS},
+    {"_id2vectors", (PyCFunction)id2vectors, METH_VARARGS},
+    {"export_image", (PyCFunction)pygimp_export_image, METH_VARARGS | METH_KEYWORDS},
+    {"export_dialog", (PyCFunction)pygimp_export_dialog_new, METH_VARARGS | METH_KEYWORDS},
+    {NULL,       (PyCFunction)NULL, 0, NULL}            /* sentinel */
+};
+
+
+static struct _PyGimp_Functions pygimp_api_functions = {
+    &PyGimpImage_Type,
+    pygimp_image_new,
+    &PyGimpDisplay_Type,
+    pygimp_display_new,
+    &PyGimpItem_Type,
+    pygimp_item_new,
+    &PyGimpDrawable_Type,
+    pygimp_drawable_new,
+    &PyGimpLayer_Type,
+    pygimp_layer_new,
+    &PyGimpGroupLayer_Type,
+    pygimp_group_layer_new,
+    &PyGimpChannel_Type,
+    pygimp_channel_new,
+    &PyGimpVectors_Type,
+    pygimp_vectors_new,
+};
+
+
+/* Initialization function for the module (*must* be called initgimp) */
+
+static char gimp_module_documentation[] =
+"This module provides interfaces to allow you to write gimp plug-ins"
+;
+
+void initgimp(void);
+
+PyMODINIT_FUNC
+initgimp(void)
+{
+    PyObject *m;
+
+    PyGimpPDB_Type.ob_type = &PyType_Type;
+    PyGimpPDB_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpPDB_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpPDB_Type) < 0)
+        return;
+
+    PyGimpPDBFunction_Type.ob_type = &PyType_Type;
+    PyGimpPDBFunction_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpPDBFunction_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpPDBFunction_Type) < 0)
+        return;
+
+    PyGimpImage_Type.ob_type = &PyType_Type;
+    PyGimpImage_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpImage_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpImage_Type) < 0)
+        return;
+
+    PyGimpDisplay_Type.ob_type = &PyType_Type;
+    PyGimpDisplay_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpDisplay_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpDisplay_Type) < 0)
+        return;
+
+    PyGimpLayer_Type.ob_type = &PyType_Type;
+    PyGimpLayer_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpLayer_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpLayer_Type) < 0)
+        return;
+
+    PyGimpGroupLayer_Type.ob_type = &PyType_Type;
+    PyGimpGroupLayer_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpGroupLayer_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpGroupLayer_Type) < 0)
+        return;
+
+    PyGimpChannel_Type.ob_type = &PyType_Type;
+    PyGimpChannel_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpChannel_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpChannel_Type) < 0)
+        return;
+
+    PyGimpTile_Type.ob_type = &PyType_Type;
+    PyGimpTile_Type.tp_alloc = PyType_GenericAlloc;
+    if (PyType_Ready(&PyGimpTile_Type) < 0)
+        return;
+
+    PyGimpPixelRgn_Type.ob_type = &PyType_Type;
+    PyGimpPixelRgn_Type.tp_alloc = PyType_GenericAlloc;
+    if (PyType_Ready(&PyGimpPixelRgn_Type) < 0)
+        return;
+
+    PyGimpParasite_Type.ob_type = &PyType_Type;
+    PyGimpParasite_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpParasite_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpParasite_Type) < 0)
+        return;
+
+    PyGimpVectorsStroke_Type.ob_type = &PyType_Type;
+    PyGimpVectorsStroke_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpVectorsStroke_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpVectorsStroke_Type) < 0)
+        return;
+
+    PyGimpVectorsBezierStroke_Type.ob_type = &PyType_Type;
+    PyGimpVectorsBezierStroke_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpVectorsBezierStroke_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpVectorsBezierStroke_Type) < 0)
+        return;
+
+    PyGimpVectors_Type.ob_type = &PyType_Type;
+    PyGimpVectors_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpVectors_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpVectors_Type) < 0)
+        return;
+
+    PyGimpPixelFetcher_Type.ob_type = &PyType_Type;
+    PyGimpPixelFetcher_Type.tp_alloc = PyType_GenericAlloc;
+    PyGimpPixelFetcher_Type.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&PyGimpPixelFetcher_Type) < 0)
+        return;
+
+    pygimp_init_pygobject();
+    init_pygimpcolor();
+
+    /* initialize i18n support */
+    bindtextdomain (GETTEXT_PACKAGE "-python", gimp_locale_directory ());
+#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
+    bind_textdomain_codeset (GETTEXT_PACKAGE "-python", "UTF-8");
+#endif
+
+    /* set the default python encoding to utf-8 */
+    PyUnicode_SetDefaultEncoding("utf-8");
+
+    /* initialize gegl */
+    gegl_init(0, NULL);
+
+    /* Create the module and add the functions */
+    m = Py_InitModule4("gimp", gimp_methods,
+                       gimp_module_documentation,
+                       NULL, PYTHON_API_VERSION);
+
+    /* Add some symbolic constants to the module */
+    pygimp_error = PyErr_NewException("gimp.error", PyExc_RuntimeError, NULL);
+    PyModule_AddObject(m, "error", pygimp_error);
+
+    PyModule_AddObject(m, "pdb", pygimp_pdb_new());
+
+    /* export the types used in gimpmodule */
+    Py_INCREF(&PyGimpImage_Type);
+    PyModule_AddObject(m, "Image", (PyObject *)&PyGimpImage_Type);
+
+    Py_INCREF(&PyGimpItem_Type);
+    PyModule_AddObject(m, "Item", (PyObject *)&PyGimpItem_Type);
+
+    Py_INCREF(&PyGimpDrawable_Type);
+    PyModule_AddObject(m, "Drawable", (PyObject *)&PyGimpDrawable_Type);
+
+    Py_INCREF(&PyGimpLayer_Type);
+    PyModule_AddObject(m, "Layer", (PyObject *)&PyGimpLayer_Type);
+
+    Py_INCREF(&PyGimpGroupLayer_Type);
+    PyModule_AddObject(m, "GroupLayer", (PyObject *)&PyGimpGroupLayer_Type);
+
+    Py_INCREF(&PyGimpChannel_Type);
+    PyModule_AddObject(m, "Channel", (PyObject *)&PyGimpChannel_Type);
+
+    Py_INCREF(&PyGimpDisplay_Type);
+    PyModule_AddObject(m, "Display", (PyObject *)&PyGimpDisplay_Type);
+
+    Py_INCREF(&PyGimpTile_Type);
+    PyModule_AddObject(m, "Tile", (PyObject *)&PyGimpTile_Type);
+
+    Py_INCREF(&PyGimpPixelRgn_Type);
+    PyModule_AddObject(m, "PixelRgn", (PyObject *)&PyGimpPixelRgn_Type);
+
+    Py_INCREF(&PyGimpParasite_Type);
+    PyModule_AddObject(m, "Parasite", (PyObject *)&PyGimpParasite_Type);
+
+    Py_INCREF(&PyGimpVectorsBezierStroke_Type);
+    PyModule_AddObject(m, "VectorsBezierStroke", (PyObject *)&PyGimpVectorsBezierStroke_Type);
+
+    Py_INCREF(&PyGimpVectors_Type);
+    PyModule_AddObject(m, "Vectors", (PyObject *)&PyGimpVectors_Type);
+
+    Py_INCREF(&PyGimpPixelFetcher_Type);
+    PyModule_AddObject(m, "PixelFetcher", (PyObject *)&PyGimpPixelFetcher_Type);
+
+    /* for other modules */
+    pygimp_api_functions.pygimp_error = pygimp_error;
+
+    PyModule_AddObject(m, "_PyGimp_API",
+                       PyCObject_FromVoidPtr(&pygimp_api_functions, NULL));
+
+    PyModule_AddObject(m, "version",
+                       Py_BuildValue("(iii)",
+                                     gimp_major_version,
+                                     gimp_minor_version,
+                                     gimp_micro_version));
+
+    /* Some environment constants */
+    PyModule_AddObject(m, "directory",
+                       PyString_FromString(gimp_directory()));
+    PyModule_AddObject(m, "data_directory",
+                       PyString_FromString(gimp_data_directory()));
+    PyModule_AddObject(m, "locale_directory",
+                       PyString_FromString(gimp_locale_directory()));
+    PyModule_AddObject(m, "sysconf_directory",
+                       PyString_FromString(gimp_sysconf_directory()));
+    PyModule_AddObject(m, "plug_in_directory",
+                       PyString_FromString(gimp_plug_in_directory()));
+
+    /* Check for errors */
+    if (PyErr_Occurred())
+        Py_FatalError("can't initialize module gimp");
+}
diff --git a/plug-ins/pygimp/gimpplugin.py b/plug-ins/pygimp/gimpplugin.py
new file mode 100644
index 0000000..eeaa3f3
--- /dev/null
+++ b/plug-ins/pygimp/gimpplugin.py
@@ -0,0 +1,81 @@
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#    This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#   plugin.py -- helper for writing gimp plugins
+#     Copyright (C) 1997, James Henstridge.
+#
+# This is a small wrapper that makes plugins look like an object class that
+# you can derive to create your plugin.  With this wrapper, you are pretty
+# much responsible for doing everything (checking run_mode, gui, etc).  If
+# you want to write a quick plugin, you probably want the gimpfu module.
+#
+# A plugin using this module would look something like this:
+#
+#   import gimp, gimpplugin
+#
+#   pdb = gimp.pdb
+#
+#   class myplugin(gimpplugin.plugin):
+#       def query(self):
+#           gimp.install_procedure("plug_in_mine", ...)
+#
+#       def plug_in_mine(self, par1, par2, par3,...):
+#           do_something()
+#
+#   if __name__ == '__main__':
+#       myplugin().start()
+
+import gimp
+
+class plugin:
+    def start(self):
+        # only pass the init()/quit() member functions to gimp.main() if the
+        # plug-in overrides them, to avoid the default NOP versions from being
+        # called unnecessarily.  in particular, this avoids plug-ins that don't
+        # implement init() from being registered as having an init function,
+        # causing them to be run at each startup.
+        def get_func(name):
+            if getattr(self.__class__, name) != getattr(plugin, name):
+                return getattr(self, name)
+            else:
+                return None
+
+        gimp.main(get_func("init"),
+                  get_func("quit"),
+                  self.query,
+                  self._run)
+
+    def init(self):
+        pass
+
+    def quit(self):
+        pass
+
+    def query(self):
+        pass
+
+    def _run(self, name, params):
+        import sys
+        if "gimpui" in sys.modules.keys():
+            sys.modules["gimpui"].gimp_ui_init ()
+
+        if hasattr(self, name):
+            return apply(getattr(self, name), params)
+        else:
+            raise AttributeError, name
+
+if __name__ == '__main__':
+    plugin().start()
diff --git a/plug-ins/pygimp/gimpshelf.py b/plug-ins/pygimp/gimpshelf.py
new file mode 100644
index 0000000..999d319
--- /dev/null
+++ b/plug-ins/pygimp/gimpshelf.py
@@ -0,0 +1,92 @@
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# gimpshelf.py -- a simple module to help gimp modules written in Python
+#                 store persistent data.
+#
+# Copyright (C) 1997, James Henstridge
+#
+# The gimp module provides a basic method for storing information that persists
+# for a whole gimp session, but only allows for the storage of strings.  This
+# is because other Python types usually have pointers to other Python objects,
+# making it difficult to work out what to save.  This module gives an interface
+# to the gimp module's primitive interface, which resembles the shelve module.
+
+# use cPickle and cStringIO if available
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+try:
+    import cStringIO as StringIO
+except ImportError:
+    import StringIO
+
+import gimp
+
+import copy_reg
+
+def _image_id(obj):
+    return gimp._id2image, (obj.ID,)
+
+def _drawable_id(obj):
+    return gimp._id2drawable, (obj.ID,)
+
+def _display_id(obj):
+    return gimp._id2display, (obj.ID,)
+
+def _vectors_id(obj):
+    return gimp._id2vectors, (int(obj.ID),)
+
+copy_reg.pickle(gimp.Image,      _image_id,    gimp._id2image)
+copy_reg.pickle(gimp.Layer,      _drawable_id, gimp._id2drawable)
+copy_reg.pickle(gimp.GroupLayer, _drawable_id, gimp._id2drawable)
+copy_reg.pickle(gimp.Channel,    _drawable_id, gimp._id2drawable)
+copy_reg.pickle(gimp.Display,    _display_id,  gimp._id2display)
+copy_reg.pickle(gimp.Vectors,    _vectors_id,  gimp._id2vectors)
+
+del copy_reg, _image_id, _drawable_id, _display_id, _vectors_id
+
+class Gimpshelf:
+    def has_key(self, key):
+        try:
+            s = gimp.get_data(key)
+            return 1
+        except gimp.error:
+            return 0
+
+    def __getitem__(self, key):
+        try:
+            s = gimp.get_data(key)
+        except gimp.error:
+            raise KeyError, key
+
+        f = StringIO.StringIO(s)
+        return pickle.Unpickler(f).load()
+
+    def __setitem__(self, key, value):
+        f = StringIO.StringIO()
+        p = pickle.Pickler(f)
+        p.dump(value)
+        gimp.set_data(key, f.getvalue())
+
+    def __delitem__(self, key):
+        gimp.set_data(key, '')
+
+shelf = Gimpshelf()
+del Gimpshelf
diff --git a/plug-ins/pygimp/gimpthumb.c b/plug-ins/pygimp/gimpthumb.c
new file mode 100644
index 0000000..d917e6b
--- /dev/null
+++ b/plug-ins/pygimp/gimpthumb.c
@@ -0,0 +1,694 @@
+/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
+
+#include <Python.h>
+
+
+
+#line 3 "gimpthumb.override"
+#include <Python.h>
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include <libgimpthumb/gimpthumb.h>
+
+/* TODO: Add a header for these */
+void gimpthumb_register_classes(PyObject *d);
+void gimpthumb_add_constants(PyObject *module, const gchar *strip_prefix);
+#line 21 "gimpthumb.c"
+
+
+/* ---------- types from other modules ---------- */
+static PyTypeObject *_PyGObject_Type;
+#define PyGObject_Type (*_PyGObject_Type)
+static PyTypeObject *_PyGdkPixbuf_Type;
+#define PyGdkPixbuf_Type (*_PyGdkPixbuf_Type)
+
+
+/* ---------- forward type declarations ---------- */
+PyTypeObject G_GNUC_INTERNAL PyGimpThumbnail_Type;
+
+#line 34 "gimpthumb.c"
+
+
+
+/* ----------- GimpThumbnail ----------- */
+
+static int
+_wrap_gimp_thumbnail_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpthumb.Thumbnail.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpthumb.Thumbnail object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_set_uri(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "uri", NULL };
+    char *uri;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Thumbnail.set_uri", kwlist, &uri))
+        return NULL;
+    
+    gimp_thumbnail_set_uri(GIMP_THUMBNAIL(self->obj), uri);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_set_filename(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "filename", NULL };
+    char *filename;
+    int ret;
+    GError *error = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Thumbnail.set_filename", kwlist, &filename))
+        return NULL;
+    
+    ret = gimp_thumbnail_set_filename(GIMP_THUMBNAIL(self->obj), filename, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_set_from_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "filename", NULL };
+    char *filename;
+    int ret;
+    GError *error = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Thumbnail.set_from_thumb", kwlist, &filename))
+        return NULL;
+    
+    ret = gimp_thumbnail_set_from_thumb(GIMP_THUMBNAIL(self->obj), filename, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_peek_image(PyGObject *self)
+{
+    gint ret;
+
+    
+    ret = gimp_thumbnail_peek_image(GIMP_THUMBNAIL(self->obj));
+    
+    return pyg_enum_from_gtype(GIMP_TYPE_THUMB_STATE, ret);
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_peek_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    gint ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.peek_thumb", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumbnail_peek_thumb(GIMP_THUMBNAIL(self->obj), size);
+    
+    return pyg_enum_from_gtype(GIMP_TYPE_THUMB_STATE, ret);
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_check_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    gint ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.check_thumb", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumbnail_check_thumb(GIMP_THUMBNAIL(self->obj), size);
+    
+    return pyg_enum_from_gtype(GIMP_TYPE_THUMB_STATE, ret);
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_load_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    GdkPixbuf *ret;
+    GError *error = NULL;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.load_thumb", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumbnail_load_thumb(GIMP_THUMBNAIL(self->obj), size, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_save_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "pixbuf", "software", NULL };
+    PyGObject *pixbuf;
+    char *software;
+    int ret;
+    GError *error = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!s:Gimp.Thumbnail.save_thumb", kwlist, &PyGdkPixbuf_Type, &pixbuf, &software))
+        return NULL;
+    
+    ret = gimp_thumbnail_save_thumb(GIMP_THUMBNAIL(self->obj), GDK_PIXBUF(pixbuf->obj), software, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_save_thumb_local(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "pixbuf", "software", NULL };
+    PyGObject *pixbuf;
+    char *software;
+    int ret;
+    GError *error = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!s:Gimp.Thumbnail.save_thumb_local", kwlist, &PyGdkPixbuf_Type, &pixbuf, &software))
+        return NULL;
+    
+    ret = gimp_thumbnail_save_thumb_local(GIMP_THUMBNAIL(self->obj), GDK_PIXBUF(pixbuf->obj), software, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_save_failure(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "software", NULL };
+    char *software;
+    int ret;
+    GError *error = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Thumbnail.save_failure", kwlist, &software))
+        return NULL;
+    
+    ret = gimp_thumbnail_save_failure(GIMP_THUMBNAIL(self->obj), software, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_delete_failure(PyGObject *self)
+{
+    
+    gimp_thumbnail_delete_failure(GIMP_THUMBNAIL(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_delete_others(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Thumbnail.delete_others", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    gimp_thumbnail_delete_others(GIMP_THUMBNAIL(self->obj), size);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumbnail_has_failed(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_thumbnail_has_failed(GIMP_THUMBNAIL(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static const PyMethodDef _PyGimpThumbnail_methods[] = {
+    { "set_uri", (PyCFunction)_wrap_gimp_thumbnail_set_uri, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_filename", (PyCFunction)_wrap_gimp_thumbnail_set_filename, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_from_thumb", (PyCFunction)_wrap_gimp_thumbnail_set_from_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "peek_image", (PyCFunction)_wrap_gimp_thumbnail_peek_image, METH_NOARGS,
+      NULL },
+    { "peek_thumb", (PyCFunction)_wrap_gimp_thumbnail_peek_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "check_thumb", (PyCFunction)_wrap_gimp_thumbnail_check_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "load_thumb", (PyCFunction)_wrap_gimp_thumbnail_load_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "save_thumb", (PyCFunction)_wrap_gimp_thumbnail_save_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "save_thumb_local", (PyCFunction)_wrap_gimp_thumbnail_save_thumb_local, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "save_failure", (PyCFunction)_wrap_gimp_thumbnail_save_failure, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "delete_failure", (PyCFunction)_wrap_gimp_thumbnail_delete_failure, METH_NOARGS,
+      NULL },
+    { "delete_others", (PyCFunction)_wrap_gimp_thumbnail_delete_others, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "has_failed", (PyCFunction)_wrap_gimp_thumbnail_has_failed, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpThumbnail_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpthumb.Thumbnail",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpThumbnail_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_thumbnail_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- functions ----------- */
+
+#line 25 "gimpthumb.override"
+static PyObject *
+_wrap_gimp_thumb_init(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *creator, *thumb_basedir = NULL;
+
+    static char *kwlist[] = { "creator", "thumb_basedir", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "s|z:init", kwlist,
+                                     &creator, &thumb_basedir))
+        return NULL;
+
+    return PyBool_FromLong(gimp_thumb_init(creator, thumb_basedir));
+}
+#line 375 "gimpthumb.c"
+
+
+#line 41 "gimpthumb.override"
+static PyObject *
+_wrap_gimp_thumb_find_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *uri, *ret;
+    PyObject *py_size, *py_ret;
+    GimpThumbSize size;
+
+    static char *kwlist[] = { "uri", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO:find_thumb", kwlist,
+                                     &uri, &py_size))
+        return NULL;
+
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gint *)&size))
+        return NULL;
+
+    ret = gimp_thumb_find_thumb(uri, &size);
+
+    if (ret == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    py_ret = Py_BuildValue("sN", ret,
+                           pyg_enum_from_gtype(GIMP_TYPE_THUMB_SIZE, size));
+    g_free(ret);
+    return py_ret;
+}
+#line 407 "gimpthumb.c"
+
+
+#line 71 "gimpthumb.override"
+static PyObject *
+_wrap_gimp_thumb_file_test(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *filename;
+    GimpThumbFileType ret;
+    gint64 mtime, size;
+    gint err_no;
+
+    static char *kwlist[] = { "filename", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:file_test", kwlist,
+                                     &filename))
+        return NULL;
+
+    ret = gimp_thumb_file_test(filename, &mtime, &size, &err_no);
+
+    if (ret == GIMP_THUMB_FILE_TYPE_NONE) {
+        PyObject *v = Py_BuildValue("iss",
+                                    err_no, g_strerror(err_no), filename); 
+        if (v != NULL) {
+            PyErr_SetObject(PyExc_IOError, v);
+            Py_DECREF(v);
+        }
+
+        return NULL;
+    }
+
+    return Py_BuildValue("NNN", 
+                         pyg_enum_from_gtype(GIMP_TYPE_THUMB_FILE_TYPE, ret),
+                         PyLong_FromLongLong(mtime),
+                         PyLong_FromLongLong(size));
+}
+#line 443 "gimpthumb.c"
+
+
+static PyObject *
+_wrap_gimp_thumb_name_from_uri(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "uri", "size", NULL };
+    char *uri;
+    PyObject *py_size = NULL;
+    gchar *ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:name_from_uri", kwlist, &uri, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_name_from_uri(uri, size);
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumb_get_thumb_dir(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    const gchar *ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:get_thumb_dir", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_get_thumb_dir(size);
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumb_ensure_thumb_dir(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "size", NULL };
+    PyObject *py_size = NULL;
+    int ret;
+    GError *error = NULL;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:ensure_thumb_dir", kwlist, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_ensure_thumb_dir(size, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbs_delete_for_uri(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "uri", NULL };
+    char *uri;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:delete_for_uri", kwlist, &uri))
+        return NULL;
+    
+    gimp_thumbs_delete_for_uri(uri);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumb_name_from_uri_local(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "uri", "size", NULL };
+    char *uri;
+    PyObject *py_size = NULL;
+    gchar *ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:name_from_uri_local", kwlist, &uri, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_name_from_uri_local(uri, size);
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumb_get_thumb_dir_local(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "dirname", "size", NULL };
+    char *dirname;
+    PyObject *py_size = NULL;
+    gchar *ret;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:get_thumb_dir_local", kwlist, &dirname, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_get_thumb_dir_local(dirname, size);
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_thumb_ensure_thumb_dir_local(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "dirname", "size", NULL };
+    char *dirname;
+    PyObject *py_size = NULL;
+    int ret;
+    GError *error = NULL;
+    GimpThumbSize size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:ensure_thumb_dir_local", kwlist, &dirname, &py_size))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size))
+        return NULL;
+    
+    ret = gimp_thumb_ensure_thumb_dir_local(dirname, size, &error);
+    
+    if (pyg_error_check(&error))
+        return NULL;
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_thumbs_delete_for_uri_local(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "uri", NULL };
+    char *uri;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:delete_for_uri_local", kwlist, &uri))
+        return NULL;
+    
+    gimp_thumbs_delete_for_uri_local(uri);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+const PyMethodDef gimpthumb_functions[] = {
+    { "init", (PyCFunction)_wrap_gimp_thumb_init, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "find_thumb", (PyCFunction)_wrap_gimp_thumb_find_thumb, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "file_test", (PyCFunction)_wrap_gimp_thumb_file_test, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "name_from_uri", (PyCFunction)_wrap_gimp_thumb_name_from_uri, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_thumb_dir", (PyCFunction)_wrap_gimp_thumb_get_thumb_dir, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "ensure_thumb_dir", (PyCFunction)_wrap_gimp_thumb_ensure_thumb_dir, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "delete_for_uri", (PyCFunction)_wrap_gimp_thumbs_delete_for_uri, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "name_from_uri_local", (PyCFunction)_wrap_gimp_thumb_name_from_uri_local, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_thumb_dir_local", (PyCFunction)_wrap_gimp_thumb_get_thumb_dir_local, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "ensure_thumb_dir_local", (PyCFunction)_wrap_gimp_thumb_ensure_thumb_dir_local, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "delete_for_uri_local", (PyCFunction)_wrap_gimp_thumbs_delete_for_uri_local, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+
+/* ----------- enums and flags ----------- */
+
+void
+gimpthumb_add_constants(PyObject *module, const gchar *strip_prefix)
+{
+#ifdef VERSION
+    PyModule_AddStringConstant(module, "__version__", VERSION);
+#endif
+  pyg_enum_add(module, "ThumbFileType", strip_prefix, GIMP_TYPE_THUMB_FILE_TYPE);
+  pyg_enum_add(module, "ThumbSize", strip_prefix, GIMP_TYPE_THUMB_SIZE);
+  pyg_enum_add(module, "ThumbState", strip_prefix, GIMP_TYPE_THUMB_STATE);
+
+  if (PyErr_Occurred())
+    PyErr_Print();
+}
+
+/* initialise stuff extension classes */
+void
+gimpthumb_register_classes(PyObject *d)
+{
+    PyObject *module;
+
+    if ((module = PyImport_ImportModule("gobject")) != NULL) {
+        _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+        if (_PyGObject_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name GObject from gobject");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gobject");
+        return ;
+    }
+    if ((module = PyImport_ImportModule("gtk.gdk")) != NULL) {
+        _PyGdkPixbuf_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Pixbuf");
+        if (_PyGdkPixbuf_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Pixbuf from gtk.gdk");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gtk.gdk");
+        return ;
+    }
+
+
+#line 692 "gimpthumb.c"
+    pygobject_register_class(d, "GimpThumbnail", GIMP_TYPE_THUMBNAIL, &PyGimpThumbnail_Type, Py_BuildValue("(O)", &PyGObject_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_THUMBNAIL);
+}
diff --git a/plug-ins/pygimp/gimpthumb.defs b/plug-ins/pygimp/gimpthumb.defs
new file mode 100644
index 0000000..35ecc7b
--- /dev/null
+++ b/plug-ins/pygimp/gimpthumb.defs
@@ -0,0 +1,312 @@
+;; -*- scheme -*-
+; object definitions ...
+(define-object Thumbnail
+  (in-module "Gimp")
+  (parent "GObject")
+  (c-name "GimpThumbnail")
+  (gtype-id "GIMP_TYPE_THUMBNAIL")
+)
+
+;; Enumerations and flags ...
+
+(define-enum ThumbFileType
+  (in-module "Gimp")
+  (c-name "GimpThumbFileType")
+  (gtype-id "GIMP_TYPE_THUMB_FILE_TYPE")
+  (values
+    '("none" "GIMP_THUMB_FILE_TYPE_NONE")
+    '("regular" "GIMP_THUMB_FILE_TYPE_REGULAR")
+    '("folder" "GIMP_THUMB_FILE_TYPE_FOLDER")
+    '("special" "GIMP_THUMB_FILE_TYPE_SPECIAL")
+  )
+)
+
+(define-enum ThumbSize
+  (in-module "Gimp")
+  (c-name "GimpThumbSize")
+  (gtype-id "GIMP_TYPE_THUMB_SIZE")
+  (values
+    '("fail" "GIMP_THUMB_SIZE_FAIL")
+    '("normal" "GIMP_THUMB_SIZE_NORMAL")
+    '("large" "GIMP_THUMB_SIZE_LARGE")
+  )
+)
+
+(define-enum ThumbState
+  (in-module "Gimp")
+  (c-name "GimpThumbState")
+  (gtype-id "GIMP_TYPE_THUMB_STATE")
+  (values
+    '("unknown" "GIMP_THUMB_STATE_UNKNOWN")
+    '("remote" "GIMP_THUMB_STATE_REMOTE")
+    '("folder" "GIMP_THUMB_STATE_FOLDER")
+    '("special" "GIMP_THUMB_STATE_SPECIAL")
+    '("not-found" "GIMP_THUMB_STATE_NOT_FOUND")
+    '("exists" "GIMP_THUMB_STATE_EXISTS")
+    '("old" "GIMP_THUMB_STATE_OLD")
+    '("failed" "GIMP_THUMB_STATE_FAILED")
+    '("ok" "GIMP_THUMB_STATE_OK")
+  )
+)
+
+
+;; From ../../libgimpthumb/gimpthumb-enums.h
+
+(define-function gimp_thumb_file_type_get_type
+  (c-name "gimp_thumb_file_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_thumb_size_get_type
+  (c-name "gimp_thumb_size_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_thumb_state_get_type
+  (c-name "gimp_thumb_state_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From ../../libgimpthumb/gimpthumb-types.h
+
+
+
+;; From ../../libgimpthumb/gimpthumb-utils.h
+
+(define-function init
+  (c-name "gimp_thumb_init")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "creator")
+    '("const-gchar*" "thumb_basedir")
+  )
+)
+
+(define-function find_thumb
+  (c-name "gimp_thumb_find_thumb")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "uri")
+    '("GimpThumbSize*" "size")
+  )
+)
+
+(define-function file_test
+  (c-name "gimp_thumb_file_test")
+  (return-type "GimpThumbFileType")
+  (parameters
+    '("const-gchar*" "filename")
+    '("gint64*" "mtime")
+    '("gint64*" "size")
+    '("gint*" "err_no")
+  )
+)
+
+(define-function name_from_uri
+  (c-name "gimp_thumb_name_from_uri")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "uri")
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-function get_thumb_dir
+  (c-name "gimp_thumb_get_thumb_dir")
+  (return-type "const-gchar*")
+  (parameters
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-function ensure_thumb_dir
+  (c-name "gimp_thumb_ensure_thumb_dir")
+  (return-type "gboolean")
+  (parameters
+    '("GimpThumbSize" "size")
+    '("GError**" "error")
+  )
+)
+
+(define-function delete_for_uri
+  (c-name "gimp_thumbs_delete_for_uri")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-function name_from_uri_local
+  (c-name "gimp_thumb_name_from_uri_local")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "uri")
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-function get_thumb_dir_local
+  (c-name "gimp_thumb_get_thumb_dir_local")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "dirname")
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-function ensure_thumb_dir_local
+  (c-name "gimp_thumb_ensure_thumb_dir_local")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "dirname")
+    '("GimpThumbSize" "size")
+    '("GError**" "error")
+  )
+)
+
+(define-function delete_for_uri_local
+  (c-name "gimp_thumbs_delete_for_uri_local")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+
+
+;; From ../../libgimpthumb/gimpthumb.h
+
+
+
+;; From ../../libgimpthumb/gimpthumbnail.h
+
+(define-function gimp_thumbnail_get_type
+  (c-name "gimp_thumbnail_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_thumbnail_new
+  (c-name "gimp_thumbnail_new")
+  (is-constructor-of "GimpThumbnail")
+  (return-type "GimpThumbnail*")
+)
+
+(define-method set_uri
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_set_uri")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-method set_filename
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_set_filename")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("GError**" "error")
+  )
+)
+
+(define-method set_from_thumb
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_set_from_thumb")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("GError**" "error")
+  )
+)
+
+(define-method peek_image
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_peek_image")
+  (return-type "GimpThumbState")
+)
+
+(define-method peek_thumb
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_peek_thumb")
+  (return-type "GimpThumbState")
+  (parameters
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-method check_thumb
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_check_thumb")
+  (return-type "GimpThumbState")
+  (parameters
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-method load_thumb
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_load_thumb")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("GimpThumbSize" "size")
+    '("GError**" "error")
+  )
+)
+
+(define-method save_thumb
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_save_thumb")
+  (return-type "gboolean")
+  (parameters
+    '("GdkPixbuf*" "pixbuf")
+    '("const-gchar*" "software")
+    '("GError**" "error")
+  )
+)
+
+(define-method save_thumb_local
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_save_thumb_local")
+  (return-type "gboolean")
+  (parameters
+    '("GdkPixbuf*" "pixbuf")
+    '("const-gchar*" "software")
+    '("GError**" "error")
+  )
+)
+
+(define-method save_failure
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_save_failure")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "software")
+    '("GError**" "error")
+  )
+)
+
+(define-method delete_failure
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_delete_failure")
+  (return-type "none")
+)
+
+(define-method delete_others
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_delete_others")
+  (return-type "none")
+  (parameters
+    '("GimpThumbSize" "size")
+  )
+)
+
+(define-method has_failed
+  (of-object "GimpThumbnail")
+  (c-name "gimp_thumbnail_has_failed")
+  (return-type "gboolean")
+)
+
+
diff --git a/plug-ins/pygimp/gimpthumb.override b/plug-ins/pygimp/gimpthumb.override
new file mode 100644
index 0000000..c43e539
--- /dev/null
+++ b/plug-ins/pygimp/gimpthumb.override
@@ -0,0 +1,102 @@
+%%
+headers
+#include <Python.h>
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include <libgimpthumb/gimpthumb.h>
+
+/* TODO: Add a header for these */
+void gimpthumb_register_classes(PyObject *d);
+void gimpthumb_add_constants(PyObject *module, const gchar *strip_prefix);
+%%
+modulename gimpthumb
+%%
+import gobject.GObject as PyGObject_Type
+import gtk.gdk.Pixbuf as PyGdkPixbuf_Type
+%%
+ignore-glob
+  *_get_type
+%%
+override gimp_thumb_init kwargs
+static PyObject *
+_wrap_gimp_thumb_init(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *creator, *thumb_basedir = NULL;
+
+    static char *kwlist[] = { "creator", "thumb_basedir", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "s|z:init", kwlist,
+                                     &creator, &thumb_basedir))
+        return NULL;
+
+    return PyBool_FromLong(gimp_thumb_init(creator, thumb_basedir));
+}
+%%
+override gimp_thumb_find_thumb kwargs
+static PyObject *
+_wrap_gimp_thumb_find_thumb(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *uri, *ret;
+    PyObject *py_size, *py_ret;
+    GimpThumbSize size;
+
+    static char *kwlist[] = { "uri", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO:find_thumb", kwlist,
+                                     &uri, &py_size))
+        return NULL;
+
+    if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gint *)&size))
+        return NULL;
+
+    ret = gimp_thumb_find_thumb(uri, &size);
+
+    if (ret == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    py_ret = Py_BuildValue("sN", ret,
+                           pyg_enum_from_gtype(GIMP_TYPE_THUMB_SIZE, size));
+    g_free(ret);
+    return py_ret;
+}
+%%
+override gimp_thumb_file_test kwargs
+static PyObject *
+_wrap_gimp_thumb_file_test(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *filename;
+    GimpThumbFileType ret;
+    gint64 mtime, size;
+    gint err_no;
+
+    static char *kwlist[] = { "filename", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:file_test", kwlist,
+                                     &filename))
+        return NULL;
+
+    ret = gimp_thumb_file_test(filename, &mtime, &size, &err_no);
+
+    if (ret == GIMP_THUMB_FILE_TYPE_NONE) {
+        PyObject *v = Py_BuildValue("iss",
+                                    err_no, g_strerror(err_no), filename); 
+        if (v != NULL) {
+            PyErr_SetObject(PyExc_IOError, v);
+            Py_DECREF(v);
+        }
+
+        return NULL;
+    }
+
+    return Py_BuildValue("NNN", 
+                         pyg_enum_from_gtype(GIMP_TYPE_THUMB_FILE_TYPE, ret),
+                         PyLong_FromLongLong(mtime),
+                         PyLong_FromLongLong(size));
+}
diff --git a/plug-ins/pygimp/gimpthumbmodule.c b/plug-ins/pygimp/gimpthumbmodule.c
new file mode 100644
index 0000000..5f87844
--- /dev/null
+++ b/plug-ins/pygimp/gimpthumbmodule.c
@@ -0,0 +1,60 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005-2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <Python.h>
+
+#include <pygobject.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include <libgimpthumb/gimpthumb.h>
+
+#include "pygimp-util.h"
+
+
+void gimpthumb_register_classes(PyObject *d);
+void gimpthumb_add_constants(PyObject *module, const gchar *strip_prefix);
+extern PyMethodDef gimpthumb_functions[];
+
+
+static char gimpthumb_doc[] =
+"This module provides interfaces to allow you to write gimp plug-ins"
+;
+
+void initgimpthumb(void);
+
+PyMODINIT_FUNC
+initgimpthumb(void)
+{
+    PyObject *m, *d;
+
+    pygimp_init_pygobject();
+
+    m = Py_InitModule3("gimpthumb", gimpthumb_functions, gimpthumb_doc);
+    d = PyModule_GetDict(m);
+
+    gimpthumb_register_classes(d);
+    gimpthumb_add_constants(m, "GIMP_THUMB_");
+
+    if (PyErr_Occurred())
+	Py_FatalError("can't initialize module gimpthumb");
+}
diff --git a/plug-ins/pygimp/gimpui.c b/plug-ins/pygimp/gimpui.c
new file mode 100644
index 0000000..26b9f50
--- /dev/null
+++ b/plug-ins/pygimp/gimpui.c
@@ -0,0 +1,9387 @@
+/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
+
+#include <Python.h>
+
+
+
+#line 2 "gimpui.override"
+#include <Python.h>
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include <pycairo.h>
+extern Pycairo_CAPI_t *Pycairo_CAPI;
+
+#define GIMP_DISABLE_DEPRECATION_WARNINGS
+#include <libgimp/gimp.h>
+#undef GIMP_DISABLE_DEPRECATED
+#include <libgimp/gimpui.h>
+#define GIMP_DISABLE_DEPRECATED
+
+#define NO_IMPORT_PYGIMP
+#include "pygimp-api.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+typedef struct {
+    PyObject *constraint;
+    PyObject *user_data;
+} PyGimpConstraintData;
+
+typedef struct {
+    PyObject *sensitivity_func;
+    PyObject *user_data;
+} PyGimpIntSensitivityData;
+
+/* TODO: Add a header for these */
+void gimpui_register_classes(PyObject *d);
+void gimpui_add_constants(PyObject *module, const gchar *strip_prefix);
+
+static void
+pygimp_decref_callback(PyObject* obj) {
+    Py_XDECREF (obj);
+}
+
+#line 48 "gimpui.c"
+
+
+/* ---------- types from other modules ---------- */
+static PyTypeObject *_PyGObject_Type;
+#define PyGObject_Type (*_PyGObject_Type)
+static PyTypeObject *_PyGdkPixbuf_Type;
+#define PyGdkPixbuf_Type (*_PyGdkPixbuf_Type)
+static PyTypeObject *_PyGtkObject_Type;
+#define PyGtkObject_Type (*_PyGtkObject_Type)
+static PyTypeObject *_PyGtkWidget_Type;
+#define PyGtkWidget_Type (*_PyGtkWidget_Type)
+static PyTypeObject *_PyGtkDialog_Type;
+#define PyGtkDialog_Type (*_PyGtkDialog_Type)
+static PyTypeObject *_PyGtkWindow_Type;
+#define PyGtkWindow_Type (*_PyGtkWindow_Type)
+static PyTypeObject *_PyGtkLabel_Type;
+#define PyGtkLabel_Type (*_PyGtkLabel_Type)
+static PyTypeObject *_PyGtkButton_Type;
+#define PyGtkButton_Type (*_PyGtkButton_Type)
+static PyTypeObject *_PyGtkToggleButton_Type;
+#define PyGtkToggleButton_Type (*_PyGtkToggleButton_Type)
+static PyTypeObject *_PyGtkRadioButton_Type;
+#define PyGtkRadioButton_Type (*_PyGtkRadioButton_Type)
+static PyTypeObject *_PyGtkSpinButton_Type;
+#define PyGtkSpinButton_Type (*_PyGtkSpinButton_Type)
+static PyTypeObject *_PyGtkEntry_Type;
+#define PyGtkEntry_Type (*_PyGtkEntry_Type)
+static PyTypeObject *_PyGtkDrawingArea_Type;
+#define PyGtkDrawingArea_Type (*_PyGtkDrawingArea_Type)
+static PyTypeObject *_PyGtkTable_Type;
+#define PyGtkTable_Type (*_PyGtkTable_Type)
+static PyTypeObject *_PyGtkFrame_Type;
+#define PyGtkFrame_Type (*_PyGtkFrame_Type)
+static PyTypeObject *_PyGtkHBox_Type;
+#define PyGtkHBox_Type (*_PyGtkHBox_Type)
+static PyTypeObject *_PyGtkVBox_Type;
+#define PyGtkVBox_Type (*_PyGtkVBox_Type)
+static PyTypeObject *_PyGtkHPaned_Type;
+#define PyGtkHPaned_Type (*_PyGtkHPaned_Type)
+static PyTypeObject *_PyGtkVPaned_Type;
+#define PyGtkVPaned_Type (*_PyGtkVPaned_Type)
+static PyTypeObject *_PyGtkScale_Type;
+#define PyGtkScale_Type (*_PyGtkScale_Type)
+static PyTypeObject *_PyGtkProgressBar_Type;
+#define PyGtkProgressBar_Type (*_PyGtkProgressBar_Type)
+static PyTypeObject *_PyGtkOptionMenu_Type;
+#define PyGtkOptionMenu_Type (*_PyGtkOptionMenu_Type)
+static PyTypeObject *_PyGtkComboBox_Type;
+#define PyGtkComboBox_Type (*_PyGtkComboBox_Type)
+static PyTypeObject *_PyGtkListStore_Type;
+#define PyGtkListStore_Type (*_PyGtkListStore_Type)
+static PyTypeObject *_PyGtkTreeModel_Type;
+#define PyGtkTreeModel_Type (*_PyGtkTreeModel_Type)
+static PyTypeObject *_PyGtkCellRenderer_Type;
+#define PyGtkCellRenderer_Type (*_PyGtkCellRenderer_Type)
+static PyTypeObject *_PyGtkCellRendererToggle_Type;
+#define PyGtkCellRendererToggle_Type (*_PyGtkCellRendererToggle_Type)
+static PyTypeObject *_PyGimpParasite_Type;
+#define PyGimpParasite_Type (*_PyGimpParasite_Type)
+
+
+/* ---------- forward type declarations ---------- */
+PyTypeObject G_GNUC_INTERNAL PyGimpBrowser_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpCellRendererColor_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpCellRendererToggle_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpChainButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorArea_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorConfig_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorDisplay_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorDisplayStack_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorHexEntry_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorProfileComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorProfileStore_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorScale_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorScales_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorSelection_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorSelector_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorNotebook_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpDialog_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumLabel_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpFrame_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpHintBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpIntComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpImageComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpDrawableComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpChannelComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpIntStore_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumStore_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpLayerComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpMemsizeEntry_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpNumberPairEntry_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpOffsetArea_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPageSelector_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPathEditor_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPickButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPreview_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpAspectPreview_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPreviewArea_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpProcBrowserDialog_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpProgressBar_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpScrolledPreview_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpDrawablePreview_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPatternSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpPaletteSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpGradientSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpFontSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpBrushSelectButton_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpRuler_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpSizeEntry_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpStringComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpUnitComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpUnitMenu_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpVectorsComboBox_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpZoomModel_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpZoomPreview_Type;
+PyTypeObject G_GNUC_INTERNAL PyGimpColorManaged_Type;
+
+#line 170 "gimpui.c"
+
+
+
+/* ----------- GimpBrowser ----------- */
+
+static int
+_wrap_gimp_browser_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.Browser.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.Browser object");
+        return -1;
+    }
+    return 0;
+}
+
+#line 1375 "gimpui.override"
+static PyObject *
+_wrap_gimp_browser_add_search_types(PyGObject *self, PyObject *args)
+{
+    GimpBrowser *browser;
+    int len, i;
+    PyObject *element;
+    gchar *label;
+    gint id;
+
+    browser = GIMP_BROWSER(self->obj);
+
+    len = PyTuple_Size(args);
+
+    for (i = 0; i < len; ++i) {
+        element = PyTuple_GetItem(args, i);
+        if (!PyTuple_Check(element)) {
+            PyErr_SetString(PyExc_TypeError, "GimpBrowser.add_search_types: Arguments must be tuples");
+            return NULL;
+        }
+        if (!PyArg_ParseTuple(element, "si",  &label, &id))
+            return NULL;
+        gimp_browser_add_search_types(browser, label, id, NULL);
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 224 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_browser_set_widget(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "widget", NULL };
+    PyGObject *widget;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.Browser.set_widget", kwlist, &PyGtkWidget_Type, &widget))
+        return NULL;
+    
+    gimp_browser_set_widget(GIMP_BROWSER(self->obj), GTK_WIDGET(widget->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_browser_show_message(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "message", NULL };
+    char *message;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Browser.show_message", kwlist, &message))
+        return NULL;
+    
+    gimp_browser_show_message(GIMP_BROWSER(self->obj), message);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpBrowser_methods[] = {
+    { "add_search_types", (PyCFunction)_wrap_gimp_browser_add_search_types, METH_VARARGS,
+      NULL },
+    { "set_widget", (PyCFunction)_wrap_gimp_browser_set_widget, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "show_message", (PyCFunction)_wrap_gimp_browser_show_message, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpBrowser_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Browser",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpBrowser_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_browser_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpButton ----------- */
+
+static int
+_wrap_gimp_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.Button.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.Button object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_button_extended_clicked(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "state", NULL };
+    PyObject *py_state = NULL;
+    GdkModifierType state;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Button.extended_clicked", kwlist, &py_state))
+        return NULL;
+    if (pyg_flags_get_value(GDK_TYPE_MODIFIER_TYPE, py_state, (gpointer)&state))
+        return NULL;
+    
+    gimp_button_extended_clicked(GIMP_BUTTON(self->obj), state);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpButton_methods[] = {
+    { "extended_clicked", (PyCFunction)_wrap_gimp_button_extended_clicked, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Button",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpCellRendererColor ----------- */
+
+static int
+_wrap_gimp_cell_renderer_color_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.CellRendererColor.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.CellRendererColor object");
+        return -1;
+    }
+    return 0;
+}
+
+PyTypeObject G_GNUC_INTERNAL PyGimpCellRendererColor_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.CellRendererColor",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_cell_renderer_color_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpCellRendererToggle ----------- */
+
+static int
+_wrap_gimp_cell_renderer_toggle_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[1];
+    PyObject *parsed_args[1] = {NULL, };
+    char *arg_names[] = {"stock_id", NULL };
+    char *prop_names[] = {"stock-id", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:gimpui.CellRendererToggle.__init__" , arg_names , &parsed_args[0]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*1);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.CellRendererToggle object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_cell_renderer_toggle_clicked(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "path", "state", NULL };
+    char *path;
+    PyObject *py_state = NULL;
+    GdkModifierType state;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:Gimp.CellRendererToggle.clicked", kwlist, &path, &py_state))
+        return NULL;
+    if (pyg_flags_get_value(GDK_TYPE_MODIFIER_TYPE, py_state, (gpointer)&state))
+        return NULL;
+    
+    gimp_cell_renderer_toggle_clicked(GIMP_CELL_RENDERER_TOGGLE(self->obj), path, state);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpCellRendererToggle_methods[] = {
+    { "clicked", (PyCFunction)_wrap_gimp_cell_renderer_toggle_clicked, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpCellRendererToggle_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.CellRendererToggle",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpCellRendererToggle_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_cell_renderer_toggle_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpChainButton ----------- */
+
+ static int
+_wrap_gimp_chain_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[1];
+    PyObject *parsed_args[1] = {NULL, };
+    char *arg_names[] = {"position", NULL };
+    char *prop_names[] = {"position", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:gimpui.ChainButton.__init__" , arg_names , &parsed_args[0]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*1);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ChainButton object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_chain_button_set_active(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "active", NULL };
+    int active;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ChainButton.set_active", kwlist, &active))
+        return NULL;
+    
+    gimp_chain_button_set_active(GIMP_CHAIN_BUTTON(self->obj), active);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_chain_button_get_active(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_chain_button_get_active(GIMP_CHAIN_BUTTON(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static const PyMethodDef _PyGimpChainButton_methods[] = {
+    { "set_active", (PyCFunction)_wrap_gimp_chain_button_set_active, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active", (PyCFunction)_wrap_gimp_chain_button_get_active, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpChainButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ChainButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpChainButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_chain_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorArea ----------- */
+
+ static int
+_wrap_gimp_color_area_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[3];
+    PyObject *parsed_args[3] = {NULL, };
+    char *arg_names[] = {"color", "type", "drag_mask", NULL };
+    char *prop_names[] = {"color", "type", "drag-mask", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:gimpui.ColorArea.__init__" , arg_names , &parsed_args[0] , &parsed_args[1] , &parsed_args[2]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*3);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorArea object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_area_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "color", NULL };
+    PyObject *py_color;
+    GimpRGB *color = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorArea.set_color", kwlist, &py_color))
+        return NULL;
+    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB");
+        return NULL;
+    }
+    
+    gimp_color_area_set_color(GIMP_COLOR_AREA(self->obj), color);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1792 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_area_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_area_get_color(GIMP_COLOR_AREA(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+#line 758 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_area_has_alpha(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_color_area_has_alpha(GIMP_COLOR_AREA(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_color_area_set_type(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "type", NULL };
+    PyObject *py_type = NULL;
+    GimpColorAreaType type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorArea.set_type", kwlist, &py_type))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type, (gpointer)&type))
+        return NULL;
+    
+    gimp_color_area_set_type(GIMP_COLOR_AREA(self->obj), type);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_area_set_draw_border(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "draw_border", NULL };
+    int draw_border;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorArea.set_draw_border", kwlist, &draw_border))
+        return NULL;
+    
+    gimp_color_area_set_draw_border(GIMP_COLOR_AREA(self->obj), draw_border);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorArea_methods[] = {
+    { "set_color", (PyCFunction)_wrap_gimp_color_area_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_color", (PyCFunction)_wrap_gimp_color_area_get_color, METH_NOARGS,
+      NULL },
+    { "has_alpha", (PyCFunction)_wrap_gimp_color_area_has_alpha, METH_NOARGS,
+      NULL },
+    { "set_type", (PyCFunction)_wrap_gimp_color_area_set_type, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_draw_border", (PyCFunction)_wrap_gimp_color_area_set_draw_border, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorArea_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorArea",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorArea_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_area_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorButton ----------- */
+
+#line 941 "gimpui.override"
+static int
+_wrap_gimp_color_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *title = NULL;
+    gint width = -1, height = -1;
+    PyObject *py_color = NULL, *py_type = NULL;
+    GimpRGB *color, default_color = { 0.0, 0.0, 0.0, 100.0 };
+    GimpColorAreaType type;
+    
+    static char *kwlist[] = { "title", "width", "height", "color", "type",
+                              NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|ziiOO:gimpui.ColorButton.__init__",
+                                     kwlist,
+                                     &title, &width, &height,
+                                     &py_color, &py_type))
+        return -1;
+
+    if (py_color == NULL || (PyObject*)py_color == Py_None)
+        color = &default_color;
+    else if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB or None");
+        return -1;
+    }
+
+    if (py_type == NULL || (PyObject*)py_type == Py_None)
+       type = GIMP_COLOR_AREA_FLAT;
+    else if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type,
+                                (gint*)&type))
+       return -1;
+
+    if (pygobject_construct(self,
+                            "title",       title,
+                            "type",        type,
+                            "color",       color,
+                            "area-width",  width,
+			    "area-height", height,
+                            NULL))
+        return -1;
+
+    return 0;
+}
+#line 915 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_button_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "color", NULL };
+    PyObject *py_color;
+    GimpRGB *color = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorButton.set_color", kwlist, &py_color))
+        return NULL;
+    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB");
+        return NULL;
+    }
+    
+    gimp_color_button_set_color(GIMP_COLOR_BUTTON(self->obj), color);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 903 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_button_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_button_get_color(GIMP_COLOR_BUTTON(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+#line 950 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_button_has_alpha(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_color_button_has_alpha(GIMP_COLOR_BUTTON(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_color_button_set_type(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "type", NULL };
+    PyObject *py_type = NULL;
+    GimpColorAreaType type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorButton.set_type", kwlist, &py_type))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type, (gpointer)&type))
+        return NULL;
+    
+    gimp_color_button_set_type(GIMP_COLOR_BUTTON(self->obj), type);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_button_get_update(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_color_button_get_update(GIMP_COLOR_BUTTON(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_color_button_set_update(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "continuous", NULL };
+    int continuous;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorButton.set_update", kwlist, &continuous))
+        return NULL;
+    
+    gimp_color_button_set_update(GIMP_COLOR_BUTTON(self->obj), continuous);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorButton_methods[] = {
+    { "set_color", (PyCFunction)_wrap_gimp_color_button_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_color", (PyCFunction)_wrap_gimp_color_button_get_color, METH_NOARGS,
+      NULL },
+    { "has_alpha", (PyCFunction)_wrap_gimp_color_button_has_alpha, METH_NOARGS,
+      NULL },
+    { "set_type", (PyCFunction)_wrap_gimp_color_button_set_type, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_update", (PyCFunction)_wrap_gimp_color_button_get_update, METH_NOARGS,
+      NULL },
+    { "set_update", (PyCFunction)_wrap_gimp_color_button_set_update, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorConfig ----------- */
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorConfig_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorConfig",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorDisplay ----------- */
+
+static PyObject *
+_wrap_gimp_color_display_clone(PyGObject *self)
+{
+    GimpColorDisplay *ret;
+
+    
+    ret = gimp_color_display_clone(GIMP_COLOR_DISPLAY(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+#line 1996 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_display_convert_surface(PyGObject *self, PyObject *args,
+                                         PyObject *kwargs)
+{
+  PycairoSurface *pysurface;
+
+  static char *kwlist[] = { "surface", NULL };
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                   "O!:GimpColorDisplay.convert_surface",
+                                   kwlist,
+                                   &PycairoSurface_Type, &pysurface))
+    return NULL;
+
+  gimp_color_display_convert_surface(GIMP_COLOR_DISPLAY(self->obj),
+                                     pysurface->surface);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+#line 1157 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_display_convert(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "buf", "width", "height", "bpp", "bpl", NULL };
+    int buf_len, width, height, bpp, bpl;
+    guchar *buf;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:Gimp.ColorDisplay.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
+        return NULL;
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use convert_surface(cairo_surface_t*) instead") < 0)
+        return NULL;
+    
+    gimp_color_display_convert(GIMP_COLOR_DISPLAY(self->obj), buf, width, height, bpp, bpl);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_load_state(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "state", NULL };
+    GimpParasite *state = NULL;
+    PyObject *py_state;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorDisplay.load_state", kwlist, &py_state))
+        return NULL;
+    if (pyg_boxed_check(py_state, GIMP_TYPE_PARASITE))
+        state = pyg_boxed_get(py_state, GimpParasite);
+    else {
+        PyErr_SetString(PyExc_TypeError, "state should be a GimpParasite");
+        return NULL;
+    }
+    
+    gimp_color_display_load_state(GIMP_COLOR_DISPLAY(self->obj), state);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_save_state(PyGObject *self)
+{
+    GimpParasite *ret;
+
+    
+    ret = gimp_color_display_save_state(GIMP_COLOR_DISPLAY(self->obj));
+    
+    /* pyg_boxed_new handles NULL checking */
+    return pyg_boxed_new(GIMP_TYPE_PARASITE, ret, TRUE, TRUE);
+}
+
+static PyObject *
+_wrap_gimp_color_display_configure(PyGObject *self)
+{
+    GtkWidget *ret;
+
+    
+    ret = gimp_color_display_configure(GIMP_COLOR_DISPLAY(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_color_display_configure_reset(PyGObject *self)
+{
+    
+    gimp_color_display_configure_reset(GIMP_COLOR_DISPLAY(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_changed(PyGObject *self)
+{
+    
+    gimp_color_display_changed(GIMP_COLOR_DISPLAY(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_set_enabled(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enabled", NULL };
+    int enabled;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorDisplay.set_enabled", kwlist, &enabled))
+        return NULL;
+    
+    gimp_color_display_set_enabled(GIMP_COLOR_DISPLAY(self->obj), enabled);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_get_enabled(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_color_display_get_enabled(GIMP_COLOR_DISPLAY(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_color_display_get_config(PyGObject *self)
+{
+    GimpColorConfig *ret;
+
+    
+    ret = gimp_color_display_get_config(GIMP_COLOR_DISPLAY(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_color_display_get_managed(PyGObject *self)
+{
+    GimpColorManaged *ret;
+
+    
+    ret = gimp_color_display_get_managed(GIMP_COLOR_DISPLAY(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static const PyMethodDef _PyGimpColorDisplay_methods[] = {
+    { "clone", (PyCFunction)_wrap_gimp_color_display_clone, METH_NOARGS,
+      NULL },
+    { "convert_surface", (PyCFunction)_wrap_gimp_color_display_convert_surface, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "convert", (PyCFunction)_wrap_gimp_color_display_convert, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "load_state", (PyCFunction)_wrap_gimp_color_display_load_state, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "save_state", (PyCFunction)_wrap_gimp_color_display_save_state, METH_NOARGS,
+      NULL },
+    { "configure", (PyCFunction)_wrap_gimp_color_display_configure, METH_NOARGS,
+      NULL },
+    { "configure_reset", (PyCFunction)_wrap_gimp_color_display_configure_reset, METH_NOARGS,
+      NULL },
+    { "changed", (PyCFunction)_wrap_gimp_color_display_changed, METH_NOARGS,
+      NULL },
+    { "set_enabled", (PyCFunction)_wrap_gimp_color_display_set_enabled, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_enabled", (PyCFunction)_wrap_gimp_color_display_get_enabled, METH_NOARGS,
+      NULL },
+    { "get_config", (PyCFunction)_wrap_gimp_color_display_get_config, METH_NOARGS,
+      NULL },
+    { "get_managed", (PyCFunction)_wrap_gimp_color_display_get_managed, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorDisplay_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorDisplay",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorDisplay_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorDisplayStack ----------- */
+
+ static int
+_wrap_gimp_color_display_stack_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.ColorDisplayStack.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorDisplayStack object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_clone(PyGObject *self)
+{
+    GimpColorDisplayStack *ret;
+
+    
+    ret = gimp_color_display_stack_clone(GIMP_COLOR_DISPLAY_STACK(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_changed(PyGObject *self)
+{
+    
+    gimp_color_display_stack_changed(GIMP_COLOR_DISPLAY_STACK(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_add(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "display", NULL };
+    PyGObject *display;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.add", kwlist, &PyGimpColorDisplay_Type, &display))
+        return NULL;
+    
+    gimp_color_display_stack_add(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_remove(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "display", NULL };
+    PyGObject *display;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.remove", kwlist, &PyGimpColorDisplay_Type, &display))
+        return NULL;
+    
+    gimp_color_display_stack_remove(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_reorder_up(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "display", NULL };
+    PyGObject *display;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.reorder_up", kwlist, &PyGimpColorDisplay_Type, &display))
+        return NULL;
+    
+    gimp_color_display_stack_reorder_up(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_display_stack_reorder_down(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "display", NULL };
+    PyGObject *display;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.reorder_down", kwlist, &PyGimpColorDisplay_Type, &display))
+        return NULL;
+    
+    gimp_color_display_stack_reorder_down(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 2018 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_display_stack_convert_surface(PyGObject *self, PyObject *args,
+                                               PyObject *kwargs)
+{
+  PycairoSurface *pysurface;
+
+  static char *kwlist[] = { "surface", NULL };
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                   "O!:GimpColorDisplayStack.convert_surface",
+                                   kwlist,
+                                   &PycairoSurface_Type, &pysurface))
+    return NULL;
+
+  gimp_color_display_stack_convert_surface(GIMP_COLOR_DISPLAY_STACK(self->obj),
+                                           pysurface->surface);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+#line 1495 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_display_stack_convert(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "buf", "width", "height", "bpp", "bpl", NULL };
+    int buf_len, width, height, bpp, bpl;
+    guchar *buf;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:Gimp.ColorDisplayStack.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
+        return NULL;
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use convert_surface(cairo_surface_t*) instead") < 0)
+        return NULL;
+    
+    gimp_color_display_stack_convert(GIMP_COLOR_DISPLAY_STACK(self->obj), buf, width, height, bpp, bpl);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorDisplayStack_methods[] = {
+    { "clone", (PyCFunction)_wrap_gimp_color_display_stack_clone, METH_NOARGS,
+      NULL },
+    { "changed", (PyCFunction)_wrap_gimp_color_display_stack_changed, METH_NOARGS,
+      NULL },
+    { "add", (PyCFunction)_wrap_gimp_color_display_stack_add, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "remove", (PyCFunction)_wrap_gimp_color_display_stack_remove, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "reorder_up", (PyCFunction)_wrap_gimp_color_display_stack_reorder_up, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "reorder_down", (PyCFunction)_wrap_gimp_color_display_stack_reorder_down, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "convert_surface", (PyCFunction)_wrap_gimp_color_display_stack_convert_surface, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "convert", (PyCFunction)_wrap_gimp_color_display_stack_convert, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorDisplayStack_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorDisplayStack",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorDisplayStack_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_display_stack_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorHexEntry ----------- */
+
+static int
+_wrap_gimp_color_hex_entry_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.ColorHexEntry.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorHexEntry object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_hex_entry_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "color", NULL };
+    PyObject *py_color;
+    GimpRGB *color = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorHexEntry.set_color", kwlist, &py_color))
+        return NULL;
+    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB");
+        return NULL;
+    }
+    
+    gimp_color_hex_entry_set_color(GIMP_COLOR_HEX_ENTRY(self->obj), color);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1803 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_hex_entry_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_hex_entry_get_color(GIMP_COLOR_HEX_ENTRY(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+#line 1637 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpColorHexEntry_methods[] = {
+    { "set_color", (PyCFunction)_wrap_gimp_color_hex_entry_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_color", (PyCFunction)_wrap_gimp_color_hex_entry_get_color, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorHexEntry_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorHexEntry",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorHexEntry_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_hex_entry_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorProfileComboBox ----------- */
+
+static int
+_wrap_gimp_color_profile_combo_box_new_with_model(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"dialog", "model", NULL };
+    char *prop_names[] = {"dialog", "model", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:gimpui.ColorProfileComboBox.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorProfileComboBox object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_profile_combo_box_add(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "filename", "label", NULL };
+    char *filename, *label;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileComboBox.add", kwlist, &filename, &label))
+        return NULL;
+    
+    gimp_color_profile_combo_box_add(GIMP_COLOR_PROFILE_COMBO_BOX(self->obj), filename, label);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_profile_combo_box_set_active(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "filename", "label", NULL };
+    char *filename, *label;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileComboBox.set_active", kwlist, &filename, &label))
+        return NULL;
+    
+    gimp_color_profile_combo_box_set_active(GIMP_COLOR_PROFILE_COMBO_BOX(self->obj), filename, label);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_profile_combo_box_get_active(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_color_profile_combo_box_get_active(GIMP_COLOR_PROFILE_COMBO_BOX(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorProfileComboBox_methods[] = {
+    { "add", (PyCFunction)_wrap_gimp_color_profile_combo_box_add, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_active", (PyCFunction)_wrap_gimp_color_profile_combo_box_set_active, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active", (PyCFunction)_wrap_gimp_color_profile_combo_box_get_active, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorProfileComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorProfileComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorProfileComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_profile_combo_box_new_with_model,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorProfileStore ----------- */
+
+ static int
+_wrap_gimp_color_profile_store_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[1];
+    PyObject *parsed_args[1] = {NULL, };
+    char *arg_names[] = {"history", NULL };
+    char *prop_names[] = {"history", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:gimpui.ColorProfileStore.__init__" , arg_names , &parsed_args[0]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*1);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorProfileStore object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_profile_store_add(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "filename", "label", NULL };
+    char *filename, *label;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileStore.add", kwlist, &filename, &label))
+        return NULL;
+    
+    gimp_color_profile_store_add(GIMP_COLOR_PROFILE_STORE(self->obj), filename, label);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorProfileStore_methods[] = {
+    { "add", (PyCFunction)_wrap_gimp_color_profile_store_add, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorProfileStore_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorProfileStore",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorProfileStore_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_profile_store_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorScale ----------- */
+
+#line 990 "gimpui.override"
+static int
+_wrap_gimp_color_scale_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_orientation, *py_channel;
+    GtkOrientation orientation;
+    GimpColorSelectorChannel channel;
+
+    static char *kwlist[] = { "orientation", "channel", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "OO:gimpui.ColorScale.__init__",
+                                     kwlist,
+                                     &py_orientation, &py_channel))
+        return -1;
+
+    if (pyg_enum_get_value(GTK_TYPE_ORIENTATION, py_orientation,
+                           (gint*)&orientation))
+        return -1;
+
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, 
+                           (gint*)&channel))
+        return -1;
+
+    if (pygobject_construct(self,
+                            "orientation", orientation,
+                            "channel",     channel,
+                            NULL))
+        return -1;
+
+    gtk_range_set_flippable (GTK_RANGE (self->obj),
+                             orientation == GTK_ORIENTATION_HORIZONTAL);
+    
+    return 0;
+}
+#line 1968 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_scale_set_channel(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "channel", NULL };
+    GimpColorSelectorChannel channel;
+    PyObject *py_channel = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorScale.set_channel", kwlist, &py_channel))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, (gpointer)&channel))
+        return NULL;
+    
+    gimp_color_scale_set_channel(GIMP_COLOR_SCALE(self->obj), channel);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_scale_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "rgb", "hsv", NULL };
+    PyObject *py_rgb, *py_hsv;
+    GimpHSV *hsv = NULL;
+    GimpRGB *rgb = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ColorScale.set_color", kwlist, &py_rgb, &py_hsv))
+        return NULL;
+    if (pyg_boxed_check(py_rgb, GIMP_TYPE_RGB))
+        rgb = pyg_boxed_get(py_rgb, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "rgb should be a GimpRGB");
+        return NULL;
+    }
+    if (pyg_boxed_check(py_hsv, GIMP_TYPE_HSV))
+        hsv = pyg_boxed_get(py_hsv, GimpHSV);
+    else {
+        PyErr_SetString(PyExc_TypeError, "hsv should be a GimpHSV");
+        return NULL;
+    }
+    
+    gimp_color_scale_set_color(GIMP_COLOR_SCALE(self->obj), rgb, hsv);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorScale_methods[] = {
+    { "set_channel", (PyCFunction)_wrap_gimp_color_scale_set_channel, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_color", (PyCFunction)_wrap_gimp_color_scale_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorScale_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorScale",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorScale_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_scale_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorSelector ----------- */
+
+static int
+_wrap_gimp_color_selector_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "selector_type", "rgb", "hsv", "channel", NULL };
+    PyObject *py_selector_type = NULL, *py_rgb, *py_hsv, *py_channel = NULL;
+    GimpHSV *hsv = NULL;
+    GType selector_type;
+    GimpColorSelectorChannel channel;
+    GimpRGB *rgb = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OOOO:Gimp.ColorSelector.__init__", kwlist, &py_selector_type, &py_rgb, &py_hsv, &py_channel))
+        return -1;
+    if ((selector_type = pyg_type_from_object(py_selector_type)) == 0)
+        return -1;
+    if (pyg_boxed_check(py_rgb, GIMP_TYPE_RGB))
+        rgb = pyg_boxed_get(py_rgb, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "rgb should be a GimpRGB");
+        return -1;
+    }
+    if (pyg_boxed_check(py_hsv, GIMP_TYPE_HSV))
+        hsv = pyg_boxed_get(py_hsv, GimpHSV);
+    else {
+        PyErr_SetString(PyExc_TypeError, "hsv should be a GimpHSV");
+        return -1;
+    }
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, (gpointer)&channel))
+        return -1;
+    self->obj = (GObject *)gimp_color_selector_new(selector_type, rgb, hsv, channel);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpColorSelector object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_toggles_visible(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "visible", NULL };
+    int visible;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_toggles_visible", kwlist, &visible))
+        return NULL;
+    
+    gimp_color_selector_set_toggles_visible(GIMP_COLOR_SELECTOR(self->obj), visible);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_toggles_sensitive(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "sensitive", NULL };
+    int sensitive;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_toggles_sensitive", kwlist, &sensitive))
+        return NULL;
+    
+    gimp_color_selector_set_toggles_sensitive(GIMP_COLOR_SELECTOR(self->obj), sensitive);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_show_alpha(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "show_alpha", NULL };
+    int show_alpha;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_show_alpha", kwlist, &show_alpha))
+        return NULL;
+    
+    gimp_color_selector_set_show_alpha(GIMP_COLOR_SELECTOR(self->obj), show_alpha);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "rgb", "hsv", NULL };
+    PyObject *py_rgb, *py_hsv;
+    GimpHSV *hsv = NULL;
+    GimpRGB *rgb = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ColorSelector.set_color", kwlist, &py_rgb, &py_hsv))
+        return NULL;
+    if (pyg_boxed_check(py_rgb, GIMP_TYPE_RGB))
+        rgb = pyg_boxed_get(py_rgb, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "rgb should be a GimpRGB");
+        return NULL;
+    }
+    if (pyg_boxed_check(py_hsv, GIMP_TYPE_HSV))
+        hsv = pyg_boxed_get(py_hsv, GimpHSV);
+    else {
+        PyErr_SetString(PyExc_TypeError, "hsv should be a GimpHSV");
+        return NULL;
+    }
+    
+    gimp_color_selector_set_color(GIMP_COLOR_SELECTOR(self->obj), rgb, hsv);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_channel(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "channel", NULL };
+    GimpColorSelectorChannel channel;
+    PyObject *py_channel = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelector.set_channel", kwlist, &py_channel))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, (gpointer)&channel))
+        return NULL;
+    
+    gimp_color_selector_set_channel(GIMP_COLOR_SELECTOR(self->obj), channel);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_color_changed(PyGObject *self)
+{
+    
+    gimp_color_selector_color_changed(GIMP_COLOR_SELECTOR(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_channel_changed(PyGObject *self)
+{
+    
+    gimp_color_selector_channel_changed(GIMP_COLOR_SELECTOR(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selector_set_config(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "config", NULL };
+    PyGObject *config;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorSelector.set_config", kwlist, &PyGimpColorConfig_Type, &config))
+        return NULL;
+    
+    gimp_color_selector_set_config(GIMP_COLOR_SELECTOR(self->obj), GIMP_COLOR_CONFIG(config->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorSelector_methods[] = {
+    { "set_toggles_visible", (PyCFunction)_wrap_gimp_color_selector_set_toggles_visible, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_toggles_sensitive", (PyCFunction)_wrap_gimp_color_selector_set_toggles_sensitive, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_show_alpha", (PyCFunction)_wrap_gimp_color_selector_set_show_alpha, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_color", (PyCFunction)_wrap_gimp_color_selector_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_channel", (PyCFunction)_wrap_gimp_color_selector_set_channel, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "color_changed", (PyCFunction)_wrap_gimp_color_selector_color_changed, METH_NOARGS,
+      NULL },
+    { "channel_changed", (PyCFunction)_wrap_gimp_color_selector_channel_changed, METH_NOARGS,
+      NULL },
+    { "set_config", (PyCFunction)_wrap_gimp_color_selector_set_config, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorSelector_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorSelector",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorSelector_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_selector_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorScales ----------- */
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorScales_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorScales",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorSelection ----------- */
+
+ static int
+_wrap_gimp_color_selection_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.ColorSelection.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ColorSelection object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_color_selection_set_show_alpha(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "show_alpha", NULL };
+    int show_alpha;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelection.set_show_alpha", kwlist, &show_alpha))
+        return NULL;
+    
+    gimp_color_selection_set_show_alpha(GIMP_COLOR_SELECTION(self->obj), show_alpha);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selection_get_show_alpha(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_color_selection_get_show_alpha(GIMP_COLOR_SELECTION(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_color_selection_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "color", NULL };
+    PyObject *py_color;
+    GimpRGB *color = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelection.set_color", kwlist, &py_color))
+        return NULL;
+    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB");
+        return NULL;
+    }
+    
+    gimp_color_selection_set_color(GIMP_COLOR_SELECTION(self->obj), color);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1825 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_selection_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_selection_get_color(GIMP_COLOR_SELECTION(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+#line 2437 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_selection_set_old_color(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "color", NULL };
+    PyObject *py_color;
+    GimpRGB *color = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelection.set_old_color", kwlist, &py_color))
+        return NULL;
+    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB");
+        return NULL;
+    }
+    
+    gimp_color_selection_set_old_color(GIMP_COLOR_SELECTION(self->obj), color);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1836 "gimpui.override"
+static PyObject *
+_wrap_gimp_color_selection_get_old_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_selection_get_old_color(GIMP_COLOR_SELECTION(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+#line 2472 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_color_selection_reset(PyGObject *self)
+{
+    
+    gimp_color_selection_reset(GIMP_COLOR_SELECTION(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selection_color_changed(PyGObject *self)
+{
+    
+    gimp_color_selection_color_changed(GIMP_COLOR_SELECTION(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_color_selection_set_config(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "config", NULL };
+    PyGObject *config;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorSelection.set_config", kwlist, &PyGimpColorConfig_Type, &config))
+        return NULL;
+    
+    gimp_color_selection_set_config(GIMP_COLOR_SELECTION(self->obj), GIMP_COLOR_CONFIG(config->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpColorSelection_methods[] = {
+    { "set_show_alpha", (PyCFunction)_wrap_gimp_color_selection_set_show_alpha, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_show_alpha", (PyCFunction)_wrap_gimp_color_selection_get_show_alpha, METH_NOARGS,
+      NULL },
+    { "set_color", (PyCFunction)_wrap_gimp_color_selection_set_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_color", (PyCFunction)_wrap_gimp_color_selection_get_color, METH_NOARGS,
+      NULL },
+    { "set_old_color", (PyCFunction)_wrap_gimp_color_selection_set_old_color, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_old_color", (PyCFunction)_wrap_gimp_color_selection_get_old_color, METH_NOARGS,
+      NULL },
+    { "reset", (PyCFunction)_wrap_gimp_color_selection_reset, METH_NOARGS,
+      NULL },
+    { "color_changed", (PyCFunction)_wrap_gimp_color_selection_color_changed, METH_NOARGS,
+      NULL },
+    { "set_config", (PyCFunction)_wrap_gimp_color_selection_set_config, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorSelection_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorSelection",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorSelection_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_color_selection_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorNotebook ----------- */
+
+static PyObject *
+_wrap_gimp_color_notebook_set_has_page(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_type", "has_page", NULL };
+    PyObject *py_page_type = NULL;
+    int has_page;
+    GType page_type;
+    GtkWidget *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oi:Gimp.ColorNotebook.set_has_page", kwlist, &py_page_type, &has_page))
+        return NULL;
+    if ((page_type = pyg_type_from_object(py_page_type)) == 0)
+        return NULL;
+    
+    ret = gimp_color_notebook_set_has_page(GIMP_COLOR_NOTEBOOK(self->obj), page_type, has_page);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static const PyMethodDef _PyGimpColorNotebook_methods[] = {
+    { "set_has_page", (PyCFunction)_wrap_gimp_color_notebook_set_has_page, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorNotebook_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorNotebook",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpColorNotebook_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpDialog ----------- */
+
+#line 730 "gimpui.override"
+static void
+pygimp_help_func_marshal(const gchar *help_id, gpointer help_data)
+{
+    GObject *dialog = help_data;
+    PyObject *py_dialog, *help_func, *ret;
+
+    py_dialog = g_object_get_data(dialog, "pygimp-dialog-pyobject");
+    help_func = g_object_get_data(dialog, "pygimp-dialog-help_func");
+
+    ret = PyObject_CallFunction(help_func, "sO", help_id, py_dialog);
+
+    if (ret)
+        Py_DECREF(ret);
+    else
+        PyErr_Print();
+}
+
+static void
+pygimp_help_func_destroy(gpointer data)
+{
+    PyObject *help_func = data;
+
+    Py_DECREF(help_func);
+}
+
+static void
+pygimp_dialog_close(GtkWidget *widget)
+{
+    /* Synthesize delete_event to close dialog. */
+
+    if (gtk_widget_get_window (widget)) {
+        GdkEvent *event = gdk_event_new(GDK_DELETE);
+
+        event->any.window     = g_object_ref (gtk_widget_get_window (widget));
+        event->any.send_event = TRUE;
+
+        gtk_main_do_event(event);
+        gdk_event_free(event);
+    }
+}
+
+static int
+_wrap_gimp_dialog_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *title, *role;
+    PyGObject *py_window = NULL;
+    PyObject *py_flags = NULL, *py_buttons = Py_None;
+    PyObject *help_func = NULL;
+    gchar *help_id = NULL;
+    GtkDialogFlags flags = 0;
+    int len, i;
+    GtkWidget *parent;
+    GimpHelpFunc func;
+
+    static char *kwlist[] = { "title", "role", "parent", "flags",
+                              "help_func", "help_id", "buttons", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "zz|OOOzO:gimpui.GimpDialog.__init__",
+                                     kwlist,
+                                     &title, &role, &py_window, &py_flags,
+                                     &help_func, &help_id, &py_buttons))
+        return -1;
+
+    if (py_window == NULL || (PyObject*)py_window == Py_None)
+        parent = NULL;
+    else if (pygobject_check(py_window, &PyGtkWindow_Type))
+        parent = GTK_WIDGET(py_window->obj);
+    else {
+        PyErr_SetString(PyExc_TypeError, "parent must be a GtkWindow or None");
+        return -1;
+    }
+
+    if (pyg_flags_get_value(GTK_TYPE_DIALOG_FLAGS, py_flags, (gint *)&flags))
+        return -1;
+
+    if (py_buttons == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_buttons))
+        len = PyTuple_Size(py_buttons);
+    else {
+        PyErr_SetString(PyExc_TypeError, "buttons must be a tuple containing text/response pairs or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "buttons tuple must contain text/response id pairs");
+        return -1;
+    }
+
+    if (help_func) {
+        if (help_func != Py_None) {
+            if (!PyCallable_Check(help_func)) {
+                PyErr_SetString(PyExc_TypeError, "help_func must be callable");
+                return -1;
+            }
+
+            func = pygimp_help_func_marshal;
+
+       } else {
+            func = gimp_standard_help_func;
+        }
+    } else {
+        func = gimp_standard_help_func;
+    }
+
+    pygobject_construct(self,
+                        "title",     title,
+                        "role",      role,
+                        "modal",     (flags & GTK_DIALOG_MODAL),
+                        "help-func", func,
+                        "help-id",   help_id,
+                        NULL);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpDialog object");
+        return -1;
+    }
+
+   if (parent) {
+        if (GTK_IS_WINDOW(parent))
+            gtk_window_set_transient_for(GTK_WINDOW(self->obj),
+                                         GTK_WINDOW(parent));
+        else
+            gtk_window_set_screen(GTK_WINDOW(self->obj),
+                                  gtk_widget_get_screen(parent));
+
+        if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
+            g_signal_connect_object(parent, "destroy",
+                                    G_CALLBACK(pygimp_dialog_close),
+                                    self->obj, G_CONNECT_SWAPPED);
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *text = PyTuple_GetItem(py_buttons, i);
+        PyObject *id = PyTuple_GetItem(py_buttons, i + 1);
+        if (!PyString_Check(text) && !PyUnicode_Check(text)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each text/response id pair "
+                            "must be a string");
+            return -1;
+        }
+        if (!PyInt_Check(id)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each text/response id pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_dialog_add_button(GIMP_DIALOG(self->obj), PyString_AsString(text),
+                               PyInt_AsLong(id));
+    }
+
+    if (help_func && help_func != Py_None) {
+        g_object_set_data(self->obj, "pygimp-dialog-help-data", self);
+
+        Py_INCREF(help_func);
+        g_object_set_data_full(self->obj, "pygimp-dialog-help-func",
+                               help_func, pygimp_help_func_destroy);
+    }
+
+    return 0;
+}
+#line 2826 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_dialog_add_button(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "button_text", "response_id", NULL };
+    char *button_text;
+    int response_id;
+    GtkWidget *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:Gimp.Dialog.add_button", kwlist, &button_text, &response_id))
+        return NULL;
+    
+    ret = gimp_dialog_add_button(GIMP_DIALOG(self->obj), button_text, response_id);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_dialog_run(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_dialog_run(GIMP_DIALOG(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+#line 932 "gimpui.override"
+static PyObject *
+_wrap_gimp_window_set_transient(PyGObject *self)
+{
+    gimp_window_set_transient(GTK_WINDOW(self->obj));
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 2865 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpDialog_methods[] = {
+    { "add_button", (PyCFunction)_wrap_gimp_dialog_add_button, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "run", (PyCFunction)_wrap_gimp_dialog_run, METH_NOARGS,
+      NULL },
+    { "set_transient", (PyCFunction)_wrap_gimp_window_set_transient, METH_VARARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpDialog_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Dialog",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpDialog_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_dialog_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpEnumLabel ----------- */
+
+#line 1028 "gimpui.override"
+static int
+_wrap_gimp_enum_label_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_enum_type = NULL;
+    GType enum_type;
+    gint value;
+
+    static char *kwlist[] = { "enum_type", "value", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "Oi:gimpui.GimpEnumLabel.__init__",
+                                     kwlist,
+                                     &py_enum_type, &value))
+        return -1;
+
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return -1;
+
+    if (pygobject_construct(self,
+                            "enum-type",  enum_type,
+                            "enum-value", value,
+                            NULL))
+        return -1;
+
+    return 0; 
+}
+#line 2954 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_enum_label_set_value(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", NULL };
+    int value;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.EnumLabel.set_value", kwlist, &value))
+        return NULL;
+    
+    gimp_enum_label_set_value(GIMP_ENUM_LABEL(self->obj), value);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpEnumLabel_methods[] = {
+    { "set_value", (PyCFunction)_wrap_gimp_enum_label_set_value, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumLabel_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.EnumLabel",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpEnumLabel_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_enum_label_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpFrame ----------- */
+
+static int
+_wrap_gimp_frame_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[1];
+    PyObject *parsed_args[1] = {NULL, };
+    char *arg_names[] = {"label", NULL };
+    char *prop_names[] = {"label", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:gimpui.Frame.__init__" , arg_names , &parsed_args[0]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*1);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.Frame object");
+        return -1;
+    }
+    return 0;
+}
+
+PyTypeObject G_GNUC_INTERNAL PyGimpFrame_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Frame",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_frame_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpHintBox ----------- */
+
+ static int
+_wrap_gimp_hint_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"hint", "stock-id", NULL };
+    char *prop_names[] = {"hint", "stock-id", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:gimpui.HintBox.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.HintBox object");
+        return -1;
+    }
+    return 0;
+}
+
+PyTypeObject G_GNUC_INTERNAL PyGimpHintBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.HintBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_hint_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpIntComboBox ----------- */
+
+#line 1058 "gimpui.override"
+static int
+_wrap_gimp_int_combo_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_items = NULL;
+    int len, i;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|O:gimpui.IntComboBox.__init__",
+                                     kwlist,
+                                     &py_items))
+        return -1; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return -1;
+    }
+
+    if (pygobject_construct(self, NULL))
+        return -1;
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return -1;
+        }
+
+        if (!PyInt_Check(value)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_int_combo_box_append(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+
+    return 0;
+}
+#line 3252 "gimpui.c"
+
+
+#line 1312 "gimpui.override"
+static PyObject *
+_wrap_gimp_int_combo_box_prepend(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *py_items;
+    int i, len;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O:gimpui.IntComboBox.prepend",
+                                     kwlist,
+                                     &py_items))
+        return NULL; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return NULL;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return NULL;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return NULL;
+        }
+
+        if (!PyInt_Check(value)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return NULL;
+        }
+
+        gimp_int_combo_box_prepend(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3317 "gimpui.c"
+
+
+#line 1249 "gimpui.override"
+static PyObject *
+_wrap_gimp_int_combo_box_append(PyGObject *self, PyObject *args,
+                                PyObject *kwargs)
+{
+    PyObject *py_items;
+    int i, len;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O:gimpui.IntComboBox.append",
+                                     kwlist,
+                                     &py_items))
+        return NULL; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return NULL;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return NULL;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return NULL;
+        }
+
+        if (!PyInt_Check(value)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return NULL;
+        }
+
+        gimp_int_combo_box_append(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3382 "gimpui.c"
+
+
+#line 1224 "gimpui.override"
+static PyObject *
+_wrap_gimp_int_combo_box_set_active(PyGObject *self, PyObject *args,
+                                    PyObject *kwargs)
+{
+    int value;
+
+    static char *kwlist[] = { "value", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "i:GimpIntComboBox.set_active", kwlist,
+                                     &value))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), value)) {
+        PyErr_Format(pygimp_error,
+                     "Value %d does not exist in GimpIntComboBox",
+                     value);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3409 "gimpui.c"
+
+
+#line 1211 "gimpui.override"
+static PyObject *
+_wrap_gimp_int_combo_box_get_active(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return PyLong_FromLong(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3424 "gimpui.c"
+
+
+#line 1128 "gimpui.override"
+static gboolean
+pygimp_int_combo_box_sensitivity_marshal(gint value, gpointer user_data)
+{
+    PyObject *py_value;
+    PyGimpIntSensitivityData *data;
+    PyObject *ret;
+    gboolean res;
+
+    data = user_data;
+
+    py_value = PyInt_FromLong(value);
+
+    ret = PyObject_CallFunctionObjArgs(data->sensitivity_func, py_value,
+                                       data->user_data, NULL);
+    
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(py_value);
+
+    return res;
+}
+
+static void
+pygimp_int_combo_box_sensitivity_data_destroy(gpointer user_data)
+{
+    PyGimpIntSensitivityData *data;
+    data = user_data;
+
+    Py_DECREF(data->sensitivity_func);
+    Py_XDECREF(data->user_data);
+
+    g_free(data);
+}
+
+static PyObject *
+_wrap_gimp_int_combo_box_set_sensitivity(PyGObject *self, PyObject *args,
+                                         PyObject *kwargs)
+{
+    PyObject *py_sensitivity_func;
+    PyObject *py_user_data = NULL;
+    PyGimpIntSensitivityData *data;
+
+    static char *kwlist[] = { "sensitivity_func", "user_data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O|O:GimpIntComboBox.set_sensitivity",
+                                     kwlist, &py_sensitivity_func,
+                                     &py_user_data))
+        return NULL;
+
+    if (!PyCallable_Check(py_sensitivity_func)) {
+        PyErr_SetString(PyExc_TypeError, "first argument must be callable.");
+        return NULL;
+    }
+
+    data = g_new(PyGimpIntSensitivityData, 1);
+
+    data->sensitivity_func = py_sensitivity_func;
+    Py_INCREF(data->sensitivity_func);
+    
+   if (py_user_data == NULL || py_user_data == Py_None)
+        data->user_data = NULL;
+    else {
+       data->user_data = py_user_data;
+       Py_INCREF(data->user_data);
+    }
+
+    gimp_int_combo_box_set_sensitivity(GIMP_INT_COMBO_BOX(self->obj),
+                                pygimp_int_combo_box_sensitivity_marshal,
+                                data,
+                                pygimp_int_combo_box_sensitivity_data_destroy);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3509 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpIntComboBox_methods[] = {
+    { "prepend", (PyCFunction)_wrap_gimp_int_combo_box_prepend, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "append", (PyCFunction)_wrap_gimp_int_combo_box_append, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_active", (PyCFunction)_wrap_gimp_int_combo_box_set_active, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active", (PyCFunction)_wrap_gimp_int_combo_box_get_active, METH_NOARGS,
+      NULL },
+    { "set_sensitivity", (PyCFunction)_wrap_gimp_int_combo_box_set_sensitivity, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpIntComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.IntComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpIntComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_int_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpImageComboBox ----------- */
+
+#line 609 "gimpui.override"
+static gboolean
+pygimp_image_constraint_marshal(gint32 image_id, gpointer user_data)
+{
+    PyObject *img, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_image_combo_box_new(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpImageConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.ImageComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_image_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_image_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_IMAGE_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.ImageComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 3656 "gimpui.c"
+
+
+#line 717 "gimpui.override"
+static PyObject *
+_wrap_gimp_image_combo_box_get_active_image(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_image_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3671 "gimpui.c"
+
+
+#line 691 "gimpui.override"
+static PyObject *
+_wrap_gimp_image_combo_box_set_active_image(PyGObject *self, PyObject *args,
+                                            PyObject *kwargs)
+{
+    PyGimpImage *img;
+
+    static char *kwlist[] = { "image", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpImageComboBox.set_active_image",
+                                     kwlist,
+                                     PyGimpImage_Type, &img))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), img->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Image (ID %d) does not exist in GimpImageComboBox",
+                     img->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3699 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpImageComboBox_methods[] = {
+    { "get_active_image", (PyCFunction)_wrap_gimp_image_combo_box_get_active_image, METH_NOARGS,
+      NULL },
+    { "set_active_image", (PyCFunction)_wrap_gimp_image_combo_box_set_active_image, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpImageComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ImageComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpImageComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_image_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpEnumComboBox ----------- */
+
+static int
+_wrap_gimp_enum_combo_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enum_type", NULL };
+    PyObject *py_enum_type = NULL;
+    GType enum_type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.EnumComboBox.__init__", kwlist, &py_enum_type))
+        return -1;
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return -1;
+    self->obj = (GObject *)gimp_enum_combo_box_new(enum_type);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpEnumComboBox object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_enum_combo_box_set_stock_prefix(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "stock_prefix", NULL };
+    char *stock_prefix;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.EnumComboBox.set_stock_prefix", kwlist, &stock_prefix))
+        return NULL;
+    
+    gimp_enum_combo_box_set_stock_prefix(GIMP_ENUM_COMBO_BOX(self->obj), stock_prefix);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpEnumComboBox_methods[] = {
+    { "set_stock_prefix", (PyCFunction)_wrap_gimp_enum_combo_box_set_stock_prefix, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.EnumComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpEnumComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_enum_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpDrawableComboBox ----------- */
+
+#line 89 "gimpui.override"
+static gboolean
+pygimp_drawable_constraint_marshal(gint32 image_id, gint32 drawable_id,
+                                   gpointer user_data)
+{
+    PyObject *img, *drw, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    drw = pygimp_drawable_new(NULL, drawable_id);
+    if (!drw) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, drw,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, drw, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(drw);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_drawable_combo_box_new(PyGObject *self, PyObject *args,
+                                  PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.DrawableComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_XINCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_drawable_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_drawable_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_DRAWABLE_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.DrawableComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 3940 "gimpui.c"
+
+
+#line 180 "gimpui.override"
+static PyObject *
+_wrap_gimp_drawable_combo_box_set_active_drawable(PyGObject *self, PyObject *args,
+                                                  PyObject *kwargs)
+{
+    PyGimpDrawable *drw;
+
+    static char *kwlist[] = { "drawable", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpDrawableComboBox.set_active_drawable",
+                                     kwlist,
+                                     PyGimpDrawable_Type, &drw))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), drw->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Drawable (ID %d) does not exist in GimpDrawableComboBox",
+                     drw->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3968 "gimpui.c"
+
+
+#line 206 "gimpui.override"
+static PyObject *
+_wrap_gimp_drawable_combo_box_get_active_drawable(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_drawable_new(NULL, value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 3983 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpDrawableComboBox_methods[] = {
+    { "set_active_drawable", (PyCFunction)_wrap_gimp_drawable_combo_box_set_active_drawable, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active_drawable", (PyCFunction)_wrap_gimp_drawable_combo_box_get_active_drawable, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpDrawableComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.DrawableComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpDrawableComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_drawable_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpChannelComboBox ----------- */
+
+#line 219 "gimpui.override"
+static gboolean
+pygimp_channel_constraint_marshal(gint32 image_id, gint32 channel_id,
+                                  gpointer user_data)
+{
+    PyObject *img, *chn, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    chn = pygimp_channel_new(channel_id);
+    if (!chn) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, chn,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, chn, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(chn);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_channel_combo_box_new(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.ChannelComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_channel_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_channel_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_CHANNEL_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.ChannelComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 4133 "gimpui.c"
+
+
+#line 310 "gimpui.override"
+static PyObject *
+_wrap_gimp_channel_combo_box_set_active_channel(PyGObject *self, PyObject *args,
+                                                PyObject *kwargs)
+{
+    PyGimpChannel *chn;
+
+    static char *kwlist[] = { "channel", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                    "O!:GimpChannelComboBox.set_active_channel",
+                                    kwlist,
+                                    PyGimpChannel_Type, &chn))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), chn->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Channel (ID %d) does not exist in GimpChannelComboBox",
+                     chn->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4161 "gimpui.c"
+
+
+#line 336 "gimpui.override"
+static PyObject *
+_wrap_gimp_channel_combo_box_get_active_channel(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_channel_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4176 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpChannelComboBox_methods[] = {
+    { "set_active_channel", (PyCFunction)_wrap_gimp_channel_combo_box_set_active_channel, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active_channel", (PyCFunction)_wrap_gimp_channel_combo_box_get_active_channel, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpChannelComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ChannelComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpChannelComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_channel_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpIntStore ----------- */
+
+ static int
+_wrap_gimp_int_store_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.IntStore.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.IntStore object");
+        return -1;
+    }
+    return 0;
+}
+
+#line 1727 "gimpui.override"
+static PyObject *
+_wrap_gimp_int_store_lookup_by_value(PyGObject *self, PyObject *args,
+                                     PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", NULL };
+    int value, ret;
+    GtkTreeIter iter;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                               "i:GimpIntStore.gimp_int_store_lookup_by_value",
+                               kwlist, &value))
+        return NULL;
+
+    ret = gimp_int_store_lookup_by_value(GTK_TREE_MODEL(self->obj), value,
+                                         &iter);
+    if (ret)
+        pyg_boxed_new(GTK_TYPE_TREE_ITER, &iter, TRUE, TRUE);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4278 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpIntStore_methods[] = {
+    { "lookup_by_value", (PyCFunction)_wrap_gimp_int_store_lookup_by_value, METH_VARARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpIntStore_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.IntStore",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpIntStore_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_int_store_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpEnumStore ----------- */
+
+#line 1847 "gimpui.override"
+static int
+_wrap_gimp_enum_store_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enum_type", "minimum", "maximum", NULL };
+    PyObject *py_enum_type = NULL;
+    PyObject *py_minimum = NULL;
+    PyObject *py_maximum = NULL;
+    GType enum_type;
+    GEnumClass *enum_class;
+    gint minimum, maximum;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O|O!O!:GimpEnumStore.__init__", kwlist,
+                                      &py_enum_type, &PyInt_Type, &py_minimum,
+                                      &PyInt_Type, &py_maximum))
+        return -1;
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return -1;
+
+    enum_class = g_type_class_ref(enum_type);
+
+    if (py_minimum == NULL)
+        minimum = enum_class->minimum;
+    else
+        minimum = PyInt_AsLong(py_minimum);
+    
+    if (py_maximum == NULL)
+        maximum = enum_class->maximum;
+    else
+        maximum = PyInt_AsLong(py_maximum);
+    
+    g_type_class_unref(enum_class);
+
+    self->obj = (GObject *)gimp_enum_store_new_with_range(enum_type, minimum, maximum);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpEnumStore object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 4379 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_enum_store_set_stock_prefix(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "stock_prefix", NULL };
+    char *stock_prefix;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.EnumStore.set_stock_prefix", kwlist, &stock_prefix))
+        return NULL;
+    
+    gimp_enum_store_set_stock_prefix(GIMP_ENUM_STORE(self->obj), stock_prefix);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpEnumStore_methods[] = {
+    { "set_stock_prefix", (PyCFunction)_wrap_gimp_enum_store_set_stock_prefix, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpEnumStore_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.EnumStore",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpEnumStore_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_enum_store_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpLayerComboBox ----------- */
+
+#line 349 "gimpui.override"
+static gboolean
+pygimp_layer_constraint_marshal(gint32 image_id, gint32 layer_id,
+                                gpointer user_data)
+{
+    PyObject *img, *lay, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    lay = pygimp_layer_new(layer_id);
+    if (!lay) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, lay,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, lay, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(lay);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_layer_combo_box_new(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.LayerComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_layer_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_layer_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_LAYER_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.LayerComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 4542 "gimpui.c"
+
+
+#line 466 "gimpui.override"
+static PyObject *
+_wrap_gimp_layer_combo_box_get_active_layer(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_layer_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4557 "gimpui.c"
+
+
+#line 440 "gimpui.override"
+static PyObject *
+_wrap_gimp_layer_combo_box_set_active_layer(PyGObject *self, PyObject *args,
+                                            PyObject *kwargs)
+{
+    PyGimpLayer *lay;
+
+    static char *kwlist[] = { "layer", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpLayerComboBox.set_active_layer",
+                                     kwlist,
+                                     PyGimpLayer_Type, &lay))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), lay->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Layer (ID %d) does not exist in GimpLayerComboBox",
+                     lay->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4585 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpLayerComboBox_methods[] = {
+    { "get_active_layer", (PyCFunction)_wrap_gimp_layer_combo_box_get_active_layer, METH_NOARGS,
+      NULL },
+    { "set_active_layer", (PyCFunction)_wrap_gimp_layer_combo_box_set_active_layer, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpLayerComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.LayerComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpLayerComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_layer_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpMemsizeEntry ----------- */
+
+#line 1750 "gimpui.override"
+static int
+_wrap_gimp_memsize_entry_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", "lower", "upper", NULL };
+    guint64 value, lower, upper;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "LLL:GimpMemsizeEntry.__init__",
+                                     kwlist, &value, &lower, &upper))
+        return -1;
+    
+    self->obj = (GObject *)gimp_memsize_entry_new(value, lower, upper);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpMemsizeEntry object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 4667 "gimpui.c"
+
+
+#line 1773 "gimpui.override"
+static PyObject *
+_wrap_gimp_memsize_entry_set_value(PyGObject *self, PyObject *args,
+                                   PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", NULL };
+    guint64 value;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "L:GimpMemsizeEntry.set_value",
+                                     kwlist, &value))
+        return NULL;
+
+    gimp_memsize_entry_set_value(GIMP_MEMSIZE_ENTRY(self->obj), value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4688 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_memsize_entry_get_value(PyGObject *self)
+{
+    guint64 ret;
+
+    
+    ret = gimp_memsize_entry_get_value(GIMP_MEMSIZE_ENTRY(self->obj));
+    
+    return PyLong_FromUnsignedLongLong(ret);
+}
+
+static const PyMethodDef _PyGimpMemsizeEntry_methods[] = {
+    { "set_value", (PyCFunction)_wrap_gimp_memsize_entry_set_value, METH_VARARGS,
+      NULL },
+    { "get_value", (PyCFunction)_wrap_gimp_memsize_entry_get_value, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpMemsizeEntry_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.MemsizeEntry",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpMemsizeEntry_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_memsize_entry_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpNumberPairEntry ----------- */
+
+static int
+_wrap_gimp_number_pair_entry_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[4];
+    PyObject *parsed_args[4] = {NULL, };
+    char *arg_names[] = {"separators", "allow_simplification", "min_valid_value", "max_valid_value", NULL };
+    char *prop_names[] = {"separators", "allow-simplification", "min-valid-value", "max-valid-value", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:gimpui.NumberPairEntry.__init__" , arg_names , &parsed_args[0] , &parsed_args[1] , &parsed_args[2] , &parsed_args[3]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*4);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.NumberPairEntry object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_number_pair_entry_set_default_values(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "left", "right", NULL };
+    double left, right;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.NumberPairEntry.set_default_values", kwlist, &left, &right))
+        return NULL;
+    
+    gimp_number_pair_entry_set_default_values(GIMP_NUMBER_PAIR_ENTRY(self->obj), left, right);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1523 "gimpui.override"
+static PyObject *
+_wrap_gimp_number_pair_entry_get_default_values(PyGObject *self)
+{
+    gdouble left, right;
+
+    gimp_number_pair_entry_get_default_values(
+                                             GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                             &left, &right);
+
+    return Py_BuildValue("(dd)", left, right);
+}
+#line 4816 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_number_pair_entry_set_values(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "left", "right", NULL };
+    double left, right;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.NumberPairEntry.set_values", kwlist, &left, &right))
+        return NULL;
+    
+    gimp_number_pair_entry_set_values(GIMP_NUMBER_PAIR_ENTRY(self->obj), left, right);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1511 "gimpui.override"
+static PyObject *
+_wrap_gimp_number_pair_entry_get_values(PyGObject *self)
+{
+    gdouble left, right;
+
+    gimp_number_pair_entry_get_values(GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                      &left, &right);
+
+    return Py_BuildValue("(dd)", left, right);   
+}
+#line 4845 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_number_pair_entry_set_default_text(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "string", NULL };
+    char *string;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.NumberPairEntry.set_default_text", kwlist, &string))
+        return NULL;
+    
+    gimp_number_pair_entry_set_default_text(GIMP_NUMBER_PAIR_ENTRY(self->obj), string);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_number_pair_entry_get_default_text(PyGObject *self)
+{
+    const gchar *ret;
+
+    
+    ret = gimp_number_pair_entry_get_default_text(GIMP_NUMBER_PAIR_ENTRY(self->obj));
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_number_pair_entry_set_ratio(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "ratio", NULL };
+    double ratio;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Gimp.NumberPairEntry.set_ratio", kwlist, &ratio))
+        return NULL;
+    
+    gimp_number_pair_entry_set_ratio(GIMP_NUMBER_PAIR_ENTRY(self->obj), ratio);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_number_pair_entry_get_ratio(PyGObject *self)
+{
+    double ret;
+
+    
+    ret = gimp_number_pair_entry_get_ratio(GIMP_NUMBER_PAIR_ENTRY(self->obj));
+    
+    return PyFloat_FromDouble(ret);
+}
+
+#line 1548 "gimpui.override"
+static PyObject *
+_wrap_gimp_number_pair_entry_set_aspect(PyGObject *self, PyObject *args,
+                                        PyObject *kwargs)
+{
+    PyObject *py_aspect;
+    GimpAspectType aspect;
+
+    static char *kwlist[] = {"aspect", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                    "O:GimpNumberPairEntry.set_aspect",
+                                    kwlist, &py_aspect))
+        return NULL;
+
+    if (pyg_enum_get_value(GIMP_TYPE_ASPECT_TYPE, py_aspect, (gint*)&aspect))
+    {
+        Py_XDECREF(py_aspect);
+        return NULL;
+    }
+
+    gimp_number_pair_entry_set_aspect(GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                      aspect);
+
+    Py_DECREF(py_aspect);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 4932 "gimpui.c"
+
+
+#line 1536 "gimpui.override"
+static PyObject *
+_wrap_gimp_number_pair_entry_get_aspect(PyGObject *self)
+{
+    GimpAspectType aspect;
+
+    aspect =
+          gimp_number_pair_entry_get_aspect(GIMP_NUMBER_PAIR_ENTRY(self->obj));
+
+    return pyg_enum_from_gtype(GIMP_TYPE_ASPECT_TYPE, aspect);
+}
+#line 4946 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_number_pair_entry_set_user_override(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "user_override", NULL };
+    int user_override;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.NumberPairEntry.set_user_override", kwlist, &user_override))
+        return NULL;
+    
+    gimp_number_pair_entry_set_user_override(GIMP_NUMBER_PAIR_ENTRY(self->obj), user_override);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_number_pair_entry_get_user_override(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_number_pair_entry_get_user_override(GIMP_NUMBER_PAIR_ENTRY(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static const PyMethodDef _PyGimpNumberPairEntry_methods[] = {
+    { "set_default_values", (PyCFunction)_wrap_gimp_number_pair_entry_set_default_values, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_default_values", (PyCFunction)_wrap_gimp_number_pair_entry_get_default_values, METH_NOARGS,
+      NULL },
+    { "set_values", (PyCFunction)_wrap_gimp_number_pair_entry_set_values, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_values", (PyCFunction)_wrap_gimp_number_pair_entry_get_values, METH_NOARGS,
+      NULL },
+    { "set_default_text", (PyCFunction)_wrap_gimp_number_pair_entry_set_default_text, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_default_text", (PyCFunction)_wrap_gimp_number_pair_entry_get_default_text, METH_NOARGS,
+      NULL },
+    { "set_ratio", (PyCFunction)_wrap_gimp_number_pair_entry_set_ratio, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_ratio", (PyCFunction)_wrap_gimp_number_pair_entry_get_ratio, METH_NOARGS,
+      NULL },
+    { "set_aspect", (PyCFunction)_wrap_gimp_number_pair_entry_set_aspect, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_aspect", (PyCFunction)_wrap_gimp_number_pair_entry_get_aspect, METH_NOARGS,
+      NULL },
+    { "set_user_override", (PyCFunction)_wrap_gimp_number_pair_entry_set_user_override, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_user_override", (PyCFunction)_wrap_gimp_number_pair_entry_get_user_override, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpNumberPairEntry_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.NumberPairEntry",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpNumberPairEntry_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_number_pair_entry_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpOffsetArea ----------- */
+
+static int
+_wrap_gimp_offset_area_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "orig_width", "orig_height", NULL };
+    int orig_width, orig_height;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.__init__", kwlist, &orig_width, &orig_height))
+        return -1;
+    self->obj = (GObject *)gimp_offset_area_new(orig_width, orig_height);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpOffsetArea object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_offset_area_set_pixbuf(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "pixbuf", NULL };
+    PyGObject *pixbuf;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.OffsetArea.set_pixbuf", kwlist, &PyGdkPixbuf_Type, &pixbuf))
+        return NULL;
+    
+    gimp_offset_area_set_pixbuf(GIMP_OFFSET_AREA(self->obj), GDK_PIXBUF(pixbuf->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_offset_area_set_size(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "width", "height", NULL };
+    int width, height;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.set_size", kwlist, &width, &height))
+        return NULL;
+    
+    gimp_offset_area_set_size(GIMP_OFFSET_AREA(self->obj), width, height);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_offset_area_set_offsets(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "offset_x", "offset_y", NULL };
+    int offset_x, offset_y;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.set_offsets", kwlist, &offset_x, &offset_y))
+        return NULL;
+    
+    gimp_offset_area_set_offsets(GIMP_OFFSET_AREA(self->obj), offset_x, offset_y);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpOffsetArea_methods[] = {
+    { "set_pixbuf", (PyCFunction)_wrap_gimp_offset_area_set_pixbuf, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_size", (PyCFunction)_wrap_gimp_offset_area_set_size, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_offsets", (PyCFunction)_wrap_gimp_offset_area_set_offsets, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpOffsetArea_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.OffsetArea",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpOffsetArea_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_offset_area_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPageSelector ----------- */
+
+ static int
+_wrap_gimp_page_selector_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.PageSelector.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PageSelector object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_set_n_pages(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "n_pages", NULL };
+    int n_pages;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.set_n_pages", kwlist, &n_pages))
+        return NULL;
+    
+    gimp_page_selector_set_n_pages(GIMP_PAGE_SELECTOR(self->obj), n_pages);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_get_n_pages(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_page_selector_get_n_pages(GIMP_PAGE_SELECTOR(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_gimp_page_selector_set_target(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "target", NULL };
+    GimpPageSelectorTarget target;
+    PyObject *py_target = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.PageSelector.set_target", kwlist, &py_target))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_PAGE_SELECTOR_TARGET, py_target, (gpointer)&target))
+        return NULL;
+    
+    gimp_page_selector_set_target(GIMP_PAGE_SELECTOR(self->obj), target);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_get_target(PyGObject *self)
+{
+    gint ret;
+
+    
+    ret = gimp_page_selector_get_target(GIMP_PAGE_SELECTOR(self->obj));
+    
+    return pyg_enum_from_gtype(GIMP_TYPE_PAGE_SELECTOR_TARGET, ret);
+}
+
+static PyObject *
+_wrap_gimp_page_selector_set_page_thumbnail(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", "thumbnail", NULL };
+    int page_no;
+    PyGObject *thumbnail;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iO!:Gimp.PageSelector.set_page_thumbnail", kwlist, &page_no, &PyGdkPixbuf_Type, &thumbnail))
+        return NULL;
+    
+    gimp_page_selector_set_page_thumbnail(GIMP_PAGE_SELECTOR(self->obj), page_no, GDK_PIXBUF(thumbnail->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_get_page_thumbnail(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", NULL };
+    int page_no;
+    GdkPixbuf *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.get_page_thumbnail", kwlist, &page_no))
+        return NULL;
+    
+    ret = gimp_page_selector_get_page_thumbnail(GIMP_PAGE_SELECTOR(self->obj), page_no);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_page_selector_set_page_label(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", "label", NULL };
+    int page_no;
+    char *label;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"is:Gimp.PageSelector.set_page_label", kwlist, &page_no, &label))
+        return NULL;
+    
+    gimp_page_selector_set_page_label(GIMP_PAGE_SELECTOR(self->obj), page_no, label);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_get_page_label(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", NULL };
+    int page_no;
+    gchar *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.get_page_label", kwlist, &page_no))
+        return NULL;
+    
+    ret = gimp_page_selector_get_page_label(GIMP_PAGE_SELECTOR(self->obj), page_no);
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_select_all(PyGObject *self)
+{
+    
+    gimp_page_selector_select_all(GIMP_PAGE_SELECTOR(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_unselect_all(PyGObject *self)
+{
+    
+    gimp_page_selector_unselect_all(GIMP_PAGE_SELECTOR(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_select_page(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", NULL };
+    int page_no;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.select_page", kwlist, &page_no))
+        return NULL;
+    
+    gimp_page_selector_select_page(GIMP_PAGE_SELECTOR(self->obj), page_no);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_unselect_page(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", NULL };
+    int page_no;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.unselect_page", kwlist, &page_no))
+        return NULL;
+    
+    gimp_page_selector_unselect_page(GIMP_PAGE_SELECTOR(self->obj), page_no);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_page_is_selected(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "page_no", NULL };
+    int page_no, ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.page_is_selected", kwlist, &page_no))
+        return NULL;
+    
+    ret = gimp_page_selector_page_is_selected(GIMP_PAGE_SELECTOR(self->obj), page_no);
+    
+    return PyBool_FromLong(ret);
+
+}
+
+#line 1578 "gimpui.override"
+static PyObject *
+_wrap_gimp_page_selector_get_selected_pages(PyGObject *self)
+{
+    gint *selected_pages;
+    gint n_selected_pages;
+    PyObject *py_selected_pages;
+    int i;
+
+    selected_pages = gimp_page_selector_get_selected_pages(
+                                                GIMP_PAGE_SELECTOR (self->obj),
+                                                &n_selected_pages);
+    
+    py_selected_pages = PyTuple_New(n_selected_pages);
+    for (i = 0; i < n_selected_pages; ++i)
+        PyTuple_SetItem(py_selected_pages, i,
+                        PyInt_FromLong(selected_pages[i]));
+
+    g_free(selected_pages);
+
+    return py_selected_pages;
+}
+#line 5406 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_page_selector_select_range(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "range", NULL };
+    char *range;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PageSelector.select_range", kwlist, &range))
+        return NULL;
+    
+    gimp_page_selector_select_range(GIMP_PAGE_SELECTOR(self->obj), range);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_page_selector_get_selected_range(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_page_selector_get_selected_range(GIMP_PAGE_SELECTOR(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpPageSelector_methods[] = {
+    { "set_n_pages", (PyCFunction)_wrap_gimp_page_selector_set_n_pages, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_n_pages", (PyCFunction)_wrap_gimp_page_selector_get_n_pages, METH_NOARGS,
+      NULL },
+    { "set_target", (PyCFunction)_wrap_gimp_page_selector_set_target, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_target", (PyCFunction)_wrap_gimp_page_selector_get_target, METH_NOARGS,
+      NULL },
+    { "set_page_thumbnail", (PyCFunction)_wrap_gimp_page_selector_set_page_thumbnail, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_page_thumbnail", (PyCFunction)_wrap_gimp_page_selector_get_page_thumbnail, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_page_label", (PyCFunction)_wrap_gimp_page_selector_set_page_label, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_page_label", (PyCFunction)_wrap_gimp_page_selector_get_page_label, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "select_all", (PyCFunction)_wrap_gimp_page_selector_select_all, METH_NOARGS,
+      NULL },
+    { "unselect_all", (PyCFunction)_wrap_gimp_page_selector_unselect_all, METH_NOARGS,
+      NULL },
+    { "select_page", (PyCFunction)_wrap_gimp_page_selector_select_page, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "unselect_page", (PyCFunction)_wrap_gimp_page_selector_unselect_page, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "page_is_selected", (PyCFunction)_wrap_gimp_page_selector_page_is_selected, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_selected_pages", (PyCFunction)_wrap_gimp_page_selector_get_selected_pages, METH_NOARGS,
+      NULL },
+    { "select_range", (PyCFunction)_wrap_gimp_page_selector_select_range, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_selected_range", (PyCFunction)_wrap_gimp_page_selector_get_selected_range, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPageSelector_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PageSelector",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPageSelector_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_page_selector_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPathEditor ----------- */
+
+static int
+_wrap_gimp_path_editor_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"title", "path", NULL };
+    char *prop_names[] = {"title", "path", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:gimpui.PathEditor.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PathEditor object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_path_editor_get_path(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_path_editor_get_path(GIMP_PATH_EDITOR(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_path_editor_set_path(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "path", NULL };
+    char *path;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.set_path", kwlist, &path))
+        return NULL;
+    
+    gimp_path_editor_set_path(GIMP_PATH_EDITOR(self->obj), path);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_path_editor_get_writable_path(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_path_editor_get_writable_path(GIMP_PATH_EDITOR(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_path_editor_set_writable_path(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "path", NULL };
+    char *path;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.set_writable_path", kwlist, &path))
+        return NULL;
+    
+    gimp_path_editor_set_writable_path(GIMP_PATH_EDITOR(self->obj), path);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_path_editor_get_dir_writable(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "directory", NULL };
+    char *directory;
+    int ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.get_dir_writable", kwlist, &directory))
+        return NULL;
+    
+    ret = gimp_path_editor_get_dir_writable(GIMP_PATH_EDITOR(self->obj), directory);
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_path_editor_set_dir_writable(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "directory", "writable", NULL };
+    char *directory;
+    int writable;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:Gimp.PathEditor.set_dir_writable", kwlist, &directory, &writable))
+        return NULL;
+    
+    gimp_path_editor_set_dir_writable(GIMP_PATH_EDITOR(self->obj), directory, writable);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpPathEditor_methods[] = {
+    { "get_path", (PyCFunction)_wrap_gimp_path_editor_get_path, METH_NOARGS,
+      NULL },
+    { "set_path", (PyCFunction)_wrap_gimp_path_editor_set_path, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_writable_path", (PyCFunction)_wrap_gimp_path_editor_get_writable_path, METH_NOARGS,
+      NULL },
+    { "set_writable_path", (PyCFunction)_wrap_gimp_path_editor_set_writable_path, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_dir_writable", (PyCFunction)_wrap_gimp_path_editor_get_dir_writable, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_dir_writable", (PyCFunction)_wrap_gimp_path_editor_set_dir_writable, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPathEditor_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PathEditor",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPathEditor_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_path_editor_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPickButton ----------- */
+
+ static int
+_wrap_gimp_pick_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.PickButton.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PickButton object");
+        return -1;
+    }
+    return 0;
+}
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPickButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PickButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_pick_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPreview ----------- */
+
+static PyObject *
+_wrap_gimp_preview_set_update(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "update", NULL };
+    int update;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.Preview.set_update", kwlist, &update))
+        return NULL;
+    
+    gimp_preview_set_update(GIMP_PREVIEW(self->obj), update);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_get_update(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_preview_get_update(GIMP_PREVIEW(self->obj));
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_preview_set_bounds(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "xmin", "ymin", "xmax", "ymax", NULL };
+    int xmin, ymin, xmax, ymax;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiii:Gimp.Preview.set_bounds", kwlist, &xmin, &ymin, &xmax, &ymax))
+        return NULL;
+    
+    gimp_preview_set_bounds(GIMP_PREVIEW(self->obj), xmin, ymin, xmax, ymax);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1601 "gimpui.override"
+static PyObject *
+_wrap_gimp_preview_get_position(PyGObject *self)
+{
+    gint x;
+    gint y;
+  
+    gimp_preview_get_position(GIMP_PREVIEW(self->obj), &x, &y);
+
+    return Py_BuildValue("(ii)", x, y);
+}
+#line 5839 "gimpui.c"
+
+
+#line 1613 "gimpui.override"
+static PyObject *
+_wrap_gimp_preview_get_size(PyGObject *self)
+{
+    gint width;
+    gint height;
+  
+    gimp_preview_get_size(GIMP_PREVIEW(self->obj), &width, &height);
+
+    return Py_BuildValue("(ii)", width, height);
+}
+#line 5853 "gimpui.c"
+
+
+#line 1625 "gimpui.override"
+static PyObject *
+_wrap_gimp_preview_transform(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gint src_x;
+    gint src_y;
+    gint dest_x;
+    gint dest_y;
+
+    static char *kwlist[] = {"x", "y", NULL};
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:GimpPreview.transform",
+                                     kwlist, &src_x, &src_y))
+        return NULL;
+
+    gimp_preview_transform(GIMP_PREVIEW(self->obj), src_x, src_y, &dest_x,
+                           &dest_y);
+
+    return Py_BuildValue("(ii)", dest_x, dest_y);
+}
+#line 5876 "gimpui.c"
+
+
+#line 1646 "gimpui.override"
+static PyObject *
+_wrap_gimp_preview_untransform(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    gint src_x;
+    gint src_y;
+    gint dest_x;
+    gint dest_y;
+
+    static char *kwlist[] = {"x", "y", NULL};
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "ii:GimpPreview.untransform",
+                                     kwlist, &src_x, &src_y))
+        return NULL;
+
+    gimp_preview_untransform(GIMP_PREVIEW(self->obj), src_x, src_y, &dest_x,
+                             &dest_y);
+
+    return Py_BuildValue("(ii)", dest_x, dest_y);
+}
+#line 5901 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_preview_get_area(PyGObject *self)
+{
+    GtkWidget *ret;
+
+    
+    ret = gimp_preview_get_area(GIMP_PREVIEW(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_preview_draw(PyGObject *self)
+{
+    
+    gimp_preview_draw(GIMP_PREVIEW(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_draw_buffer(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "buffer", "rowstride", NULL };
+    int buffer_len, rowstride;
+    guchar *buffer;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:Gimp.Preview.draw_buffer", kwlist, &buffer, &buffer_len, &rowstride))
+        return NULL;
+    
+    gimp_preview_draw_buffer(GIMP_PREVIEW(self->obj), buffer, rowstride);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_invalidate(PyGObject *self)
+{
+    
+    gimp_preview_invalidate(GIMP_PREVIEW(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_set_default_cursor(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "cursor", NULL };
+    PyObject *py_cursor;
+    GdkCursor *cursor = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Preview.set_default_cursor", kwlist, &py_cursor))
+        return NULL;
+    if (pyg_boxed_check(py_cursor, GDK_TYPE_CURSOR))
+        cursor = pyg_boxed_get(py_cursor, GdkCursor);
+    else {
+        PyErr_SetString(PyExc_TypeError, "cursor should be a GdkCursor");
+        return NULL;
+    }
+    
+    gimp_preview_set_default_cursor(GIMP_PREVIEW(self->obj), cursor);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_get_controls(PyGObject *self)
+{
+    GtkWidget *ret;
+
+    
+    ret = gimp_preview_get_controls(GIMP_PREVIEW(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static const PyMethodDef _PyGimpPreview_methods[] = {
+    { "set_update", (PyCFunction)_wrap_gimp_preview_set_update, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_update", (PyCFunction)_wrap_gimp_preview_get_update, METH_NOARGS,
+      NULL },
+    { "set_bounds", (PyCFunction)_wrap_gimp_preview_set_bounds, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_position", (PyCFunction)_wrap_gimp_preview_get_position, METH_NOARGS,
+      NULL },
+    { "get_size", (PyCFunction)_wrap_gimp_preview_get_size, METH_NOARGS,
+      NULL },
+    { "transform", (PyCFunction)_wrap_gimp_preview_transform, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "untransform", (PyCFunction)_wrap_gimp_preview_untransform, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_area", (PyCFunction)_wrap_gimp_preview_get_area, METH_NOARGS,
+      NULL },
+    { "draw", (PyCFunction)_wrap_gimp_preview_draw, METH_NOARGS,
+      NULL },
+    { "draw_buffer", (PyCFunction)_wrap_gimp_preview_draw_buffer, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "invalidate", (PyCFunction)_wrap_gimp_preview_invalidate, METH_NOARGS,
+      NULL },
+    { "set_default_cursor", (PyCFunction)_wrap_gimp_preview_set_default_cursor, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_controls", (PyCFunction)_wrap_gimp_preview_get_controls, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPreview_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Preview",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPreview_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpAspectPreview ----------- */
+
+#line 1928 "gimpui.override"
+static int
+_wrap_gimp_aspect_preview_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", NULL };
+    PyGimpDrawable *py_drawable;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|:GimpAspectPreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable))
+        return -1;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+    
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, NULL))
+        return -1;
+    
+    g_signal_connect_swapped(self->obj, "destroy",
+                             (GCallback)pygimp_decref_callback, py_drawable);
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+#line 6089 "gimpui.c"
+
+
+PyTypeObject G_GNUC_INTERNAL PyGimpAspectPreview_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.AspectPreview",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_aspect_preview_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPreviewArea ----------- */
+
+static int
+_wrap_gimp_preview_area_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.PreviewArea.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PreviewArea object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_draw(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", "width", "height", "type", "buf", "rowstride", NULL };
+    int x, y, width, height, buf_len, rowstride;
+    PyObject *py_type = NULL;
+    guchar *buf;
+    GimpImageType type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiOs#i:Gimp.PreviewArea.draw", kwlist, &x, &y, &width, &height, &py_type, &buf, &buf_len, &rowstride))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_IMAGE_TYPE, py_type, (gpointer)&type))
+        return NULL;
+    
+    gimp_preview_area_draw(GIMP_PREVIEW_AREA(self->obj), x, y, width, height, type, buf, rowstride);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_blend(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", "width", "height", "type", "buf1", "rowstride1", "buf2", "rowstride2", "opacity", NULL };
+    int x, y, width, height, buf1_len, rowstride1, buf2_len, rowstride2;
+    PyObject *py_type = NULL;
+    guchar *buf1, *buf2;
+    char opacity;
+    GimpImageType type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiOs#is#ic:Gimp.PreviewArea.blend", kwlist, &x, &y, &width, &height, &py_type, &buf1, &buf1_len, &rowstride1, &buf2, &buf2_len, &rowstride2, &opacity))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_IMAGE_TYPE, py_type, (gpointer)&type))
+        return NULL;
+    
+    gimp_preview_area_blend(GIMP_PREVIEW_AREA(self->obj), x, y, width, height, type, buf1, rowstride1, buf2, rowstride2, opacity);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_mask(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", "width", "height", "type", "buf1", "rowstride1", "buf2", "rowstride2", "mask", "rowstride_mask", NULL };
+    int x, y, width, height, buf1_len, rowstride1, buf2_len, rowstride2, mask_len, rowstride_mask;
+    PyObject *py_type = NULL;
+    guchar *buf1, *buf2, *mask;
+    GimpImageType type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiOs#is#is#i:Gimp.PreviewArea.mask", kwlist, &x, &y, &width, &height, &py_type, &buf1, &buf1_len, &rowstride1, &buf2, &buf2_len, &rowstride2, &mask, &mask_len, &rowstride_mask))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_IMAGE_TYPE, py_type, (gpointer)&type))
+        return NULL;
+    
+    gimp_preview_area_mask(GIMP_PREVIEW_AREA(self->obj), x, y, width, height, type, buf1, rowstride1, buf2, rowstride2, mask, rowstride_mask);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_fill(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", "width", "height", "red", "green", "blue", NULL };
+    int x, y, width, height;
+    char red, green, blue;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiccc:Gimp.PreviewArea.fill", kwlist, &x, &y, &width, &height, &red, &green, &blue))
+        return NULL;
+    
+    gimp_preview_area_fill(GIMP_PREVIEW_AREA(self->obj), x, y, width, height, red, green, blue);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_set_offsets(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", NULL };
+    int x, y;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.PreviewArea.set_offsets", kwlist, &x, &y))
+        return NULL;
+    
+    gimp_preview_area_set_offsets(GIMP_PREVIEW_AREA(self->obj), x, y);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_set_colormap(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "colormap", "num_colors", NULL };
+    int colormap_len, num_colors;
+    guchar *colormap;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:Gimp.PreviewArea.set_colormap", kwlist, &colormap, &colormap_len, &num_colors))
+        return NULL;
+    
+    gimp_preview_area_set_colormap(GIMP_PREVIEW_AREA(self->obj), colormap, num_colors);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_set_max_size(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "width", "height", NULL };
+    int width, height;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.PreviewArea.set_max_size", kwlist, &width, &height))
+        return NULL;
+    
+    gimp_preview_area_set_max_size(GIMP_PREVIEW_AREA(self->obj), width, height);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_preview_area_menu_popup(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "event", NULL };
+    GdkEvent *event = NULL;
+    PyObject *py_event;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.PreviewArea.menu_popup", kwlist, &py_event))
+        return NULL;
+    if (pyg_boxed_check(py_event, GDK_TYPE_EVENT))
+        event = pyg_boxed_get(py_event, GdkEvent);
+    else {
+        PyErr_SetString(PyExc_TypeError, "event should be a GdkEvent");
+        return NULL;
+    }
+    
+    gimp_preview_area_menu_popup(GIMP_PREVIEW_AREA(self->obj), (GdkEventButton *)event);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpPreviewArea_methods[] = {
+    { "draw", (PyCFunction)_wrap_gimp_preview_area_draw, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "blend", (PyCFunction)_wrap_gimp_preview_area_blend, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "mask", (PyCFunction)_wrap_gimp_preview_area_mask, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "fill", (PyCFunction)_wrap_gimp_preview_area_fill, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_offsets", (PyCFunction)_wrap_gimp_preview_area_set_offsets, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_colormap", (PyCFunction)_wrap_gimp_preview_area_set_colormap, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_max_size", (PyCFunction)_wrap_gimp_preview_area_set_max_size, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "menu_popup", (PyCFunction)_wrap_gimp_preview_area_menu_popup, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPreviewArea_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PreviewArea",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPreviewArea_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_preview_area_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpProcBrowserDialog ----------- */
+
+#line 1404 "gimpui.override"
+static int
+_wrap_gimp_proc_browser_dialog_new(PyGObject *self, PyObject *args,
+                                   PyObject *kwargs)
+{
+    gchar *title, *role;
+    PyObject *py_buttons = Py_None;
+    PyObject *help_func = NULL;
+    gchar *help_id = NULL;
+    int len, i;
+    GimpHelpFunc func;
+
+    static char *kwlist[] = { "title", "role", "help_func", "help_id",
+                              "buttons", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "zz|OzO:gimpui.GimpProcBrowserDialog.__init__",
+                                     kwlist,
+                                     &title, &role, &help_func, &help_id,
+                                     &py_buttons))
+        return -1;
+
+    if (py_buttons == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_buttons))
+        len = PyTuple_Size(py_buttons);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "buttons must be a tuple containing text/response "
+                        "pairs or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "buttons tuple must contain text/response id pairs");
+        return -1;
+    }
+
+    if (help_func) {
+        if (help_func != Py_None) {
+            if (!PyCallable_Check(help_func)) {
+                PyErr_SetString(PyExc_TypeError, "help_func must be callable");
+                return -1;
+            }
+
+            func = pygimp_help_func_marshal;
+
+       } else {
+            func = gimp_standard_help_func;
+        }
+    } else {
+        func = gimp_standard_help_func;
+    }
+
+    pygobject_construct(self,
+                        "title",     title,
+                        "role",      role,
+                        "help-func", func,
+                        "help-id",   help_id,
+                        NULL);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpProcBrowserDialog object");
+        return -1;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *text = PyTuple_GetItem(py_buttons, i);
+        PyObject *id = PyTuple_GetItem(py_buttons, i + 1);
+        if (!PyString_Check(text) && !PyUnicode_Check(text)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each text/response id pair "
+                            "must be a string");
+            return -1;
+        }
+        if (!PyInt_Check(id)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each text/response id pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_dialog_add_button(GIMP_DIALOG(self->obj), PyString_AsString(text),
+                               PyInt_AsLong(id));
+    }
+
+    if (help_func && help_func != Py_None) {
+        g_object_set_data(self->obj, "pygimp-dialog-help-data", self);
+
+        Py_INCREF(help_func);
+        g_object_set_data_full(self->obj, "pygimp-dialog-help-func",
+                               help_func, pygimp_help_func_destroy);
+    }
+
+    g_signal_emit_by_name(GIMP_PROC_BROWSER_DIALOG(self->obj)->browser,
+                          "search", "", 0, self->obj);
+    return 0;
+}
+#line 6479 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_proc_browser_dialog_get_selected(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_proc_browser_dialog_get_selected(GIMP_PROC_BROWSER_DIALOG(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpProcBrowserDialog_methods[] = {
+    { "get_selected", (PyCFunction)_wrap_gimp_proc_browser_dialog_get_selected, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpProcBrowserDialog_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ProcBrowserDialog",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpProcBrowserDialog_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_proc_browser_dialog_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpProgressBar ----------- */
+
+static int
+_wrap_gimp_progress_bar_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.ProgressBar.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ProgressBar object");
+        return -1;
+    }
+    return 0;
+}
+
+PyTypeObject G_GNUC_INTERNAL PyGimpProgressBar_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ProgressBar",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_progress_bar_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpScrolledPreview ----------- */
+
+static PyObject *
+_wrap_gimp_scrolled_preview_set_position(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "x", "y", NULL };
+    int x, y;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.ScrolledPreview.set_position", kwlist, &x, &y))
+        return NULL;
+    
+    gimp_scrolled_preview_set_position(GIMP_SCROLLED_PREVIEW(self->obj), x, y);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_scrolled_preview_set_policy(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "hscrollbar_policy", "vscrollbar_policy", NULL };
+    PyObject *py_hscrollbar_policy = NULL, *py_vscrollbar_policy = NULL;
+    GtkPolicyType hscrollbar_policy, vscrollbar_policy;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ScrolledPreview.set_policy", kwlist, &py_hscrollbar_policy, &py_vscrollbar_policy))
+        return NULL;
+    if (pyg_enum_get_value(GTK_TYPE_POLICY_TYPE, py_hscrollbar_policy, (gpointer)&hscrollbar_policy))
+        return NULL;
+    if (pyg_enum_get_value(GTK_TYPE_POLICY_TYPE, py_vscrollbar_policy, (gpointer)&vscrollbar_policy))
+        return NULL;
+    
+    gimp_scrolled_preview_set_policy(GIMP_SCROLLED_PREVIEW(self->obj), hscrollbar_policy, vscrollbar_policy);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_scrolled_preview_freeze(PyGObject *self)
+{
+    
+    gimp_scrolled_preview_freeze(GIMP_SCROLLED_PREVIEW(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_scrolled_preview_thaw(PyGObject *self)
+{
+    
+    gimp_scrolled_preview_thaw(GIMP_SCROLLED_PREVIEW(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpScrolledPreview_methods[] = {
+    { "set_position", (PyCFunction)_wrap_gimp_scrolled_preview_set_position, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_policy", (PyCFunction)_wrap_gimp_scrolled_preview_set_policy, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "freeze", (PyCFunction)_wrap_gimp_scrolled_preview_freeze, METH_NOARGS,
+      NULL },
+    { "thaw", (PyCFunction)_wrap_gimp_scrolled_preview_thaw, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpScrolledPreview_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ScrolledPreview",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpScrolledPreview_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpDrawablePreview ----------- */
+
+#line 1955 "gimpui.override"
+static int
+_wrap_gimp_drawable_preview_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", NULL };
+    PyGimpDrawable *py_drawable;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|:GimpDrawablePreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable))
+        return -1;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+  
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, NULL))
+        return -1;
+
+    g_object_set_data_full(self->obj, "pygimp-drawable-preview-pydrawable",
+                           py_drawable, 
+                           (GDestroyNotify)pygimp_decref_callback);
+
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+
+#line 6766 "gimpui.c"
+
+
+#line 1682 "gimpui.override"
+static PyObject *
+_wrap_gimp_drawable_preview_get_drawable(PyGObject *self)
+{
+    PyObject *drawable;
+    
+    drawable = g_object_get_data(self->obj, 
+                                 "pygimp-drawable-preview-pydrawable");
+    Py_INCREF(drawable);
+    return drawable;
+}
+#line 6780 "gimpui.c"
+
+
+#line 1706 "gimpui.override"
+static PyObject *
+_wrap_gimp_drawable_preview_draw_region(PyGObject *self, PyObject *args,
+                                        PyObject *kwargs)
+{
+/*    PyGimpPixelRgn *pypixelrgn;
+
+    static char *kwlist[] = {"drawable", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                    "O!:GimpDrawablePreview.draw_region",
+                                    kwlist, PyGimpPixelRgn_Type, &pypixelrgn))
+        return NULL;
+
+    gimp_drawable_preview_draw_region(GIMP_DRAWABLE_PREVIEW(self->obj),
+                                      &pypixelrgn->pr);
+*/
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 6803 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpDrawablePreview_methods[] = {
+    { "get_drawable", (PyCFunction)_wrap_gimp_drawable_preview_get_drawable, METH_NOARGS,
+      NULL },
+    { "draw_region", (PyCFunction)_wrap_gimp_drawable_preview_draw_region, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpDrawablePreview_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.DrawablePreview",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpDrawablePreview_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_drawable_preview_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpSelectButton ----------- */
+
+static PyObject *
+_wrap_gimp_select_button_close_popup(PyGObject *self)
+{
+    
+    gimp_select_button_close_popup(GIMP_SELECT_BUTTON(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpSelectButton_methods[] = {
+    { "close_popup", (PyCFunction)_wrap_gimp_select_button_close_popup, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.SelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPatternSelectButton ----------- */
+
+static int
+_wrap_gimp_pattern_select_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"title", "pattern_name", NULL };
+    char *prop_names[] = {"title", "pattern-name", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:gimpui.PatternSelectButton.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PatternSelectButton object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_pattern_select_button_get_pattern(PyGObject *self)
+{
+    const gchar *ret;
+
+    
+    ret = gimp_pattern_select_button_get_pattern(GIMP_PATTERN_SELECT_BUTTON(self->obj));
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_pattern_select_button_set_pattern(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "pattern_name", NULL };
+    char *pattern_name;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PatternSelectButton.set_pattern", kwlist, &pattern_name))
+        return NULL;
+    
+    gimp_pattern_select_button_set_pattern(GIMP_PATTERN_SELECT_BUTTON(self->obj), pattern_name);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpPatternSelectButton_methods[] = {
+    { "get_pattern", (PyCFunction)_wrap_gimp_pattern_select_button_get_pattern, METH_NOARGS,
+      NULL },
+    { "set_pattern", (PyCFunction)_wrap_gimp_pattern_select_button_set_pattern, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPatternSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PatternSelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPatternSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_pattern_select_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpPaletteSelectButton ----------- */
+
+ static int
+_wrap_gimp_palette_select_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"title", "palette_name", NULL };
+    char *prop_names[] = {"title", "palette-name", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:gimpui.PaletteSelectButton.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.PaletteSelectButton object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_palette_select_button_get_palette(PyGObject *self)
+{
+    const gchar *ret;
+
+    
+    ret = gimp_palette_select_button_get_palette(GIMP_PALETTE_SELECT_BUTTON(self->obj));
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_palette_select_button_set_palette(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "palette_name", NULL };
+    char *palette_name;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PaletteSelectButton.set_palette", kwlist, &palette_name))
+        return NULL;
+    
+    gimp_palette_select_button_set_palette(GIMP_PALETTE_SELECT_BUTTON(self->obj), palette_name);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpPaletteSelectButton_methods[] = {
+    { "get_palette", (PyCFunction)_wrap_gimp_palette_select_button_get_palette, METH_NOARGS,
+      NULL },
+    { "set_palette", (PyCFunction)_wrap_gimp_palette_select_button_set_palette, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpPaletteSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.PaletteSelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpPaletteSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_palette_select_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpGradientSelectButton ----------- */
+
+ static int
+_wrap_gimp_gradient_select_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"title", "gradient_name", NULL };
+    char *prop_names[] = {"title", "gradient-name", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:gimpui.GradientSelectButton.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.GradientSelectButton object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_gradient_select_button_get_gradient(PyGObject *self)
+{
+    const gchar *ret;
+
+    
+    ret = gimp_gradient_select_button_get_gradient(GIMP_GRADIENT_SELECT_BUTTON(self->obj));
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_gradient_select_button_set_gradient(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "gradient_name", NULL };
+    char *gradient_name;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.GradientSelectButton.set_gradient", kwlist, &gradient_name))
+        return NULL;
+    
+    gimp_gradient_select_button_set_gradient(GIMP_GRADIENT_SELECT_BUTTON(self->obj), gradient_name);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpGradientSelectButton_methods[] = {
+    { "get_gradient", (PyCFunction)_wrap_gimp_gradient_select_button_get_gradient, METH_NOARGS,
+      NULL },
+    { "set_gradient", (PyCFunction)_wrap_gimp_gradient_select_button_set_gradient, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpGradientSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.GradientSelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpGradientSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_gradient_select_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpFontSelectButton ----------- */
+
+ static int
+_wrap_gimp_font_select_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[2];
+    PyObject *parsed_args[2] = {NULL, };
+    char *arg_names[] = {"title", "font_name", NULL };
+    char *prop_names[] = {"title", "font-name", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:gimpui.FontSelectButton.__init__" , arg_names , &parsed_args[0] , &parsed_args[1]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*2);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.FontSelectButton object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_font_select_button_get_font(PyGObject *self)
+{
+    const gchar *ret;
+
+    
+    ret = gimp_font_select_button_get_font(GIMP_FONT_SELECT_BUTTON(self->obj));
+    
+    if (ret)
+        return PyString_FromString(ret);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_font_select_button_set_font(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "font_name", NULL };
+    char *font_name;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.FontSelectButton.set_font", kwlist, &font_name))
+        return NULL;
+    
+    gimp_font_select_button_set_font(GIMP_FONT_SELECT_BUTTON(self->obj), font_name);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpFontSelectButton_methods[] = {
+    { "get_font", (PyCFunction)_wrap_gimp_font_select_button_get_font, METH_NOARGS,
+      NULL },
+    { "set_font", (PyCFunction)_wrap_gimp_font_select_button_set_font, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpFontSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.FontSelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpFontSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_font_select_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpBrushSelectButton ----------- */
+
+ static int
+_wrap_gimp_brush_select_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[5];
+    PyObject *parsed_args[5] = {NULL, };
+    char *arg_names[] = {"title", "brush_name", "opacity", "spacing", "paint_mode", NULL };
+    char *prop_names[] = {"title", "brush-name", "brush-opacity", "brush-spacing", "brush-paint-mode", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOOO:gimpui.BrushSelectButton.__init__" , arg_names , &parsed_args[0] , &parsed_args[1] , &parsed_args[2] , &parsed_args[3] , &parsed_args[4]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*5);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.BrushSelectButton object");
+        return -1;
+    }
+    return 0;
+}
+
+#line 914 "gimpui.override"
+static PyObject *
+_wrap_gimp_brush_select_button_get_brush(PyGObject *self)
+{
+    const gchar *brush_name;
+    gdouble opacity;
+    gint spacing;
+    GimpLayerMode paint_mode;
+
+    brush_name =
+        gimp_brush_select_button_get_brush(GIMP_BRUSH_SELECT_BUTTON(self->obj),
+                                           &opacity, &spacing, &paint_mode);
+
+    return Py_BuildValue("(sdiN)", brush_name, opacity, spacing,
+                         pyg_enum_from_gtype(GIMP_TYPE_LAYER_MODE,
+                                             paint_mode));
+}
+#line 7439 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpBrushSelectButton_methods[] = {
+    { "get_brush", (PyCFunction)_wrap_gimp_brush_select_button_get_brush, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpBrushSelectButton_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.BrushSelectButton",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpBrushSelectButton_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_brush_select_button_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpRuler ----------- */
+
+ static int
+_wrap_gimp_ruler_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[4];
+    PyObject *parsed_args[4] = {NULL, };
+    char *arg_names[] = {"orientation", "lower", "upper", "max_size", NULL };
+    char *prop_names[] = {"orientation", "lower", "upper", "max-size", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:gimpui.Ruler.__init__" , arg_names , &parsed_args[0] , &parsed_args[1] , &parsed_args[2] , &parsed_args[3]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*4);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.Ruler object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_ruler_set_unit(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "unit", NULL };
+    int unit;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.Ruler.set_unit", kwlist, &unit))
+        return NULL;
+    
+    gimp_ruler_set_unit(GIMP_RULER(self->obj), unit);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_ruler_get_unit(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_ruler_get_unit(GIMP_RULER(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_gimp_ruler_set_position(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "position", NULL };
+    double position;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Gimp.Ruler.set_position", kwlist, &position))
+        return NULL;
+    
+    gimp_ruler_set_position(GIMP_RULER(self->obj), position);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_ruler_get_position(PyGObject *self)
+{
+    double ret;
+
+    
+    ret = gimp_ruler_get_position(GIMP_RULER(self->obj));
+    
+    return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+_wrap_gimp_ruler_set_range(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "lower", "upper", "max_size", NULL };
+    double lower, upper, max_size;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ddd:Gimp.Ruler.set_range", kwlist, &lower, &upper, &max_size))
+        return NULL;
+    
+    gimp_ruler_set_range(GIMP_RULER(self->obj), lower, upper, max_size);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+#line 1985 "gimpui.override"
+static PyObject *
+_wrap_gimp_ruler_get_range(PyGObject *self)
+{
+    gdouble lower, upper, max_size;
+
+    gimp_ruler_get_range(GIMP_RULER(self->obj), &lower, &upper, &max_size);
+
+    return Py_BuildValue("(ddd)", lower, upper, max_size);
+}
+#line 7604 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpRuler_methods[] = {
+    { "set_unit", (PyCFunction)_wrap_gimp_ruler_set_unit, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_unit", (PyCFunction)_wrap_gimp_ruler_get_unit, METH_NOARGS,
+      NULL },
+    { "set_position", (PyCFunction)_wrap_gimp_ruler_set_position, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_position", (PyCFunction)_wrap_gimp_ruler_get_position, METH_NOARGS,
+      NULL },
+    { "set_range", (PyCFunction)_wrap_gimp_ruler_set_range, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_range", (PyCFunction)_wrap_gimp_ruler_get_range, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpRuler_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.Ruler",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpRuler_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_ruler_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpSizeEntry ----------- */
+
+static int
+_wrap_gimp_size_entry_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "number_of_fields", "unit", "unit_format", "menu_show_pixels", "menu_show_percent", "show_refval", "spinbutton_width", "update_policy", NULL };
+    int number_of_fields, unit, menu_show_pixels, menu_show_percent, show_refval, spinbutton_width;
+    char *unit_format;
+    GimpSizeEntryUpdatePolicy update_policy;
+    PyObject *py_update_policy = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iisiiiiO:Gimp.SizeEntry.__init__", kwlist, &number_of_fields, &unit, &unit_format, &menu_show_pixels, &menu_show_percent, &show_refval, &spinbutton_width, &py_update_policy))
+        return -1;
+    if (pyg_enum_get_value(GIMP_TYPE_SIZE_ENTRY_UPDATE_POLICY, py_update_policy, (gpointer)&update_policy))
+        return -1;
+    self->obj = (GObject *)gimp_size_entry_new(number_of_fields, unit, unit_format, menu_show_pixels, menu_show_percent, show_refval, spinbutton_width, update_policy);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpSizeEntry object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_add_field(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "value_spinbutton", "refval_spinbutton", NULL };
+    PyGObject *value_spinbutton, *refval_spinbutton;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!O!:Gimp.SizeEntry.add_field", kwlist, &PyGtkSpinButton_Type, &value_spinbutton, &PyGtkSpinButton_Type, &refval_spinbutton))
+        return NULL;
+    
+    gimp_size_entry_add_field(GIMP_SIZE_ENTRY(self->obj), GTK_SPIN_BUTTON(value_spinbutton->obj), GTK_SPIN_BUTTON(refval_spinbutton->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_attach_label(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "text", "row", "column", "alignment", NULL };
+    char *text;
+    int row, column;
+    GtkWidget *ret;
+    double alignment;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"siid:Gimp.SizeEntry.attach_label", kwlist, &text, &row, &column, &alignment))
+        return NULL;
+    
+    ret = gimp_size_entry_attach_label(GIMP_SIZE_ENTRY(self->obj), text, row, column, alignment);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_resolution(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "resolution", "keep_size", NULL };
+    int field, keep_size;
+    double resolution;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idi:Gimp.SizeEntry.set_resolution", kwlist, &field, &resolution, &keep_size))
+        return NULL;
+    
+    gimp_size_entry_set_resolution(GIMP_SIZE_ENTRY(self->obj), field, resolution, keep_size);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_size(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "lower", "upper", NULL };
+    int field;
+    double lower, upper;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_size", kwlist, &field, &lower, &upper))
+        return NULL;
+    
+    gimp_size_entry_set_size(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_value_boundaries(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "lower", "upper", NULL };
+    int field;
+    double lower, upper;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_value_boundaries", kwlist, &field, &lower, &upper))
+        return NULL;
+    
+    gimp_size_entry_set_value_boundaries(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_get_value(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", NULL };
+    int field;
+    double ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_value", kwlist, &field))
+        return NULL;
+    
+    ret = gimp_size_entry_get_value(GIMP_SIZE_ENTRY(self->obj), field);
+    
+    return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_value(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "value", NULL };
+    int field;
+    double value;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Gimp.SizeEntry.set_value", kwlist, &field, &value))
+        return NULL;
+    
+    gimp_size_entry_set_value(GIMP_SIZE_ENTRY(self->obj), field, value);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_refval_boundaries(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "lower", "upper", NULL };
+    int field;
+    double lower, upper;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_refval_boundaries", kwlist, &field, &lower, &upper))
+        return NULL;
+    
+    gimp_size_entry_set_refval_boundaries(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_refval_digits(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "digits", NULL };
+    int field, digits;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.SizeEntry.set_refval_digits", kwlist, &field, &digits))
+        return NULL;
+    
+    gimp_size_entry_set_refval_digits(GIMP_SIZE_ENTRY(self->obj), field, digits);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_get_refval(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", NULL };
+    int field;
+    double ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_refval", kwlist, &field))
+        return NULL;
+    
+    ret = gimp_size_entry_get_refval(GIMP_SIZE_ENTRY(self->obj), field);
+    
+    return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_refval(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", "refval", NULL };
+    int field;
+    double refval;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Gimp.SizeEntry.set_refval", kwlist, &field, &refval))
+        return NULL;
+    
+    gimp_size_entry_set_refval(GIMP_SIZE_ENTRY(self->obj), field, refval);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_get_unit(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_size_entry_get_unit(GIMP_SIZE_ENTRY(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_unit(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "unit", NULL };
+    int unit;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.set_unit", kwlist, &unit))
+        return NULL;
+    
+    gimp_size_entry_set_unit(GIMP_SIZE_ENTRY(self->obj), unit);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_show_unit_menu(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "show", NULL };
+    int show;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.show_unit_menu", kwlist, &show))
+        return NULL;
+    
+    gimp_size_entry_show_unit_menu(GIMP_SIZE_ENTRY(self->obj), show);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_pixel_digits(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "digits", NULL };
+    int digits;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.set_pixel_digits", kwlist, &digits))
+        return NULL;
+    
+    gimp_size_entry_set_pixel_digits(GIMP_SIZE_ENTRY(self->obj), digits);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_grab_focus(PyGObject *self)
+{
+    
+    gimp_size_entry_grab_focus(GIMP_SIZE_ENTRY(self->obj));
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_set_activates_default(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "setting", NULL };
+    int setting;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.set_activates_default", kwlist, &setting))
+        return NULL;
+    
+    gimp_size_entry_set_activates_default(GIMP_SIZE_ENTRY(self->obj), setting);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_size_entry_get_help_widget(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "field", NULL };
+    int field;
+    GtkWidget *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_help_widget", kwlist, &field))
+        return NULL;
+    
+    ret = gimp_size_entry_get_help_widget(GIMP_SIZE_ENTRY(self->obj), field);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static const PyMethodDef _PyGimpSizeEntry_methods[] = {
+    { "add_field", (PyCFunction)_wrap_gimp_size_entry_add_field, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "attach_label", (PyCFunction)_wrap_gimp_size_entry_attach_label, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_resolution", (PyCFunction)_wrap_gimp_size_entry_set_resolution, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_size", (PyCFunction)_wrap_gimp_size_entry_set_size, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_value_boundaries", (PyCFunction)_wrap_gimp_size_entry_set_value_boundaries, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_value", (PyCFunction)_wrap_gimp_size_entry_get_value, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_value", (PyCFunction)_wrap_gimp_size_entry_set_value, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_refval_boundaries", (PyCFunction)_wrap_gimp_size_entry_set_refval_boundaries, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_refval_digits", (PyCFunction)_wrap_gimp_size_entry_set_refval_digits, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_refval", (PyCFunction)_wrap_gimp_size_entry_get_refval, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_refval", (PyCFunction)_wrap_gimp_size_entry_set_refval, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_unit", (PyCFunction)_wrap_gimp_size_entry_get_unit, METH_NOARGS,
+      NULL },
+    { "set_unit", (PyCFunction)_wrap_gimp_size_entry_set_unit, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "show_unit_menu", (PyCFunction)_wrap_gimp_size_entry_show_unit_menu, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "set_pixel_digits", (PyCFunction)_wrap_gimp_size_entry_set_pixel_digits, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "grab_focus", (PyCFunction)_wrap_gimp_size_entry_grab_focus, METH_NOARGS,
+      NULL },
+    { "set_activates_default", (PyCFunction)_wrap_gimp_size_entry_set_activates_default, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_help_widget", (PyCFunction)_wrap_gimp_size_entry_get_help_widget, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpSizeEntry_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.SizeEntry",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpSizeEntry_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_size_entry_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpStringComboBox ----------- */
+
+ static int
+_wrap_gimp_string_combo_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GType obj_type = pyg_type_from_object((PyObject *) self);
+    GParameter params[3];
+    PyObject *parsed_args[3] = {NULL, };
+    char *arg_names[] = {"model", "id_column", "label_column", NULL };
+    char *prop_names[] = {"model", "id-column", "label-column", NULL };
+    guint nparams, i;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:gimpui.StringComboBox.__init__" , arg_names , &parsed_args[0] , &parsed_args[1] , &parsed_args[2]))
+        return -1;
+
+    memset(params, 0, sizeof(GParameter)*3);
+    if (!pyg_parse_constructor_args(obj_type, arg_names,
+                                    prop_names, params, 
+                                    &nparams, parsed_args))
+        return -1;
+    pygobject_constructv(self, nparams, params);
+    for (i = 0; i < nparams; ++i)
+        g_value_unset(&params[i].value);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.StringComboBox object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_string_combo_box_set_active(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "id", NULL };
+    char *id;
+    int ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.StringComboBox.set_active", kwlist, &id))
+        return NULL;
+    
+    ret = gimp_string_combo_box_set_active(GIMP_STRING_COMBO_BOX(self->obj), id);
+    
+    return PyBool_FromLong(ret);
+
+}
+
+static PyObject *
+_wrap_gimp_string_combo_box_get_active(PyGObject *self)
+{
+    gchar *ret;
+
+    
+    ret = gimp_string_combo_box_get_active(GIMP_STRING_COMBO_BOX(self->obj));
+    
+    if (ret) {
+        PyObject *py_ret = PyString_FromString(ret);
+        g_free(ret);
+        return py_ret;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpStringComboBox_methods[] = {
+    { "set_active", (PyCFunction)_wrap_gimp_string_combo_box_set_active, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_active", (PyCFunction)_wrap_gimp_string_combo_box_get_active, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpStringComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.StringComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpStringComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_string_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpUnitComboBox ----------- */
+
+ static int
+_wrap_gimp_unit_combo_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.UnitComboBox.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.UnitComboBox object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_unit_combo_box_get_active(PyGObject *self)
+{
+    int ret;
+
+    
+    ret = gimp_unit_combo_box_get_active(GIMP_UNIT_COMBO_BOX(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_gimp_unit_combo_box_set_active(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "unit", NULL };
+    int unit;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.UnitComboBox.set_active", kwlist, &unit))
+        return NULL;
+    
+    gimp_unit_combo_box_set_active(GIMP_UNIT_COMBO_BOX(self->obj), unit);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static const PyMethodDef _PyGimpUnitComboBox_methods[] = {
+    { "get_active", (PyCFunction)_wrap_gimp_unit_combo_box_get_active, METH_NOARGS,
+      NULL },
+    { "set_active", (PyCFunction)_wrap_gimp_unit_combo_box_set_active, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpUnitComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.UnitComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpUnitComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_unit_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpUnitMenu ----------- */
+
+static int
+_wrap_gimp_unit_menu_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "format", "unit", "show_pixels", "show_percent", "show_custom", NULL };
+    char *format;
+    int unit, show_pixels, show_percent, show_custom;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"siiii:Gimp.UnitMenu.__init__", kwlist, &format, &unit, &show_pixels, &show_percent, &show_custom))
+        return -1;
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimpui.UnitComboBox instead") < 0)
+        return -1;
+    self->obj = (GObject *)gimp_unit_menu_new(format, unit, show_pixels, show_percent, show_custom);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpUnitMenu object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_unit_menu_set_unit(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "unit", NULL };
+    int unit;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.UnitMenu.set_unit", kwlist, &unit))
+        return NULL;
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimpui.UnitComboBox instead") < 0)
+        return NULL;
+    
+    gimp_unit_menu_set_unit(GIMP_UNIT_MENU(self->obj), unit);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_unit_menu_get_unit(PyGObject *self)
+{
+    int ret;
+
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimpui.UnitComboBox instead") < 0)
+        return NULL;
+    
+    ret = gimp_unit_menu_get_unit(GIMP_UNIT_MENU(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static PyObject *
+_wrap_gimp_unit_menu_set_pixel_digits(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "digits", NULL };
+    int digits;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.UnitMenu.set_pixel_digits", kwlist, &digits))
+        return NULL;
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimpui.UnitComboBox instead") < 0)
+        return NULL;
+    
+    gimp_unit_menu_set_pixel_digits(GIMP_UNIT_MENU(self->obj), digits);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_unit_menu_get_pixel_digits(PyGObject *self)
+{
+    int ret;
+
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gimpui.UnitComboBox instead") < 0)
+        return NULL;
+    
+    ret = gimp_unit_menu_get_pixel_digits(GIMP_UNIT_MENU(self->obj));
+    
+    return PyInt_FromLong(ret);
+}
+
+static const PyMethodDef _PyGimpUnitMenu_methods[] = {
+    { "set_unit", (PyCFunction)_wrap_gimp_unit_menu_set_unit, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_unit", (PyCFunction)_wrap_gimp_unit_menu_get_unit, METH_NOARGS,
+      NULL },
+    { "set_pixel_digits", (PyCFunction)_wrap_gimp_unit_menu_set_pixel_digits, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_pixel_digits", (PyCFunction)_wrap_gimp_unit_menu_get_pixel_digits, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpUnitMenu_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.UnitMenu",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpUnitMenu_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_unit_menu_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpVectorsComboBox ----------- */
+
+#line 479 "gimpui.override"
+static gboolean
+pygimp_vectors_constraint_marshal(gint32 image_id, gint32 vectors_id,
+                                  gpointer user_data)
+{
+    PyObject *img, *vect, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    vect = pygimp_vectors_new(vectors_id);
+    if (!vect) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, vect,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, vect, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(vect);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_vectors_combo_box_new(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpVectorsConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.VectorsComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_vectors_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_vectors_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_VECTORS_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.VectorsComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+#line 8510 "gimpui.c"
+
+
+#line 596 "gimpui.override"
+static PyObject *
+_wrap_gimp_vectors_combo_box_get_active_vectors(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_vectors_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 8525 "gimpui.c"
+
+
+#line 570 "gimpui.override"
+static PyObject *
+_wrap_gimp_vectors_combo_box_set_active_vectors(PyGObject *self, PyObject *args,
+                                                PyObject *kwargs)
+{
+    PyGimpVectors *vect;
+
+    static char *kwlist[] = { "vectors", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                   "O!:GimpVectorsComboBox.set_active_vectors",
+                                   kwlist,
+                                   PyGimpVectors_Type, &vect))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), vect->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Vectors (ID %d) does not exist in GimpVectorsComboBox",
+                     vect->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#line 8553 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpVectorsComboBox_methods[] = {
+    { "get_active_vectors", (PyCFunction)_wrap_gimp_vectors_combo_box_get_active_vectors, METH_NOARGS,
+      NULL },
+    { "set_active_vectors", (PyCFunction)_wrap_gimp_vectors_combo_box_set_active_vectors, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpVectorsComboBox_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.VectorsComboBox",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpVectorsComboBox_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_vectors_combo_box_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpZoomModel ----------- */
+
+static int
+_wrap_gimp_zoom_model_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char* kwlist[] = { NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     ":gimpui.ZoomModel.__init__",
+                                     kwlist))
+        return -1;
+
+    pygobject_constructv(self, 0, NULL);
+    if (!self->obj) {
+        PyErr_SetString(
+            PyExc_RuntimeError, 
+            "could not create gimpui.ZoomModel object");
+        return -1;
+    }
+    return 0;
+}
+
+static PyObject *
+_wrap_gimp_zoom_model_set_range(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "min", "max", NULL };
+    double min, max;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.ZoomModel.set_range", kwlist, &min, &max))
+        return NULL;
+    
+    gimp_zoom_model_set_range(GIMP_ZOOM_MODEL(self->obj), min, max);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_zoom_model_zoom(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "zoom_type", "scale", NULL };
+    PyObject *py_zoom_type = NULL;
+    double scale;
+    GimpZoomType zoom_type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Od:Gimp.ZoomModel.zoom", kwlist, &py_zoom_type, &scale))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_ZOOM_TYPE, py_zoom_type, (gpointer)&zoom_type))
+        return NULL;
+    
+    gimp_zoom_model_zoom(GIMP_ZOOM_MODEL(self->obj), zoom_type, scale);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+_wrap_gimp_zoom_model_get_factor(PyGObject *self)
+{
+    double ret;
+
+    
+    ret = gimp_zoom_model_get_factor(GIMP_ZOOM_MODEL(self->obj));
+    
+    return PyFloat_FromDouble(ret);
+}
+
+#line 1669 "gimpui.override"
+static PyObject *
+_wrap_gimp_zoom_model_get_fraction(PyGObject *self)
+{
+    gint numerator;
+    gint denominator;
+
+    gimp_zoom_model_get_fraction(GIMP_ZOOM_MODEL(self->obj), &numerator,
+                                 &denominator);
+
+    return Py_BuildValue("(ii)", numerator, denominator);
+}
+#line 8690 "gimpui.c"
+
+
+static const PyMethodDef _PyGimpZoomModel_methods[] = {
+    { "set_range", (PyCFunction)_wrap_gimp_zoom_model_set_range, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "zoom", (PyCFunction)_wrap_gimp_zoom_model_zoom, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "get_factor", (PyCFunction)_wrap_gimp_zoom_model_get_factor, METH_NOARGS,
+      NULL },
+    { "get_fraction", (PyCFunction)_wrap_gimp_zoom_model_get_fraction, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpZoomModel_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ZoomModel",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpZoomModel_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_zoom_model_new,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpZoomPreview ----------- */
+
+#line 1891 "gimpui.override"
+static int
+_wrap_gimp_zoom_preview_new_with_model(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", "model", NULL };
+    PyGimpDrawable *py_drawable;
+    PyGObject *py_zoom_model = NULL;
+    GimpZoomModel *zoom_model;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|O!:GimpZoomPreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable,
+                                     &PyGimpZoomModel_Type, &py_zoom_model))
+        return -1;
+
+    if (py_zoom_model)
+        zoom_model = (GimpZoomModel*)py_zoom_model->obj;
+    else
+        zoom_model = NULL;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, "model", zoom_model, NULL))
+        return -1;
+
+    g_object_set_data_full(self->obj, "pygimp-zoom-preview-pydrawable",
+                           py_drawable,
+                           (GDestroyNotify)pygimp_decref_callback);
+
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+#line 8788 "gimpui.c"
+
+
+#line 2040 "gimpui.override"
+static PyObject *
+_wrap_gimp_zoom_preview_get_source(PyGObject *self)
+{
+  gint width, height, bpp;
+  guchar *image;
+  PyObject *pyimage;
+
+  image = gimp_zoom_preview_get_source(GIMP_ZOOM_PREVIEW(self->obj),
+                                       &width, &height, &bpp);
+
+  if (image)
+    {
+      pyimage = PyByteArray_FromStringAndSize((const char *)image,
+                                              width * height * bpp);
+      g_free (image);
+    }
+  else
+    {
+      Py_INCREF(Py_None);
+      pyimage = Py_None;
+    }
+
+  return Py_BuildValue("(Niii)", pyimage, width, height, bpp);
+}
+#line 8816 "gimpui.c"
+
+
+#line 1694 "gimpui.override"
+static PyObject *
+_wrap_gimp_zoom_preview_get_drawable(PyGObject *self)
+{
+    PyObject *drawable;
+    
+    drawable = g_object_get_data(self->obj,
+                                 "pygimp-zoom-preview-pydrawable");
+    Py_INCREF(drawable);
+    return drawable;
+}
+#line 8830 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_zoom_preview_get_model(PyGObject *self)
+{
+    GimpZoomModel *ret;
+
+    
+    ret = gimp_zoom_preview_get_model(GIMP_ZOOM_PREVIEW(self->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_zoom_preview_get_factor(PyGObject *self)
+{
+    double ret;
+
+    
+    ret = gimp_zoom_preview_get_factor(GIMP_ZOOM_PREVIEW(self->obj));
+    
+    return PyFloat_FromDouble(ret);
+}
+
+static const PyMethodDef _PyGimpZoomPreview_methods[] = {
+    { "get_source", (PyCFunction)_wrap_gimp_zoom_preview_get_source, METH_NOARGS,
+      NULL },
+    { "get_drawable", (PyCFunction)_wrap_gimp_zoom_preview_get_drawable, METH_NOARGS,
+      NULL },
+    { "get_model", (PyCFunction)_wrap_gimp_zoom_preview_get_model, METH_NOARGS,
+      NULL },
+    { "get_factor", (PyCFunction)_wrap_gimp_zoom_preview_get_factor, METH_NOARGS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject G_GNUC_INTERNAL PyGimpZoomPreview_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ZoomPreview",                   /* tp_name */
+    sizeof(PyGObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)_PyGimpZoomPreview_methods, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
+    (initproc)_wrap_gimp_zoom_preview_new_with_model,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- GimpColorManaged ----------- */
+
+PyTypeObject G_GNUC_INTERNAL PyGimpColorManaged_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "gimpui.ColorManaged",                   /* tp_name */
+    sizeof(PyObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    /* methods */
+    (destructor)0,        /* tp_dealloc */
+    (printfunc)0,                      /* tp_print */
+    (getattrfunc)0,       /* tp_getattr */
+    (setattrfunc)0,       /* tp_setattr */
+    (cmpfunc)0,           /* tp_compare */
+    (reprfunc)0,             /* tp_repr */
+    (PyNumberMethods*)0,     /* tp_as_number */
+    (PySequenceMethods*)0, /* tp_as_sequence */
+    (PyMappingMethods*)0,   /* tp_as_mapping */
+    (hashfunc)0,             /* tp_hash */
+    (ternaryfunc)0,          /* tp_call */
+    (reprfunc)0,              /* tp_str */
+    (getattrofunc)0,     /* tp_getattro */
+    (setattrofunc)0,     /* tp_setattro */
+    (PyBufferProcs*)0,  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
+    NULL,                        /* Documentation string */
+    (traverseproc)0,     /* tp_traverse */
+    (inquiry)0,             /* tp_clear */
+    (richcmpfunc)0,   /* tp_richcompare */
+    0,             /* tp_weaklistoffset */
+    (getiterfunc)0,          /* tp_iter */
+    (iternextfunc)0,     /* tp_iternext */
+    (struct PyMethodDef*)NULL, /* tp_methods */
+    (struct PyMemberDef*)0,              /* tp_members */
+    (struct PyGetSetDef*)0,  /* tp_getset */
+    NULL,                              /* tp_base */
+    NULL,                              /* tp_dict */
+    (descrgetfunc)0,    /* tp_descr_get */
+    (descrsetfunc)0,    /* tp_descr_set */
+    0,                 /* tp_dictoffset */
+    (initproc)0,             /* tp_init */
+    (allocfunc)0,           /* tp_alloc */
+    (newfunc)0,               /* tp_new */
+    (freefunc)0,             /* tp_free */
+    (inquiry)0              /* tp_is_gc */
+};
+
+
+
+/* ----------- functions ----------- */
+
+#line 2066 "gimpui.override"
+static PyObject *
+_wrap_gimp_ui_init(PyObject *self)
+{
+  extern const char *prog_name;
+
+  gimp_ui_init (prog_name, FALSE);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+#line 8977 "gimpui.c"
+
+
+static PyObject *
+_wrap_gimp_enum_combo_box_new_with_model(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enum_store", NULL };
+    PyGObject *enum_store;
+    GtkWidget *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:gimp_enum_combo_box_new_with_model", kwlist, &PyGimpEnumStore_Type, &enum_store))
+        return NULL;
+    
+    ret = gimp_enum_combo_box_new_with_model(GIMP_ENUM_STORE(enum_store->obj));
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_enum_store_new_with_range(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enum_type", "minimum", "maximum", NULL };
+    PyObject *py_enum_type = NULL;
+    int minimum, maximum;
+    GType enum_type;
+    GtkListStore *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oii:gimp_enum_store_new_with_range", kwlist, &py_enum_type, &minimum, &maximum))
+        return NULL;
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return NULL;
+    
+    ret = gimp_enum_store_new_with_range(enum_type, minimum, maximum);
+    
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+
+static PyObject *
+_wrap_gimp_zoom_model_zoom_step(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "zoom_type", "scale", NULL };
+    PyObject *py_zoom_type = NULL;
+    double scale, ret;
+    GimpZoomType zoom_type;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Od:gimp_zoom_model_zoom_step", kwlist, &py_zoom_type, &scale))
+        return NULL;
+    if (pyg_enum_get_value(GIMP_TYPE_ZOOM_TYPE, py_zoom_type, (gpointer)&zoom_type))
+        return NULL;
+    
+    ret = gimp_zoom_model_zoom_step(zoom_type, scale);
+    
+    return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+_wrap_gimp_pattern_select_destroy(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "pattern_callback", NULL };
+    char *pattern_callback;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:gimp_pattern_select_destroy", kwlist, &pattern_callback))
+        return NULL;
+    
+    gimp_pattern_select_destroy(pattern_callback);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+const PyMethodDef gimpui_functions[] = {
+    { "gimp_ui_init", (PyCFunction)_wrap_gimp_ui_init, METH_NOARGS,
+      NULL },
+    { "gimp_enum_combo_box_new_with_model", (PyCFunction)_wrap_gimp_enum_combo_box_new_with_model, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "gimp_enum_store_new_with_range", (PyCFunction)_wrap_gimp_enum_store_new_with_range, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "gimp_zoom_model_zoom_step", (PyCFunction)_wrap_gimp_zoom_model_zoom_step, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { "gimp_pattern_select_destroy", (PyCFunction)_wrap_gimp_pattern_select_destroy, METH_VARARGS|METH_KEYWORDS,
+      NULL },
+    { NULL, NULL, 0, NULL }
+};
+
+
+/* ----------- enums and flags ----------- */
+
+void
+gimpui_add_constants(PyObject *module, const gchar *strip_prefix)
+{
+#ifdef VERSION
+    PyModule_AddStringConstant(module, "__version__", VERSION);
+#endif
+  pyg_enum_add(module, "AspectType", strip_prefix, GIMP_TYPE_ASPECT_TYPE);
+  pyg_enum_add(module, "ChainPosition", strip_prefix, GIMP_TYPE_CHAIN_POSITION);
+  pyg_enum_add(module, "ColorAreaType", strip_prefix, GIMP_TYPE_COLOR_AREA_TYPE);
+  pyg_enum_add(module, "ColorSelectorChannel", strip_prefix, GIMP_TYPE_COLOR_SELECTOR_CHANNEL);
+  pyg_enum_add(module, "PageSelectorTarget", strip_prefix, GIMP_TYPE_PAGE_SELECTOR_TARGET);
+  pyg_enum_add(module, "SizeEntryUpdatePolicy", strip_prefix, GIMP_TYPE_SIZE_ENTRY_UPDATE_POLICY);
+    PyModule_AddIntConstant(module, (char *) pyg_constant_strip_prefix("GIMP_UNIT_PIXEL", strip_prefix), GIMP_UNIT_PIXEL);
+    PyModule_AddIntConstant(module, (char *) pyg_constant_strip_prefix("GIMP_UNIT_INCH", strip_prefix), GIMP_UNIT_INCH);
+    PyModule_AddIntConstant(module, (char *) pyg_constant_strip_prefix("GIMP_UNIT_MM", strip_prefix), GIMP_UNIT_MM);
+    PyModule_AddIntConstant(module, (char *) pyg_constant_strip_prefix("GIMP_UNIT_POINT", strip_prefix), GIMP_UNIT_POINT);
+    PyModule_AddIntConstant(module, (char *) pyg_constant_strip_prefix("GIMP_UNIT_PICA", strip_prefix), GIMP_UNIT_PICA);
+  pyg_enum_add(module, "ZoomType", strip_prefix, GIMP_TYPE_ZOOM_TYPE);
+
+  if (PyErr_Occurred())
+    PyErr_Print();
+}
+
+/* initialise stuff extension classes */
+void
+gimpui_register_classes(PyObject *d)
+{
+    PyObject *module;
+
+    if ((module = PyImport_ImportModule("gobject")) != NULL) {
+        _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
+        if (_PyGObject_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name GObject from gobject");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gobject");
+        return ;
+    }
+    if ((module = PyImport_ImportModule("gtk")) != NULL) {
+        _PyGtkObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Object");
+        if (_PyGtkObject_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Object from gtk");
+            return ;
+        }
+        _PyGtkWidget_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Widget");
+        if (_PyGtkWidget_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Widget from gtk");
+            return ;
+        }
+        _PyGtkDialog_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Dialog");
+        if (_PyGtkDialog_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Dialog from gtk");
+            return ;
+        }
+        _PyGtkWindow_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Window");
+        if (_PyGtkWindow_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Window from gtk");
+            return ;
+        }
+        _PyGtkLabel_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Label");
+        if (_PyGtkLabel_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Label from gtk");
+            return ;
+        }
+        _PyGtkButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Button");
+        if (_PyGtkButton_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Button from gtk");
+            return ;
+        }
+        _PyGtkToggleButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ToggleButton");
+        if (_PyGtkToggleButton_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name ToggleButton from gtk");
+            return ;
+        }
+        _PyGtkRadioButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "RadioButton");
+        if (_PyGtkRadioButton_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name RadioButton from gtk");
+            return ;
+        }
+        _PyGtkSpinButton_Type = (PyTypeObject *)PyObject_GetAttrString(module, "SpinButton");
+        if (_PyGtkSpinButton_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name SpinButton from gtk");
+            return ;
+        }
+        _PyGtkEntry_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Entry");
+        if (_PyGtkEntry_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Entry from gtk");
+            return ;
+        }
+        _PyGtkDrawingArea_Type = (PyTypeObject *)PyObject_GetAttrString(module, "DrawingArea");
+        if (_PyGtkDrawingArea_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name DrawingArea from gtk");
+            return ;
+        }
+        _PyGtkTable_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Table");
+        if (_PyGtkTable_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Table from gtk");
+            return ;
+        }
+        _PyGtkFrame_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Frame");
+        if (_PyGtkFrame_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Frame from gtk");
+            return ;
+        }
+        _PyGtkHBox_Type = (PyTypeObject *)PyObject_GetAttrString(module, "HBox");
+        if (_PyGtkHBox_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name HBox from gtk");
+            return ;
+        }
+        _PyGtkVBox_Type = (PyTypeObject *)PyObject_GetAttrString(module, "VBox");
+        if (_PyGtkVBox_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name VBox from gtk");
+            return ;
+        }
+        _PyGtkHPaned_Type = (PyTypeObject *)PyObject_GetAttrString(module, "HPaned");
+        if (_PyGtkHPaned_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name HPaned from gtk");
+            return ;
+        }
+        _PyGtkVPaned_Type = (PyTypeObject *)PyObject_GetAttrString(module, "VPaned");
+        if (_PyGtkVPaned_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name VPaned from gtk");
+            return ;
+        }
+        _PyGtkScale_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Scale");
+        if (_PyGtkScale_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Scale from gtk");
+            return ;
+        }
+        _PyGtkProgressBar_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ProgressBar");
+        if (_PyGtkProgressBar_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name ProgressBar from gtk");
+            return ;
+        }
+        _PyGtkOptionMenu_Type = (PyTypeObject *)PyObject_GetAttrString(module, "OptionMenu");
+        if (_PyGtkOptionMenu_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name OptionMenu from gtk");
+            return ;
+        }
+        _PyGtkComboBox_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ComboBox");
+        if (_PyGtkComboBox_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name ComboBox from gtk");
+            return ;
+        }
+        _PyGtkListStore_Type = (PyTypeObject *)PyObject_GetAttrString(module, "ListStore");
+        if (_PyGtkListStore_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name ListStore from gtk");
+            return ;
+        }
+        _PyGtkTreeModel_Type = (PyTypeObject *)PyObject_GetAttrString(module, "TreeModel");
+        if (_PyGtkTreeModel_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name TreeModel from gtk");
+            return ;
+        }
+        _PyGtkCellRenderer_Type = (PyTypeObject *)PyObject_GetAttrString(module, "CellRenderer");
+        if (_PyGtkCellRenderer_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name CellRenderer from gtk");
+            return ;
+        }
+        _PyGtkCellRendererToggle_Type = (PyTypeObject *)PyObject_GetAttrString(module, "CellRendererToggle");
+        if (_PyGtkCellRendererToggle_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name CellRendererToggle from gtk");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gtk");
+        return ;
+    }
+    if ((module = PyImport_ImportModule("gtk.gdk")) != NULL) {
+        _PyGdkPixbuf_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Pixbuf");
+        if (_PyGdkPixbuf_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Pixbuf from gtk.gdk");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gtk.gdk");
+        return ;
+    }
+    if ((module = PyImport_ImportModule("gimp")) != NULL) {
+        _PyGimpParasite_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Parasite");
+        if (_PyGimpParasite_Type == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                "cannot import name Parasite from gimp");
+            return ;
+        }
+    } else {
+        PyErr_SetString(PyExc_ImportError,
+            "could not import gimp");
+        return ;
+    }
+
+
+#line 9289 "gimpui.c"
+    pyg_register_interface(d, "ColorManaged", GIMP_TYPE_COLOR_MANAGED, &PyGimpColorManaged_Type);
+    pygobject_register_class(d, "GimpBrowser", GIMP_TYPE_BROWSER, &PyGimpBrowser_Type, Py_BuildValue("(O)", &PyGtkHPaned_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_BROWSER);
+    pygobject_register_class(d, "GimpButton", GIMP_TYPE_BUTTON, &PyGimpButton_Type, Py_BuildValue("(O)", &PyGtkButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_BUTTON);
+    pygobject_register_class(d, "GimpCellRendererColor", GIMP_TYPE_CELL_RENDERER_COLOR, &PyGimpCellRendererColor_Type, Py_BuildValue("(O)", &PyGtkCellRenderer_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_CELL_RENDERER_COLOR);
+    pygobject_register_class(d, "GimpCellRendererToggle", GIMP_TYPE_CELL_RENDERER_TOGGLE, &PyGimpCellRendererToggle_Type, Py_BuildValue("(O)", &PyGtkCellRendererToggle_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_CELL_RENDERER_TOGGLE);
+    pygobject_register_class(d, "GimpChainButton", GIMP_TYPE_CHAIN_BUTTON, &PyGimpChainButton_Type, Py_BuildValue("(O)", &PyGtkTable_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_CHAIN_BUTTON);
+    pygobject_register_class(d, "GimpColorArea", GIMP_TYPE_COLOR_AREA, &PyGimpColorArea_Type, Py_BuildValue("(O)", &PyGtkDrawingArea_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_AREA);
+    pygobject_register_class(d, "GimpColorButton", GIMP_TYPE_COLOR_BUTTON, &PyGimpColorButton_Type, Py_BuildValue("(O)", &PyGimpButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_BUTTON);
+    pygobject_register_class(d, "GimpColorConfig", GIMP_TYPE_COLOR_CONFIG, &PyGimpColorConfig_Type, Py_BuildValue("(O)", &PyGObject_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_CONFIG);
+    pygobject_register_class(d, "GimpColorDisplay", GIMP_TYPE_COLOR_DISPLAY, &PyGimpColorDisplay_Type, Py_BuildValue("(O)", &PyGObject_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_DISPLAY);
+    pygobject_register_class(d, "GimpColorDisplayStack", GIMP_TYPE_COLOR_DISPLAY_STACK, &PyGimpColorDisplayStack_Type, Py_BuildValue("(O)", &PyGObject_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_DISPLAY_STACK);
+    pygobject_register_class(d, "GimpColorHexEntry", GIMP_TYPE_COLOR_HEX_ENTRY, &PyGimpColorHexEntry_Type, Py_BuildValue("(O)", &PyGtkEntry_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_HEX_ENTRY);
+    pygobject_register_class(d, "GimpColorProfileComboBox", GIMP_TYPE_COLOR_PROFILE_COMBO_BOX, &PyGimpColorProfileComboBox_Type, Py_BuildValue("(O)", &PyGtkComboBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_PROFILE_COMBO_BOX);
+    pygobject_register_class(d, "GimpColorProfileStore", GIMP_TYPE_COLOR_PROFILE_STORE, &PyGimpColorProfileStore_Type, Py_BuildValue("(O)", &PyGtkListStore_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_PROFILE_STORE);
+    pygobject_register_class(d, "GimpColorScale", GIMP_TYPE_COLOR_SCALE, &PyGimpColorScale_Type, Py_BuildValue("(O)", &PyGtkScale_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_SCALE);
+    pygobject_register_class(d, "GimpColorSelection", GIMP_TYPE_COLOR_SELECTION, &PyGimpColorSelection_Type, Py_BuildValue("(O)", &PyGtkVBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_COLOR_SELECTION);
+    pygobject_register_class(d, "GimpColorSelector", GIMP_TYPE_COLOR_SELECTOR, &PyGimpColorSelector_Type, Py_BuildValue("(O)", &PyGtkVBox_Type));
+    pygobject_register_class(d, "GimpColorScales", GIMP_TYPE_COLOR_SCALES, &PyGimpColorScales_Type, Py_BuildValue("(O)", &PyGimpColorSelector_Type));
+    pygobject_register_class(d, "GimpColorNotebook", GIMP_TYPE_COLOR_NOTEBOOK, &PyGimpColorNotebook_Type, Py_BuildValue("(O)", &PyGimpColorSelector_Type));
+    pygobject_register_class(d, "GimpDialog", GIMP_TYPE_DIALOG, &PyGimpDialog_Type, Py_BuildValue("(O)", &PyGtkDialog_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_DIALOG);
+    pygobject_register_class(d, "GimpEnumLabel", GIMP_TYPE_ENUM_LABEL, &PyGimpEnumLabel_Type, Py_BuildValue("(O)", &PyGtkLabel_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_ENUM_LABEL);
+    pygobject_register_class(d, "GimpFrame", GIMP_TYPE_FRAME, &PyGimpFrame_Type, Py_BuildValue("(O)", &PyGtkFrame_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_FRAME);
+    pygobject_register_class(d, "GimpHintBox", GIMP_TYPE_HINT_BOX, &PyGimpHintBox_Type, Py_BuildValue("(O)", &PyGtkHBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_HINT_BOX);
+    pygobject_register_class(d, "GimpIntComboBox", GIMP_TYPE_INT_COMBO_BOX, &PyGimpIntComboBox_Type, Py_BuildValue("(O)", &PyGtkComboBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_INT_COMBO_BOX);
+    pygobject_register_class(d, "GimpImageComboBox", GIMP_TYPE_IMAGE_COMBO_BOX, &PyGimpImageComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpEnumComboBox", GIMP_TYPE_ENUM_COMBO_BOX, &PyGimpEnumComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpDrawableComboBox", GIMP_TYPE_DRAWABLE_COMBO_BOX, &PyGimpDrawableComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpChannelComboBox", GIMP_TYPE_CHANNEL_COMBO_BOX, &PyGimpChannelComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpIntStore", GIMP_TYPE_INT_STORE, &PyGimpIntStore_Type, Py_BuildValue("(O)", &PyGtkListStore_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_INT_STORE);
+    pygobject_register_class(d, "GimpEnumStore", GIMP_TYPE_ENUM_STORE, &PyGimpEnumStore_Type, Py_BuildValue("(O)", &PyGimpIntStore_Type));
+    pygobject_register_class(d, "GimpLayerComboBox", GIMP_TYPE_LAYER_COMBO_BOX, &PyGimpLayerComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpMemsizeEntry", GIMP_TYPE_MEMSIZE_ENTRY, &PyGimpMemsizeEntry_Type, Py_BuildValue("(O)", &PyGtkHBox_Type));
+    pygobject_register_class(d, "GimpNumberPairEntry", GIMP_TYPE_NUMBER_PAIR_ENTRY, &PyGimpNumberPairEntry_Type, Py_BuildValue("(O)", &PyGtkEntry_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_NUMBER_PAIR_ENTRY);
+    pygobject_register_class(d, "GimpOffsetArea", GIMP_TYPE_OFFSET_AREA, &PyGimpOffsetArea_Type, Py_BuildValue("(O)", &PyGtkDrawingArea_Type));
+    pygobject_register_class(d, "GimpPageSelector", GIMP_TYPE_PAGE_SELECTOR, &PyGimpPageSelector_Type, Py_BuildValue("(O)", &PyGtkVBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PAGE_SELECTOR);
+    pygobject_register_class(d, "GimpPathEditor", GIMP_TYPE_PATH_EDITOR, &PyGimpPathEditor_Type, Py_BuildValue("(O)", &PyGtkVBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PATH_EDITOR);
+    pygobject_register_class(d, "GimpPickButton", GIMP_TYPE_PICK_BUTTON, &PyGimpPickButton_Type, Py_BuildValue("(O)", &PyGtkButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PICK_BUTTON);
+    pygobject_register_class(d, "GimpPreview", GIMP_TYPE_PREVIEW, &PyGimpPreview_Type, Py_BuildValue("(O)", &PyGtkVBox_Type));
+    pygobject_register_class(d, "GimpAspectPreview", GIMP_TYPE_ASPECT_PREVIEW, &PyGimpAspectPreview_Type, Py_BuildValue("(O)", &PyGimpPreview_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_ASPECT_PREVIEW);
+    pygobject_register_class(d, "GimpPreviewArea", GIMP_TYPE_PREVIEW_AREA, &PyGimpPreviewArea_Type, Py_BuildValue("(O)", &PyGtkDrawingArea_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PREVIEW_AREA);
+    pygobject_register_class(d, "GimpProcBrowserDialog", GIMP_TYPE_PROC_BROWSER_DIALOG, &PyGimpProcBrowserDialog_Type, Py_BuildValue("(O)", &PyGimpDialog_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PROC_BROWSER_DIALOG);
+    pygobject_register_class(d, "GimpProgressBar", GIMP_TYPE_PROGRESS_BAR, &PyGimpProgressBar_Type, Py_BuildValue("(O)", &PyGtkProgressBar_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PROGRESS_BAR);
+    pygobject_register_class(d, "GimpScrolledPreview", GIMP_TYPE_SCROLLED_PREVIEW, &PyGimpScrolledPreview_Type, Py_BuildValue("(O)", &PyGimpPreview_Type));
+    pygobject_register_class(d, "GimpDrawablePreview", GIMP_TYPE_DRAWABLE_PREVIEW, &PyGimpDrawablePreview_Type, Py_BuildValue("(O)", &PyGimpScrolledPreview_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_DRAWABLE_PREVIEW);
+    pygobject_register_class(d, "GimpSelectButton", GIMP_TYPE_SELECT_BUTTON, &PyGimpSelectButton_Type, Py_BuildValue("(O)", &PyGtkHBox_Type));
+    pygobject_register_class(d, "GimpPatternSelectButton", GIMP_TYPE_PATTERN_SELECT_BUTTON, &PyGimpPatternSelectButton_Type, Py_BuildValue("(O)", &PyGimpSelectButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PATTERN_SELECT_BUTTON);
+    pygobject_register_class(d, "GimpPaletteSelectButton", GIMP_TYPE_PALETTE_SELECT_BUTTON, &PyGimpPaletteSelectButton_Type, Py_BuildValue("(O)", &PyGimpSelectButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_PALETTE_SELECT_BUTTON);
+    pygobject_register_class(d, "GimpGradientSelectButton", GIMP_TYPE_GRADIENT_SELECT_BUTTON, &PyGimpGradientSelectButton_Type, Py_BuildValue("(O)", &PyGimpSelectButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_GRADIENT_SELECT_BUTTON);
+    pygobject_register_class(d, "GimpFontSelectButton", GIMP_TYPE_FONT_SELECT_BUTTON, &PyGimpFontSelectButton_Type, Py_BuildValue("(O)", &PyGimpSelectButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_FONT_SELECT_BUTTON);
+    pygobject_register_class(d, "GimpBrushSelectButton", GIMP_TYPE_BRUSH_SELECT_BUTTON, &PyGimpBrushSelectButton_Type, Py_BuildValue("(O)", &PyGimpSelectButton_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_BRUSH_SELECT_BUTTON);
+    pygobject_register_class(d, "GimpRuler", GIMP_TYPE_RULER, &PyGimpRuler_Type, Py_BuildValue("(O)", &PyGtkWidget_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_RULER);
+    pygobject_register_class(d, "GimpSizeEntry", GIMP_TYPE_SIZE_ENTRY, &PyGimpSizeEntry_Type, Py_BuildValue("(O)", &PyGtkTable_Type));
+    pygobject_register_class(d, "GimpStringComboBox", GIMP_TYPE_STRING_COMBO_BOX, &PyGimpStringComboBox_Type, Py_BuildValue("(O)", &PyGtkComboBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_STRING_COMBO_BOX);
+    pygobject_register_class(d, "GimpUnitComboBox", GIMP_TYPE_UNIT_COMBO_BOX, &PyGimpUnitComboBox_Type, Py_BuildValue("(O)", &PyGtkComboBox_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_UNIT_COMBO_BOX);
+    pygobject_register_class(d, "GimpUnitMenu", GIMP_TYPE_UNIT_MENU, &PyGimpUnitMenu_Type, Py_BuildValue("(O)", &PyGtkOptionMenu_Type));
+    pygobject_register_class(d, "GimpVectorsComboBox", GIMP_TYPE_VECTORS_COMBO_BOX, &PyGimpVectorsComboBox_Type, Py_BuildValue("(O)", &PyGimpIntComboBox_Type));
+    pygobject_register_class(d, "GimpZoomModel", GIMP_TYPE_ZOOM_MODEL, &PyGimpZoomModel_Type, Py_BuildValue("(O)", &PyGObject_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_ZOOM_MODEL);
+    pygobject_register_class(d, "GimpZoomPreview", GIMP_TYPE_ZOOM_PREVIEW, &PyGimpZoomPreview_Type, Py_BuildValue("(O)", &PyGimpScrolledPreview_Type));
+    pyg_set_object_has_new_constructor(GIMP_TYPE_ZOOM_PREVIEW);
+}
diff --git a/plug-ins/pygimp/gimpui.defs b/plug-ins/pygimp/gimpui.defs
new file mode 100644
index 0000000..1540534
--- /dev/null
+++ b/plug-ins/pygimp/gimpui.defs
@@ -0,0 +1,3411 @@
+;; -*- scheme -*-
+; object definitions ...
+(define-object Browser
+  (in-module "Gimp")
+  (parent "GtkHPaned")
+  (c-name "GimpBrowser")
+  (gtype-id "GIMP_TYPE_BROWSER")
+)
+
+(define-object Button
+  (in-module "Gimp")
+  (parent "GtkButton")
+  (c-name "GimpButton")
+  (gtype-id "GIMP_TYPE_BUTTON")
+)
+
+(define-object CellRendererColor
+  (in-module "Gimp")
+  (parent "GtkCellRenderer")
+  (c-name "GimpCellRendererColor")
+  (gtype-id "GIMP_TYPE_CELL_RENDERER_COLOR")
+)
+
+(define-object CellRendererToggle
+  (in-module "Gimp")
+  (parent "GtkCellRendererToggle")
+  (c-name "GimpCellRendererToggle")
+  (gtype-id "GIMP_TYPE_CELL_RENDERER_TOGGLE")
+)
+
+(define-object ChainButton
+  (in-module "Gimp")
+  (parent "GtkTable")
+  (c-name "GimpChainButton")
+  (gtype-id "GIMP_TYPE_CHAIN_BUTTON")
+)
+
+(define-object ColorArea
+  (in-module "Gimp")
+  (parent "GtkDrawingArea")
+  (c-name "GimpColorArea")
+  (gtype-id "GIMP_TYPE_COLOR_AREA")
+)
+
+(define-object ColorButton
+  (in-module "Gimp")
+  (parent "GimpButton")
+  (c-name "GimpColorButton")
+  (gtype-id "GIMP_TYPE_COLOR_BUTTON")
+)
+
+(define-object ColorConfig
+  (in-module "Gimp")
+  (parent "GObject")
+  (c-name "GimpColorConfig")
+  (gtype-id "GIMP_TYPE_COLOR_CONFIG")
+)
+
+(define-object ColorDisplay
+  (in-module "Gimp")
+  (parent "GObject")
+  (c-name "GimpColorDisplay")
+  (gtype-id "GIMP_TYPE_COLOR_DISPLAY")
+)
+
+(define-object ColorDisplayStack
+  (in-module "Gimp")
+  (parent "GObject")
+  (c-name "GimpColorDisplayStack")
+  (gtype-id "GIMP_TYPE_COLOR_DISPLAY_STACK")
+)
+
+(define-object ColorHexEntry
+  (in-module "Gimp")
+  (parent "GtkEntry")
+  (c-name "GimpColorHexEntry")
+  (gtype-id "GIMP_TYPE_COLOR_HEX_ENTRY")
+)
+
+(define-object ColorProfileComboBox
+  (in-module "Gimp")
+  (parent "GtkComboBox")
+  (c-name "GimpColorProfileComboBox")
+  (gtype-id "GIMP_TYPE_COLOR_PROFILE_COMBO_BOX")
+)
+
+(define-object ColorProfileStore
+  (in-module "Gimp")
+  (parent "GtkListStore")
+  (c-name "GimpColorProfileStore")
+  (gtype-id "GIMP_TYPE_COLOR_PROFILE_STORE")
+)
+
+(define-object ColorScale
+  (in-module "Gimp")
+  (parent "GtkScale")
+  (c-name "GimpColorScale")
+  (gtype-id "GIMP_TYPE_COLOR_SCALE")
+)
+
+(define-object ColorScales
+  (in-module "Gimp")
+  (parent "GimpColorSelector")
+  (c-name "GimpColorScales")
+  (gtype-id "GIMP_TYPE_COLOR_SCALES")
+)
+
+(define-object ColorSelection
+  (in-module "Gimp")
+  (parent "GtkVBox")
+  (c-name "GimpColorSelection")
+  (gtype-id "GIMP_TYPE_COLOR_SELECTION")
+)
+
+(define-object ColorSelector
+  (in-module "Gimp")
+  (parent "GtkVBox")
+  (c-name "GimpColorSelector")
+  (gtype-id "GIMP_TYPE_COLOR_SELECTOR")
+)
+
+(define-object ColorNotebook
+  (in-module "Gimp")
+  (parent "GimpColorSelector")
+  (c-name "GimpColorNotebook")
+  (gtype-id "GIMP_TYPE_COLOR_NOTEBOOK")
+)
+
+(define-object Dialog
+  (in-module "Gimp")
+  (parent "GtkDialog")
+  (c-name "GimpDialog")
+  (gtype-id "GIMP_TYPE_DIALOG")
+)
+
+(define-object EnumLabel
+  (in-module "Gimp")
+  (parent "GtkLabel")
+  (c-name "GimpEnumLabel")
+  (gtype-id "GIMP_TYPE_ENUM_LABEL")
+)
+
+(define-object Frame
+  (in-module "Gimp")
+  (parent "GtkFrame")
+  (c-name "GimpFrame")
+  (gtype-id "GIMP_TYPE_FRAME")
+)
+
+(define-object HintBox
+  (in-module "Gimp")
+  (parent "GtkHBox")
+  (c-name "GimpHintBox")
+  (gtype-id "GIMP_TYPE_HINT_BOX")
+)
+
+(define-object IntComboBox
+  (in-module "Gimp")
+  (parent "GtkComboBox")
+  (c-name "GimpIntComboBox")
+  (gtype-id "GIMP_TYPE_INT_COMBO_BOX")
+)
+
+(define-object ImageComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpImageComboBox")
+  (gtype-id "GIMP_TYPE_IMAGE_COMBO_BOX")
+)
+
+(define-object EnumComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpEnumComboBox")
+  (gtype-id "GIMP_TYPE_ENUM_COMBO_BOX")
+)
+
+(define-object DrawableComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpDrawableComboBox")
+  (gtype-id "GIMP_TYPE_DRAWABLE_COMBO_BOX")
+)
+
+(define-object ChannelComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpChannelComboBox")
+  (gtype-id "GIMP_TYPE_CHANNEL_COMBO_BOX")
+)
+
+(define-object IntStore
+  (in-module "Gimp")
+  (parent "GtkListStore")
+  (c-name "GimpIntStore")
+  (gtype-id "GIMP_TYPE_INT_STORE")
+)
+
+(define-object EnumStore
+  (in-module "Gimp")
+  (parent "GimpIntStore")
+  (c-name "GimpEnumStore")
+  (gtype-id "GIMP_TYPE_ENUM_STORE")
+)
+
+(define-object LayerComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpLayerComboBox")
+  (gtype-id "GIMP_TYPE_LAYER_COMBO_BOX")
+)
+
+(define-object MemsizeEntry
+  (in-module "Gimp")
+  (parent "GtkHBox")
+  (c-name "GimpMemsizeEntry")
+  (gtype-id "GIMP_TYPE_MEMSIZE_ENTRY")
+)
+
+(define-object NumberPairEntry
+  (in-module "Gimp")
+  (parent "GtkEntry")
+  (c-name "GimpNumberPairEntry")
+  (gtype-id "GIMP_TYPE_NUMBER_PAIR_ENTRY")
+)
+
+(define-object OffsetArea
+  (in-module "Gimp")
+  (parent "GtkDrawingArea")
+  (c-name "GimpOffsetArea")
+  (gtype-id "GIMP_TYPE_OFFSET_AREA")
+)
+
+(define-object PageSelector
+  (in-module "Gimp")
+  (parent "GtkVBox")
+  (c-name "GimpPageSelector")
+  (gtype-id "GIMP_TYPE_PAGE_SELECTOR")
+)
+
+(define-object PathEditor
+  (in-module "Gimp")
+  (parent "GtkVBox")
+  (c-name "GimpPathEditor")
+  (gtype-id "GIMP_TYPE_PATH_EDITOR")
+)
+
+(define-object PickButton
+  (in-module "Gimp")
+  (parent "GtkButton")
+  (c-name "GimpPickButton")
+  (gtype-id "GIMP_TYPE_PICK_BUTTON")
+)
+
+(define-object Preview
+  (in-module "Gimp")
+  (parent "GtkVBox")
+  (c-name "GimpPreview")
+  (gtype-id "GIMP_TYPE_PREVIEW")
+)
+
+(define-object AspectPreview
+  (in-module "Gimp")
+  (parent "GimpPreview")
+  (c-name "GimpAspectPreview")
+  (gtype-id "GIMP_TYPE_ASPECT_PREVIEW")
+)
+
+(define-object PreviewArea
+  (in-module "Gimp")
+  (parent "GtkDrawingArea")
+  (c-name "GimpPreviewArea")
+  (gtype-id "GIMP_TYPE_PREVIEW_AREA")
+)
+
+(define-object ProcBrowserDialog
+  (in-module "Gimp")
+  (parent "GimpDialog")
+  (c-name "GimpProcBrowserDialog")
+  (gtype-id "GIMP_TYPE_PROC_BROWSER_DIALOG")
+)
+
+(define-object ProgressBar
+  (in-module "Gimp")
+  (parent "GtkProgressBar")
+  (c-name "GimpProgressBar")
+  (gtype-id "GIMP_TYPE_PROGRESS_BAR")
+)
+
+(define-object ScrolledPreview
+  (in-module "Gimp")
+  (parent "GimpPreview")
+  (c-name "GimpScrolledPreview")
+  (gtype-id "GIMP_TYPE_SCROLLED_PREVIEW")
+)
+
+(define-object DrawablePreview
+  (in-module "Gimp")
+  (parent "GimpScrolledPreview")
+  (c-name "GimpDrawablePreview")
+  (gtype-id "GIMP_TYPE_DRAWABLE_PREVIEW")
+)
+
+(define-object SelectButton
+  (in-module "Gimp")
+  (parent "GtkHBox")
+  (c-name "GimpSelectButton")
+  (gtype-id "GIMP_TYPE_SELECT_BUTTON")
+)
+
+(define-object PatternSelectButton
+  (in-module "Gimp")
+  (parent "GimpSelectButton")
+  (c-name "GimpPatternSelectButton")
+  (gtype-id "GIMP_TYPE_PATTERN_SELECT_BUTTON")
+)
+
+(define-object PaletteSelectButton
+  (in-module "Gimp")
+  (parent "GimpSelectButton")
+  (c-name "GimpPaletteSelectButton")
+  (gtype-id "GIMP_TYPE_PALETTE_SELECT_BUTTON")
+)
+
+(define-object GradientSelectButton
+  (in-module "Gimp")
+  (parent "GimpSelectButton")
+  (c-name "GimpGradientSelectButton")
+  (gtype-id "GIMP_TYPE_GRADIENT_SELECT_BUTTON")
+)
+
+(define-object FontSelectButton
+  (in-module "Gimp")
+  (parent "GimpSelectButton")
+  (c-name "GimpFontSelectButton")
+  (gtype-id "GIMP_TYPE_FONT_SELECT_BUTTON")
+)
+
+(define-object BrushSelectButton
+  (in-module "Gimp")
+  (parent "GimpSelectButton")
+  (c-name "GimpBrushSelectButton")
+  (gtype-id "GIMP_TYPE_BRUSH_SELECT_BUTTON")
+)
+
+(define-object Ruler
+  (in-module "Gimp")
+  (parent "GtkWidget")
+  (c-name "GimpRuler")
+  (gtype-id "GIMP_TYPE_RULER")
+)
+
+(define-object SizeEntry
+  (in-module "Gimp")
+  (parent "GtkTable")
+  (c-name "GimpSizeEntry")
+  (gtype-id "GIMP_TYPE_SIZE_ENTRY")
+)
+
+(define-object StringComboBox
+  (in-module "Gimp")
+  (parent "GtkComboBox")
+  (c-name "GimpStringComboBox")
+  (gtype-id "GIMP_TYPE_STRING_COMBO_BOX")
+)
+
+(define-object UnitComboBox
+  (in-module "Gimp")
+  (parent "GtkComboBox")
+  (c-name "GimpUnitComboBox")
+  (gtype-id "GIMP_TYPE_UNIT_COMBO_BOX")
+)
+
+(define-object UnitMenu
+  (in-module "Gimp")
+  (parent "GtkOptionMenu")
+  (c-name "GimpUnitMenu")
+  (gtype-id "GIMP_TYPE_UNIT_MENU")
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-object VectorsComboBox
+  (in-module "Gimp")
+  (parent "GimpIntComboBox")
+  (c-name "GimpVectorsComboBox")
+  (gtype-id "GIMP_TYPE_VECTORS_COMBO_BOX")
+)
+
+(define-object ZoomModel
+  (in-module "Gimp")
+  (parent "GObject")
+  (c-name "GimpZoomModel")
+  (gtype-id "GIMP_TYPE_ZOOM_MODEL")
+)
+
+(define-object ZoomPreview
+  (in-module "Gimp")
+  (parent "GimpScrolledPreview")
+  (c-name "GimpZoomPreview")
+  (gtype-id "GIMP_TYPE_ZOOM_PREVIEW")
+)
+
+;; Interfaces
+
+(define-interface ColorManaged
+  (in-module "Gimp")
+  (c-name "GimpColorManaged")
+  (gtype-id "GIMP_TYPE_COLOR_MANAGED")
+)
+
+;; Enumerations and flags ...
+
+(define-enum IntStoreColumns
+  (in-module "Gimp")
+  (c-name "GimpIntStoreColumns")
+  (gtype-id "GIMP_TYPE_INT_STORE_COLUMNS")
+  (values
+    '("value" "GIMP_INT_STORE_VALUE")
+    '("label" "GIMP_INT_STORE_LABEL")
+    '("stock-id" "GIMP_INT_STORE_STOCK_ID")
+    '("pixbuf" "GIMP_INT_STORE_PIXBUF")
+    '("user-data" "GIMP_INT_STORE_USER_DATA")
+    '("num-columns" "GIMP_INT_STORE_NUM_COLUMNS")
+  )
+)
+
+(define-enum AspectType
+  (in-module "Gimp")
+  (c-name "GimpAspectType")
+  (gtype-id "GIMP_TYPE_ASPECT_TYPE")
+  (values
+    '("square" "GIMP_ASPECT_SQUARE")
+    '("portrait" "GIMP_ASPECT_PORTRAIT")
+    '("landscape" "GIMP_ASPECT_LANDSCAPE")
+  )
+)
+
+(define-enum ChainPosition
+  (in-module "Gimp")
+  (c-name "GimpChainPosition")
+  (gtype-id "GIMP_TYPE_CHAIN_POSITION")
+  (values
+    '("top" "GIMP_CHAIN_TOP")
+    '("left" "GIMP_CHAIN_LEFT")
+    '("bottom" "GIMP_CHAIN_BOTTOM")
+    '("right" "GIMP_CHAIN_RIGHT")
+  )
+)
+
+(define-enum ColorAreaType
+  (in-module "Gimp")
+  (c-name "GimpColorAreaType")
+  (gtype-id "GIMP_TYPE_COLOR_AREA_TYPE")
+  (values
+    '("flat" "GIMP_COLOR_AREA_FLAT")
+    '("small-checks" "GIMP_COLOR_AREA_SMALL_CHECKS")
+    '("large-checks" "GIMP_COLOR_AREA_LARGE_CHECKS")
+  )
+)
+
+(define-enum ColorSelectorChannel
+  (in-module "Gimp")
+  (c-name "GimpColorSelectorChannel")
+  (gtype-id "GIMP_TYPE_COLOR_SELECTOR_CHANNEL")
+  (values
+    '("hue" "GIMP_COLOR_SELECTOR_HUE")
+    '("saturation" "GIMP_COLOR_SELECTOR_SATURATION")
+    '("value" "GIMP_COLOR_SELECTOR_VALUE")
+    '("red" "GIMP_COLOR_SELECTOR_RED")
+    '("green" "GIMP_COLOR_SELECTOR_GREEN")
+    '("blue" "GIMP_COLOR_SELECTOR_BLUE")
+    '("alpha" "GIMP_COLOR_SELECTOR_ALPHA")
+  )
+)
+
+(define-enum PageSelectorTarget
+  (in-module "Gimp")
+  (c-name "GimpPageSelectorTarget")
+  (gtype-id "GIMP_TYPE_PAGE_SELECTOR_TARGET")
+  (values
+    '("layers" "GIMP_PAGE_SELECTOR_TARGET_LAYERS")
+    '("images" "GIMP_PAGE_SELECTOR_TARGET_IMAGES")
+  )
+)
+
+(define-enum SizeEntryUpdatePolicy
+  (in-module "Gimp")
+  (c-name "GimpSizeEntryUpdatePolicy")
+  (gtype-id "GIMP_TYPE_SIZE_ENTRY_UPDATE_POLICY")
+  (values
+    '("none" "GIMP_SIZE_ENTRY_UPDATE_NONE")
+    '("size" "GIMP_SIZE_ENTRY_UPDATE_SIZE")
+    '("resolution" "GIMP_SIZE_ENTRY_UPDATE_RESOLUTION")
+  )
+)
+
+(define-enum Unit
+  (in-module "Gimp")
+  (c-name "GimpUnit")
+;; FIXME: make GimpUnit enum more binding-friendly -- gimp_unit_get_type()
+;;  (gtype-id "GIMP_TYPE_UNIT")
+  (values
+    '("pixel" "GIMP_UNIT_PIXEL")
+    '("inch" "GIMP_UNIT_INCH")
+    '("mm" "GIMP_UNIT_MM")
+    '("point" "GIMP_UNIT_POINT")
+    '("pica" "GIMP_UNIT_PICA")
+  )
+)
+
+(define-enum ZoomType
+  (in-module "Gimp")
+  (c-name "GimpZoomType")
+  (gtype-id "GIMP_TYPE_ZOOM_TYPE")
+  (values
+    '("in" "GIMP_ZOOM_IN")
+    '("out" "GIMP_ZOOM_OUT")
+    '("in-more" "GIMP_ZOOM_IN_MORE")
+    '("out-more" "GIMP_ZOOM_OUT_MORE")
+    '("in-max" "GIMP_ZOOM_IN_MAX")
+    '("out-max" "GIMP_ZOOM_OUT_MAX")
+    '("to" "GIMP_ZOOM_TO")
+  )
+)
+
+
+;; From gimpbrowser.h
+
+(define-function gimp_browser_get_type
+  (c-name "gimp_browser_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_browser_new
+  (c-name "gimp_browser_new")
+  (is-constructor-of "GimpBrowser")
+  (return-type "GtkWidget*")
+)
+
+(define-method add_search_types
+  (of-object "GimpBrowser")
+  (c-name "gimp_browser_add_search_types")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "first_type_label")
+    '("gint" "first_type_id")
+  )
+  (varargs #t)
+)
+
+(define-method set_widget
+  (of-object "GimpBrowser")
+  (c-name "gimp_browser_set_widget")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+(define-method show_message
+  (of-object "GimpBrowser")
+  (c-name "gimp_browser_show_message")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "message")
+  )
+)
+
+
+
+;; From gimpbutton.h
+
+(define-function gimp_button_get_type
+  (c-name "gimp_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_button_new
+  (c-name "gimp_button_new")
+  (is-constructor-of "GimpButton")
+  (return-type "GtkWidget*")
+)
+
+(define-method extended_clicked
+  (of-object "GimpButton")
+  (c-name "gimp_button_extended_clicked")
+  (return-type "none")
+  (parameters
+    '("GdkModifierType" "state")
+  )
+)
+
+
+
+;; From gimpcellrenderercolor.h
+
+(define-function gimp_cell_renderer_color_get_type
+  (c-name "gimp_cell_renderer_color_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_cell_renderer_color_new
+  (c-name "gimp_cell_renderer_color_new")
+  (is-constructor-of "GimpCellRendererColor")
+  (return-type "GtkCellRenderer*")
+)
+
+
+
+;; From gimpcellrenderertoggle.h
+
+(define-function gimp_cell_renderer_toggle_get_type
+  (c-name "gimp_cell_renderer_toggle_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_cell_renderer_toggle_new
+  (c-name "gimp_cell_renderer_toggle_new")
+  (is-constructor-of "GimpCellRendererToggle")
+  (return-type "GtkCellRenderer*")
+  (properties
+    '("stock-id" (argname "stock_id") (optional))
+  )
+)
+
+(define-method clicked
+  (of-object "GimpCellRendererToggle")
+  (c-name "gimp_cell_renderer_toggle_clicked")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "path")
+    '("GdkModifierType" "state")
+  )
+)
+
+
+
+;; From gimpchainbutton.h
+
+(define-function gimp_chain_button_get_type
+  (c-name "gimp_chain_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_chain_button_new
+  (c-name "gimp_chain_button_new")
+  (is-constructor-of "GimpChainButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("position")
+  )
+)
+
+(define-method set_active
+  (of-object "GimpChainButton")
+  (c-name "gimp_chain_button_set_active")
+  (return-type "none")
+  (parameters
+    '("gboolean" "active")
+  )
+)
+
+(define-method get_active
+  (of-object "GimpChainButton")
+  (c-name "gimp_chain_button_get_active")
+  (return-type "gboolean")
+)
+
+
+
+;; From gimpcolorarea.h
+
+(define-function gimp_color_area_get_type
+  (c-name "gimp_color_area_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_area_new
+  (c-name "gimp_color_area_new")
+  (is-constructor-of "GimpColorArea")
+  (return-type "GtkWidget*")
+  (properties
+    '("color" (optional))
+    '("type" (optional))
+    '("drag-mask" (argname "drag_mask") (optional))
+  )
+)
+
+(define-method set_color
+  (of-object "GimpColorArea")
+  (c-name "gimp_color_area_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "color")
+  )
+)
+
+(define-method get_color
+  (of-object "GimpColorArea")
+  (c-name "gimp_color_area_get_color")
+  (return-type "none")
+  (parameters
+    '("GimpRGB*" "color")
+  )
+)
+
+(define-method has_alpha
+  (of-object "GimpColorArea")
+  (c-name "gimp_color_area_has_alpha")
+  (return-type "gboolean")
+)
+
+(define-method set_type
+  (of-object "GimpColorArea")
+  (c-name "gimp_color_area_set_type")
+  (return-type "none")
+  (parameters
+    '("GimpColorAreaType" "type")
+  )
+)
+
+(define-method set_draw_border
+  (of-object "GimpColorArea")
+  (c-name "gimp_color_area_set_draw_border")
+  (return-type "none")
+  (parameters
+    '("gboolean" "draw_border")
+  )
+)
+
+
+
+;; From gimpcolorbutton.h
+
+(define-function gimp_color_button_get_type
+  (c-name "gimp_color_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_button_new
+  (c-name "gimp_color_button_new")
+  (is-constructor-of "GimpColorButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("width" (optional))
+    '("height" (optional))
+    '("color" (optional))
+    '("type" (optional))
+  )
+)
+
+(define-method set_color
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "color")
+  )
+)
+
+(define-method get_color
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_get_color")
+  (return-type "none")
+  (parameters
+    '("GimpRGB*" "color")
+  )
+)
+
+(define-method has_alpha
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_has_alpha")
+  (return-type "gboolean")
+)
+
+(define-method set_type
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_set_type")
+  (return-type "none")
+  (parameters
+    '("GimpColorAreaType" "type")
+  )
+)
+
+(define-method get_update
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_get_update")
+  (return-type "gboolean")
+)
+
+(define-method set_update
+  (of-object "GimpColorButton")
+  (c-name "gimp_color_button_set_update")
+  (return-type "none")
+  (parameters
+    '("gboolean" "continuous")
+  )
+)
+
+
+
+;; From gimpcolordisplay.h
+
+(define-function gimp_color_display_get_type
+  (c-name "gimp_color_display_get_type")
+  (return-type "GType")
+)
+
+(define-method clone
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_clone")
+  (return-type "GimpColorDisplay*")
+)
+
+(define-method convert_surface
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_convert_surface")
+  (return-type "none")
+  (parameters
+    '("cairo_surface_t*" "surface")
+  )
+)
+
+(define-method convert
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_convert")
+  (return-type "none")
+  (parameters
+    '("guchar*" "buf")
+    '("gint" "width")
+    '("gint" "height")
+    '("gint" "bpp")
+    '("gint" "bpl")
+  )
+  (deprecated "use convert_surface(cairo_surface_t*) instead")
+)
+
+(define-method load_state
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_load_state")
+  (return-type "none")
+  (parameters
+    '("GimpParasite*" "state")
+  )
+)
+
+(define-method save_state
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_save_state")
+  (return-type "GimpParasite*")
+)
+
+(define-method configure
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_configure")
+  (return-type "GtkWidget*")
+)
+
+(define-method configure_reset
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_configure_reset")
+  (return-type "none")
+)
+
+(define-method changed
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_changed")
+  (return-type "none")
+)
+
+(define-method set_enabled
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_set_enabled")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enabled")
+  )
+)
+
+(define-method get_enabled
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_get_enabled")
+  (return-type "gboolean")
+)
+
+(define-method get_config
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_get_config")
+  (return-type "GimpColorConfig*")
+)
+
+(define-method get_managed
+  (of-object "GimpColorDisplay")
+  (c-name "gimp_color_display_get_managed")
+  (return-type "GimpColorManaged*")
+)
+
+
+
+;; From gimpcolordisplaystack.h
+
+(define-function gimp_color_display_stack_get_type
+  (c-name "gimp_color_display_stack_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_display_stack_new
+  (c-name "gimp_color_display_stack_new")
+  (is-constructor-of "GimpColorDisplayStack")
+  (return-type "GimpColorDisplayStack*")
+)
+
+(define-method clone
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_clone")
+  (return-type "GimpColorDisplayStack*")
+)
+
+(define-method changed
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_changed")
+  (return-type "none")
+)
+
+(define-method add
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_add")
+  (return-type "none")
+  (parameters
+    '("GimpColorDisplay*" "display")
+  )
+)
+
+(define-method remove
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_remove")
+  (return-type "none")
+  (parameters
+    '("GimpColorDisplay*" "display")
+  )
+)
+
+(define-method reorder_up
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_reorder_up")
+  (return-type "none")
+  (parameters
+    '("GimpColorDisplay*" "display")
+  )
+)
+
+(define-method reorder_down
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_reorder_down")
+  (return-type "none")
+  (parameters
+    '("GimpColorDisplay*" "display")
+  )
+)
+
+(define-method convert_surface
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_convert_surface")
+  (return-type "none")
+  (parameters
+    '("cairo_surface_t*" "surface")
+  )
+)
+
+(define-method convert
+  (of-object "GimpColorDisplayStack")
+  (c-name "gimp_color_display_stack_convert")
+  (return-type "none")
+  (parameters
+    '("guchar*" "buf")
+    '("gint" "width")
+    '("gint" "height")
+    '("gint" "bpp")
+    '("gint" "bpl")
+  )
+  (deprecated "use convert_surface(cairo_surface_t*) instead")
+)
+
+
+
+;; From gimpcolorhexentry.h
+
+(define-function gimp_color_hex_entry_get_type
+  (c-name "gimp_color_hex_entry_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_hex_entry_new
+  (c-name "gimp_color_hex_entry_new")
+  (is-constructor-of "GimpColorHexEntry")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_color
+  (of-object "GimpColorHexEntry")
+  (c-name "gimp_color_hex_entry_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "color")
+  )
+)
+
+(define-method get_color
+  (of-object "GimpColorHexEntry")
+  (c-name "gimp_color_hex_entry_get_color")
+  (return-type "none")
+  (parameters
+    '("GimpRGB*" "color")
+  )
+)
+
+
+
+;; From gimpcolornotebook.h
+
+(define-function gimp_color_notebook_get_type
+  (c-name "gimp_color_notebook_get_type")
+  (return-type "GType")
+)
+
+(define-method set_has_page
+  (of-object "GimpColorNotebook")
+  (c-name "gimp_color_notebook_set_has_page")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GType" "page_type")
+    '("gboolean" "has_page")
+  )
+)
+
+
+
+;; From gimpcolorprofilecombobox.h
+
+(define-function gimp_color_profile_combo_box_get_type
+  (c-name "gimp_color_profile_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_profile_combo_box_new_with_model
+  (c-name "gimp_color_profile_combo_box_new_with_model")
+  (is-constructor-of "GimpColorProfileComboBox")
+  (return-type "GtkWidget*")
+  (properties
+    '("dialog")
+    '("model")
+  )
+)
+
+(define-method add
+  (of-object "GimpColorProfileComboBox")
+  (c-name "gimp_color_profile_combo_box_add")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "label")
+  )
+)
+
+(define-method set_active
+  (of-object "GimpColorProfileComboBox")
+  (c-name "gimp_color_profile_combo_box_set_active")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "label")
+  )
+)
+
+(define-method get_active
+  (of-object "GimpColorProfileComboBox")
+  (c-name "gimp_color_profile_combo_box_get_active")
+  (return-type "gchar*")
+)
+
+
+
+;; From gimpcolorprofilestore.h
+
+(define-function gimp_color_profile_store_get_type
+  (c-name "gimp_color_profile_store_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_profile_store_new
+  (c-name "gimp_color_profile_store_new")
+  (is-constructor-of "GimpColorProfileStore")
+  (return-type "GtkListStore*")
+  (properties
+    '("history")
+  )
+)
+
+(define-method add
+  (of-object "GimpColorProfileStore")
+  (c-name "gimp_color_profile_store_add")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "label")
+  )
+)
+
+
+
+;; From gimpcolorscale.h
+
+(define-function gimp_color_scale_get_type
+  (c-name "gimp_color_scale_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_scale_new
+  (c-name "gimp_color_scale_new")
+  (is-constructor-of "GimpColorScale")
+  (return-type "GtkWidget*")
+  (properties
+    '("orientation")
+    '("channel")
+  )
+)
+
+(define-method set_channel
+  (of-object "GimpColorScale")
+  (c-name "gimp_color_scale_set_channel")
+  (return-type "none")
+  (parameters
+    '("GimpColorSelectorChannel" "channel")
+  )
+)
+
+(define-method set_color
+  (of-object "GimpColorScale")
+  (c-name "gimp_color_scale_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "rgb")
+    '("const-GimpHSV*" "hsv")
+  )
+)
+
+
+
+;; From gimpcolorscales.h
+
+(define-function gimp_color_scales_get_type
+  (c-name "gimp_color_scales_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gimpcolorselect.h
+
+(define-function gimp_color_select_get_type
+  (c-name "gimp_color_select_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gimpcolorselection.h
+
+(define-function gimp_color_selection_get_type
+  (c-name "gimp_color_selection_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_selection_new
+  (c-name "gimp_color_selection_new")
+  (is-constructor-of "GimpColorSelection")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_show_alpha
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_set_show_alpha")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show_alpha")
+  )
+)
+
+(define-method get_show_alpha
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_get_show_alpha")
+  (return-type "gboolean")
+)
+
+(define-method set_color
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "color")
+  )
+)
+
+(define-method get_color
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_get_color")
+  (return-type "none")
+  (parameters
+    '("GimpRGB*" "color")
+  )
+)
+
+(define-method set_old_color
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_set_old_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "color")
+  )
+)
+
+(define-method get_old_color
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_get_old_color")
+  (return-type "none")
+  (parameters
+    '("GimpRGB*" "color")
+  )
+)
+
+(define-method reset
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_reset")
+  (return-type "none")
+)
+
+(define-method color_changed
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_color_changed")
+  (return-type "none")
+)
+
+(define-method set_config
+  (of-object "GimpColorSelection")
+  (c-name "gimp_color_selection_set_config")
+  (return-type "none")
+  (parameters
+    '("GimpColorConfig*" "config")
+  )
+)
+
+
+
+;; From gimpcolorselector.h
+
+(define-function gimp_color_selector_get_type
+  (c-name "gimp_color_selector_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_selector_new
+  (c-name "gimp_color_selector_new")
+  (is-constructor-of "GimpColorSelector")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GType" "selector_type")
+    '("const-GimpRGB*" "rgb")
+    '("const-GimpHSV*" "hsv")
+    '("GimpColorSelectorChannel" "channel")
+  )
+)
+
+(define-method set_toggles_visible
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_toggles_visible")
+  (return-type "none")
+  (parameters
+    '("gboolean" "visible")
+  )
+)
+
+(define-method set_toggles_sensitive
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_toggles_sensitive")
+  (return-type "none")
+  (parameters
+    '("gboolean" "sensitive")
+  )
+)
+
+(define-method set_show_alpha
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_show_alpha")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show_alpha")
+  )
+)
+
+(define-method set_color
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_color")
+  (return-type "none")
+  (parameters
+    '("const-GimpRGB*" "rgb")
+    '("const-GimpHSV*" "hsv")
+  )
+)
+
+(define-method set_channel
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_channel")
+  (return-type "none")
+  (parameters
+    '("GimpColorSelectorChannel" "channel")
+  )
+)
+
+(define-method color_changed
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_color_changed")
+  (return-type "none")
+)
+
+(define-method channel_changed
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_channel_changed")
+  (return-type "none")
+)
+
+(define-method set_config
+  (of-object "GimpColorSelector")
+  (c-name "gimp_color_selector_set_config")
+  (return-type "none")
+  (parameters
+    '("GimpColorConfig*" "config")
+  )
+)
+
+
+
+;; From gimpdialog.h
+
+(define-function gimp_dialog_get_type
+  (c-name "gimp_dialog_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_dialog_new
+  (c-name "gimp_dialog_new")
+  (is-constructor-of "GimpDialog")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "title")
+    '("const-gchar*" "role")
+    '("GtkWidget*" "parent")
+    '("GtkDialogFlags" "flags")
+    '("GimpHelpFunc" "help_func")
+    '("const-gchar*" "help_id")
+  )
+  (varargs #t)
+)
+
+(define-function gimp_dialog_new_valist
+  (c-name "gimp_dialog_new_valist")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "title")
+    '("const-gchar*" "role")
+    '("GtkWidget*" "parent")
+    '("GtkDialogFlags" "flags")
+    '("GimpHelpFunc" "help_func")
+    '("const-gchar*" "help_id")
+    '("va_list" "args")
+  )
+)
+
+(define-method add_button
+  (of-object "GimpDialog")
+  (c-name "gimp_dialog_add_button")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "button_text")
+    '("gint" "response_id")
+  )
+)
+
+(define-method add_buttons
+  (of-object "GimpDialog")
+  (c-name "gimp_dialog_add_buttons")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method add_buttons_valist
+  (of-object "GimpDialog")
+  (c-name "gimp_dialog_add_buttons_valist")
+  (return-type "none")
+  (parameters
+    '("va_list" "args")
+  )
+)
+
+(define-method run
+  (of-object "GimpDialog")
+  (c-name "gimp_dialog_run")
+  (return-type "gint")
+)
+
+(function gimp_dialogs_show_help_button
+  (c-name "gimp_dialogs_show_help_button")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show")
+  )
+)
+
+;; from gimpui.h
+
+(define-method set_transient
+  (of-object "GimpDialog")
+  (c-name "gimp_window_set_transient")
+  (return-type "none")
+)
+
+
+;; From gimpenumcombobox.h
+
+(define-function gimp_enum_combo_box_get_type
+  (c-name "gimp_enum_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_enum_combo_box_new
+  (c-name "gimp_enum_combo_box_new")
+  (is-constructor-of "GimpEnumComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GType" "enum_type")
+  )
+)
+
+(define-function gimp_ui_init
+  (c-name "gimp_ui_init")
+  (return-type "none")
+)
+
+(define-function gimp_enum_combo_box_new_with_model
+  (c-name "gimp_enum_combo_box_new_with_model")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpEnumStore*" "enum_store")
+  )
+)
+
+(define-method set_stock_prefix
+  (of-object "GimpEnumComboBox")
+  (c-name "gimp_enum_combo_box_set_stock_prefix")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "stock_prefix")
+  )
+)
+
+
+
+;; From gimpenumlabel.h
+
+(define-function gimp_enum_label_get_type
+  (c-name "gimp_enum_label_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_enum_label_new
+  (c-name "gimp_enum_label_new")
+  (is-constructor-of "GimpEnumLabel")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GType" "enum_type")
+    '("gint" "value")
+  )
+)
+
+(define-method set_value
+  (of-object "GimpEnumLabel")
+  (c-name "gimp_enum_label_set_value")
+  (return-type "none")
+  (parameters
+    '("gint" "value")
+  )
+)
+
+
+
+;; From gimpenumstore.h
+
+(define-function gimp_enum_store_get_type
+  (c-name "gimp_enum_store_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_enum_store_new
+  (c-name "gimp_enum_store_new")
+  (is-constructor-of "GimpEnumStore")
+  (return-type "GtkListStore*")
+  (parameters
+    '("GType" "enum_type")
+  )
+)
+
+(define-function gimp_enum_store_new_with_range
+  (c-name "gimp_enum_store_new_with_range")
+  (return-type "GtkListStore*")
+  (parameters
+    '("GType" "enum_type")
+    '("gint" "minimum")
+    '("gint" "maximum")
+  )
+)
+
+(define-function gimp_enum_store_new_with_values
+  (c-name "gimp_enum_store_new_with_values")
+  (return-type "GtkListStore*")
+  (parameters
+    '("GType" "enum_type")
+    '("gint" "n_values")
+  )
+  (varargs #t)
+)
+
+(define-function gimp_enum_store_new_with_values_valist
+  (c-name "gimp_enum_store_new_with_values_valist")
+  (return-type "GtkListStore*")
+  (parameters
+    '("GType" "enum_type")
+    '("gint" "n_values")
+    '("va_list" "args")
+  )
+)
+
+(define-method set_stock_prefix
+  (of-object "GimpEnumStore")
+  (c-name "gimp_enum_store_set_stock_prefix")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "stock_prefix")
+  )
+)
+
+
+
+;; From gimpframe.h
+
+(define-function gimp_frame_get_type
+  (c-name "gimp_frame_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_frame_new
+  (c-name "gimp_frame_new")
+  (is-constructor-of "GimpFrame")
+  (return-type "GtkWidget*")
+  (properties
+    '("label")
+  )
+)
+
+
+
+;; From gimphintbox.h
+
+(define-function gimp_hint_box_get_type
+  (c-name "gimp_hint_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_hint_box_new
+  (c-name "gimp_hint_box_new")
+  (is-constructor-of "GimpHintBox")
+  (return-type "GtkWidget*")
+  (properties
+    '("hint")
+    '("stock-id" (optional))
+  )
+)
+
+
+
+;; From gimpintcombobox.h
+
+(define-function gimp_int_combo_box_get_type
+  (c-name "gimp_int_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_int_combo_box_new
+  (c-name "gimp_int_combo_box_new")
+  (is-constructor-of "GimpIntComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "first_label")
+    '("gint" "first_value")
+  )
+  (varargs #t)
+)
+
+(define-function gimp_int_combo_box_new_valist
+  (c-name "gimp_int_combo_box_new_valist")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "first_label")
+    '("gint" "first_value")
+    '("va_list" "values")
+  )
+)
+
+(define-function gimp_int_combo_box_new_array
+  (c-name "gimp_int_combo_box_new_array")
+  (return-type "GtkWidget*")
+  (parameters
+    '("gint" "n_values")
+    '("const-gchar*[]" "labels")
+  )
+)
+
+(define-method prepend
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_prepend")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method append
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_append")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method set_active
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_set_active")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "value")
+  )
+)
+
+(define-method get_active
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_get_active")
+  (return-type "gboolean")
+  (parameters
+    '("gint*" "value")
+  )
+)
+
+(define-method connect
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_connect")
+  (return-type "gulong")
+  (parameters
+    '("gint" "value")
+    '("GCallback" "callback")
+    '("gpointer" "data")
+  )
+)
+
+(define-method set_sensitivity
+  (of-object "GimpIntComboBox")
+  (c-name "gimp_int_combo_box_set_sensitivity")
+  (return-type "none")
+  (parameters
+    '("GimpIntSensitivityFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "destroy")
+  )
+)
+
+
+
+;; From gimpintstore.h
+
+(define-function gimp_int_store_get_type
+  (c-name "gimp_int_store_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_int_store_new
+  (c-name "gimp_int_store_new")
+  (is-constructor-of "GimpIntStore")
+  (return-type "GtkListStore*")
+)
+
+(define-method lookup_by_value
+  (of-object "GimpIntStore")
+  (c-name "gimp_int_store_lookup_by_value")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "value")
+    '("GtkTreeIter*" "iter")
+  )
+)
+
+
+
+;; From gimpmemsizeentry.h
+
+(define-function gimp_memsize_entry_get_type
+  (c-name "gimp_memsize_entry_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_memsize_entry_new
+  (c-name "gimp_memsize_entry_new")
+  (is-constructor-of "GimpMemsizeEntry")
+  (return-type "GtkWidget*")
+  (parameters
+    '("guint64" "value")
+    '("guint64" "lower")
+    '("guint64" "upper")
+  )
+)
+
+(define-method set_value
+  (of-object "GimpMemsizeEntry")
+  (c-name "gimp_memsize_entry_set_value")
+  (return-type "none")
+  (parameters
+    '("guint64" "value")
+  )
+)
+
+(define-method get_value
+  (of-object "GimpMemsizeEntry")
+  (c-name "gimp_memsize_entry_get_value")
+  (return-type "guint64")
+)
+
+
+
+;; From gimpnumberpairentry.h
+
+(define-function gimp_number_pair_entry_get_type
+  (c-name "gimp_number_pair_entry_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_number_pair_entry_new
+  (c-name "gimp_number_pair_entry_new")
+  (is-constructor-of "GimpNumberPairEntry")
+  (return-type "GtkWidget*")
+  (properties
+    '("separators")
+    '("allow-simplification" (argname "allow_simplification"))
+    '("min-valid-value" (argname "min_valid_value"))
+    '("max-valid-value" (argname "max_valid_value"))
+  )
+)
+
+(define-method set_default_values
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_default_values")
+  (return-type "none")
+  (parameters
+    '("gdouble" "left")
+    '("gdouble" "right")
+  )
+)
+
+(define-method get_default_values
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_default_values")
+  (return-type "none")
+  (parameters
+    '("gdouble*" "left")
+    '("gdouble*" "right")
+  )
+)
+
+(define-method set_values
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_values")
+  (return-type "none")
+  (parameters
+    '("gdouble" "left")
+    '("gdouble" "right")
+  )
+)
+
+(define-method get_values
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_values")
+  (return-type "none")
+  (parameters
+    '("gdouble*" "left")
+    '("gdouble*" "right")
+  )
+)
+
+(define-method set_default_text
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_default_text")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "string")
+  )
+)
+
+(define-method get_default_text
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_default_text")
+  (return-type "const-gchar*")
+)
+
+(define-method set_ratio
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_ratio")
+  (return-type "none")
+  (parameters
+    '("gdouble" "ratio")
+  )
+)
+
+(define-method get_ratio
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_ratio")
+  (return-type "gdouble")
+)
+
+(define-method set_aspect
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_aspect")
+  (return-type "none")
+  (parameters
+    '("GimpAspectType" "aspect")
+  )
+)
+
+(define-method get_aspect
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_aspect")
+  (return-type "GimpAspectType")
+)
+
+(define-method set_user_override
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_set_user_override")
+  (return-type "none")
+  (parameters
+    '("gboolean" "user_override")
+  )
+)
+
+(define-method get_user_override
+  (of-object "GimpNumberPairEntry")
+  (c-name "gimp_number_pair_entry_get_user_override")
+  (return-type "gboolean")
+)
+
+
+
+;; From gimpoffsetarea.h
+
+(define-function gimp_offset_area_get_type
+  (c-name "gimp_offset_area_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_offset_area_new
+  (c-name "gimp_offset_area_new")
+  (is-constructor-of "GimpOffsetArea")
+  (return-type "GtkWidget*")
+  (parameters
+    '("gint" "orig_width")
+    '("gint" "orig_height")
+  )
+)
+
+(define-method set_pixbuf
+  (of-object "GimpOffsetArea")
+  (c-name "gimp_offset_area_set_pixbuf")
+  (return-type "none")
+  (parameters
+    '("GdkPixbuf*" "pixbuf")
+  )
+)
+
+(define-method set_size
+  (of-object "GimpOffsetArea")
+  (c-name "gimp_offset_area_set_size")
+  (return-type "none")
+  (parameters
+    '("gint" "width")
+    '("gint" "height")
+  )
+)
+
+(define-method set_offsets
+  (of-object "GimpOffsetArea")
+  (c-name "gimp_offset_area_set_offsets")
+  (return-type "none")
+  (parameters
+    '("gint" "offset_x")
+    '("gint" "offset_y")
+  )
+)
+
+
+
+;; From gimppageselector.h
+
+(define-function gimp_page_selector_get_type
+  (c-name "gimp_page_selector_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_page_selector_new
+  (c-name "gimp_page_selector_new")
+  (is-constructor-of "GimpPageSelector")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_n_pages
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_set_n_pages")
+  (return-type "none")
+  (parameters
+    '("gint" "n_pages")
+  )
+)
+
+(define-method get_n_pages
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_n_pages")
+  (return-type "gint")
+)
+
+(define-method set_target
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_set_target")
+  (return-type "none")
+  (parameters
+    '("GimpPageSelectorTarget" "target")
+  )
+)
+
+(define-method get_target
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_target")
+  (return-type "GimpPageSelectorTarget")
+)
+
+(define-method set_page_thumbnail
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_set_page_thumbnail")
+  (return-type "none")
+  (parameters
+    '("gint" "page_no")
+    '("GdkPixbuf*" "thumbnail")
+  )
+)
+
+(define-method get_page_thumbnail
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_page_thumbnail")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("gint" "page_no")
+  )
+)
+
+(define-method set_page_label
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_set_page_label")
+  (return-type "none")
+  (parameters
+    '("gint" "page_no")
+    '("const-gchar*" "label")
+  )
+)
+
+(define-method get_page_label
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_page_label")
+  (return-type "gchar*")
+  (parameters
+    '("gint" "page_no")
+  )
+)
+
+(define-method select_all
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_select_all")
+  (return-type "none")
+)
+
+(define-method unselect_all
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_unselect_all")
+  (return-type "none")
+)
+
+(define-method select_page
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_select_page")
+  (return-type "none")
+  (parameters
+    '("gint" "page_no")
+  )
+)
+
+(define-method unselect_page
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_unselect_page")
+  (return-type "none")
+  (parameters
+    '("gint" "page_no")
+  )
+)
+
+(define-method page_is_selected
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_page_is_selected")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "page_no")
+  )
+)
+
+(define-method get_selected_pages
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_selected_pages")
+  (return-type "gint*")
+  (parameters
+    '("gint*" "n_selected_pages")
+  )
+)
+
+(define-method select_range
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_select_range")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "range")
+  )
+)
+
+(define-method get_selected_range
+  (of-object "GimpPageSelector")
+  (c-name "gimp_page_selector_get_selected_range")
+  (return-type "gchar*")
+)
+
+
+
+;; From gimppatheditor.h
+
+(define-function gimp_path_editor_get_type
+  (c-name "gimp_path_editor_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_path_editor_new
+  (c-name "gimp_path_editor_new")
+  (is-constructor-of "GimpPathEditor")
+  (properties
+    '("title")
+    '("path" (optional))
+  )
+  (return-type "GtkWidget*")
+)
+
+(define-method get_path
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_get_path")
+  (return-type "gchar*")
+)
+
+(define-method set_path
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_set_path")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-method get_writable_path
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_get_writable_path")
+  (return-type "gchar*")
+)
+
+(define-method set_writable_path
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_set_writable_path")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-method get_dir_writable
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_get_dir_writable")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "directory")
+  )
+)
+
+(define-method set_dir_writable
+  (of-object "GimpPathEditor")
+  (c-name "gimp_path_editor_set_dir_writable")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "directory")
+    '("gboolean" "writable")
+  )
+)
+
+
+
+;; From gimppickbutton.h
+
+(define-function gimp_pick_button_get_type
+  (c-name "gimp_pick_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_pick_button_new
+  (c-name "gimp_pick_button_new")
+  (is-constructor-of "GimpPickButton")
+  (return-type "GtkWidget*")
+)
+
+
+
+;; From gimppreview.h
+
+(define-function gimp_preview_get_type
+  (c-name "gimp_preview_get_type")
+  (return-type "GType")
+)
+
+(define-method set_update
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_set_update")
+  (return-type "none")
+  (parameters
+    '("gboolean" "update")
+  )
+)
+
+(define-method get_update
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_get_update")
+  (return-type "gboolean")
+)
+
+(define-method set_bounds
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_set_bounds")
+  (return-type "none")
+  (parameters
+    '("gint" "xmin")
+    '("gint" "ymin")
+    '("gint" "xmax")
+    '("gint" "ymax")
+  )
+)
+
+(define-method get_position
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_get_position")
+  (return-type "none")
+  (parameters
+    '("gint*" "x")
+    '("gint*" "y")
+  )
+)
+
+(define-method get_size
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_get_size")
+  (return-type "none")
+  (parameters
+    '("gint*" "width")
+    '("gint*" "height")
+  )
+)
+
+(define-method transform
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_transform")
+  (return-type "none")
+  (parameters
+    '("gint" "src_x")
+    '("gint" "src_y")
+    '("gint*" "dest_x")
+    '("gint*" "dest_y")
+  )
+)
+
+(define-method untransform
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_untransform")
+  (return-type "none")
+  (parameters
+    '("gint" "src_x")
+    '("gint" "src_y")
+    '("gint*" "dest_x")
+    '("gint*" "dest_y")
+  )
+)
+
+(define-method get_area
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_get_area")
+  (return-type "GtkWidget*")
+)
+
+(define-method draw
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_draw")
+  (return-type "none")
+)
+
+(define-method draw_buffer
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_draw_buffer")
+  (return-type "none")
+  (parameters
+    '("const-guchar*" "buffer")
+    '("gint" "rowstride")
+  )
+)
+
+(define-method invalidate
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_invalidate")
+  (return-type "none")
+)
+
+(define-method set_default_cursor
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_set_default_cursor")
+  (return-type "none")
+  (parameters
+    '("GdkCursor*" "cursor")
+  )
+)
+
+(define-method get_controls
+  (of-object "GimpPreview")
+  (c-name "gimp_preview_get_controls")
+  (return-type "GtkWidget*")
+)
+
+
+
+;; From gimppreviewarea.h
+
+(define-function gimp_preview_area_get_type
+  (c-name "gimp_preview_area_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_preview_area_new
+  (c-name "gimp_preview_area_new")
+  (is-constructor-of "GimpPreviewArea")
+  (return-type "GtkWidget*")
+)
+
+(define-method draw
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_draw")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("GimpImageType" "type")
+    '("const-guchar*" "buf")
+    '("gint" "rowstride")
+  )
+)
+
+(define-method blend
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_blend")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("GimpImageType" "type")
+    '("const-guchar*" "buf1")
+    '("gint" "rowstride1")
+    '("const-guchar*" "buf2")
+    '("gint" "rowstride2")
+    '("guchar" "opacity")
+  )
+)
+
+(define-method mask
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_mask")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("GimpImageType" "type")
+    '("const-guchar*" "buf1")
+    '("gint" "rowstride1")
+    '("const-guchar*" "buf2")
+    '("gint" "rowstride2")
+    '("const-guchar*" "mask")
+    '("gint" "rowstride_mask")
+  )
+)
+
+(define-method fill
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_fill")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("guchar" "red")
+    '("guchar" "green")
+    '("guchar" "blue")
+  )
+)
+
+(define-method set_offsets
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_set_offsets")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method set_colormap
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_set_colormap")
+  (return-type "none")
+  (parameters
+    '("const-guchar*" "colormap")
+    '("gint" "num_colors")
+  )
+)
+
+(define-method set_max_size
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_set_max_size")
+  (return-type "none")
+  (parameters
+    '("gint" "width")
+    '("gint" "height")
+  )
+)
+
+(define-method menu_popup
+  (of-object "GimpPreviewArea")
+  (c-name "gimp_preview_area_menu_popup")
+  (return-type "none")
+  (parameters
+    '("GdkEventButton*" "event")
+  )
+)
+
+
+
+;; From gimpscrolledpreview.h
+
+(define-function gimp_scrolled_preview_get_type
+  (c-name "gimp_scrolled_preview_get_type")
+  (return-type "GType")
+)
+
+(define-method set_position
+  (of-object "GimpScrolledPreview")
+  (c-name "gimp_scrolled_preview_set_position")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method set_policy
+  (of-object "GimpScrolledPreview")
+  (c-name "gimp_scrolled_preview_set_policy")
+  (return-type "none")
+  (parameters
+    '("GtkPolicyType" "hscrollbar_policy")
+    '("GtkPolicyType" "vscrollbar_policy")
+  )
+)
+
+(define-method freeze
+  (of-object "GimpScrolledPreview")
+  (c-name "gimp_scrolled_preview_freeze")
+  (return-type "none")
+)
+
+(define-method thaw
+  (of-object "GimpScrolledPreview")
+  (c-name "gimp_scrolled_preview_thaw")
+  (return-type "none")
+)
+
+
+
+;; From gimpsizeentry.h
+
+(define-function gimp_size_entry_get_type
+  (c-name "gimp_size_entry_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_size_entry_new
+  (c-name "gimp_size_entry_new")
+  (is-constructor-of "GimpSizeEntry")
+  (return-type "GtkWidget*")
+  (parameters
+    '("gint" "number_of_fields")
+    '("GimpUnit" "unit")
+    '("const-gchar*" "unit_format")
+    '("gboolean" "menu_show_pixels")
+    '("gboolean" "menu_show_percent")
+    '("gboolean" "show_refval")
+    '("gint" "spinbutton_width")
+    '("GimpSizeEntryUpdatePolicy" "update_policy")
+  )
+)
+
+(define-method add_field
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_add_field")
+  (return-type "none")
+  (parameters
+    '("GtkSpinButton*" "value_spinbutton")
+    '("GtkSpinButton*" "refval_spinbutton")
+  )
+)
+
+(define-method attach_label
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_attach_label")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "text")
+    '("gint" "row")
+    '("gint" "column")
+    '("gfloat" "alignment")
+  )
+)
+
+(define-method set_resolution
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_resolution")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "resolution")
+    '("gboolean" "keep_size")
+  )
+)
+
+(define-method set_size
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_size")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "lower")
+    '("gdouble" "upper")
+  )
+)
+
+(define-method set_value_boundaries
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_value_boundaries")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "lower")
+    '("gdouble" "upper")
+  )
+)
+
+(define-method get_value
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_get_value")
+  (return-type "gdouble")
+  (parameters
+    '("gint" "field")
+  )
+)
+
+(define-method set_value
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_value")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "value")
+  )
+)
+
+(define-method set_refval_boundaries
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_refval_boundaries")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "lower")
+    '("gdouble" "upper")
+  )
+)
+
+(define-method set_refval_digits
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_refval_digits")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gint" "digits")
+  )
+)
+
+(define-method get_refval
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_get_refval")
+  (return-type "gdouble")
+  (parameters
+    '("gint" "field")
+  )
+)
+
+(define-method set_refval
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_refval")
+  (return-type "none")
+  (parameters
+    '("gint" "field")
+    '("gdouble" "refval")
+  )
+)
+
+(define-method get_unit
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_get_unit")
+  (return-type "GimpUnit")
+)
+
+(define-method set_unit
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_unit")
+  (return-type "none")
+  (parameters
+    '("GimpUnit" "unit")
+  )
+)
+
+(define-method show_unit_menu
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_show_unit_menu")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show")
+  )
+)
+
+(define-method set_pixel_digits
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_pixel_digits")
+  (return-type "none")
+  (parameters
+    '("gint" "digits")
+  )
+)
+
+(define-method grab_focus
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_grab_focus")
+  (return-type "none")
+)
+
+(define-method set_activates_default
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_set_activates_default")
+  (return-type "none")
+  (parameters
+    '("gboolean" "setting")
+  )
+)
+
+(define-method get_help_widget
+  (of-object "GimpSizeEntry")
+  (c-name "gimp_size_entry_get_help_widget")
+  (return-type "GtkWidget*")
+  (parameters
+    '("gint" "field")
+  )
+)
+
+
+
+;; From gimpstringcombobox.h
+
+(define-function gimp_string_combo_box_get_type
+  (c-name "gimp_string_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_string_combo_box_new
+  (c-name "gimp_string_combo_box_new")
+  (is-constructor-of "GimpStringComboBox")
+  (return-type "GtkWidget*")
+  (properties
+    '("model")
+    '("id-column" (argname "id_column"))
+    '("label-column" (argname "label_column"))
+  )
+)
+
+(define-method set_active
+  (of-object "GimpStringComboBox")
+  (c-name "gimp_string_combo_box_set_active")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method get_active
+  (of-object "GimpStringComboBox")
+  (c-name "gimp_string_combo_box_get_active")
+  (return-type "gchar*")
+)
+
+
+
+;; From gimpunitcombobox.h
+
+(define-function gimp_unit_combo_box_get_type
+  (c-name "gimp_unit_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_unit_combo_box_new
+  (c-name "gimp_unit_combo_box_new")
+  (is-constructor-of "GimpUnitComboBox")
+  (return-type "GtkWidget*")
+)
+
+(define-function gimp_unit_combo_box_new_with_model
+  (c-name "gimp_unit_combo_box_new_with_model")
+  (is-constructor-of "GimpUnitComboBox")
+  (return-type "GtkWidget*")
+  (properties
+    '("model" (optional))
+  )
+)
+
+(define-method get_active
+  (of-object "GimpUnitComboBox")
+  (c-name "gimp_unit_combo_box_get_active")
+  (return-type "GimpUnit")
+)
+
+(define-method set_active
+  (of-object "GimpUnitComboBox")
+  (c-name "gimp_unit_combo_box_set_active")
+  (return-type "none")
+  (parameters
+    '("GimpUnit" "unit")
+  )
+)
+
+
+
+;; From gimpunitmenu.h
+
+(define-function gimp_unit_menu_get_type
+  (c-name "gimp_unit_menu_get_type")
+  (return-type "GType")
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-function gimp_unit_menu_new
+  (c-name "gimp_unit_menu_new")
+  (is-constructor-of "GimpUnitMenu")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "format")
+    '("GimpUnit" "unit")
+    '("gboolean" "show_pixels")
+    '("gboolean" "show_percent")
+    '("gboolean" "show_custom")
+  )
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-method set_unit
+  (of-object "GimpUnitMenu")
+  (c-name "gimp_unit_menu_set_unit")
+  (return-type "none")
+  (parameters
+    '("GimpUnit" "unit")
+  )
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-method get_unit
+  (of-object "GimpUnitMenu")
+  (c-name "gimp_unit_menu_get_unit")
+  (return-type "GimpUnit")
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-method set_pixel_digits
+  (of-object "GimpUnitMenu")
+  (c-name "gimp_unit_menu_set_pixel_digits")
+  (return-type "none")
+  (parameters
+    '("gint" "digits")
+  )
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+(define-method get_pixel_digits
+  (of-object "GimpUnitMenu")
+  (c-name "gimp_unit_menu_get_pixel_digits")
+  (return-type "gint")
+  (deprecated "use gimpui.UnitComboBox instead")
+)
+
+
+
+;; From gimpzoommodel.h
+
+(define-function gimp_zoom_model_get_type
+  (c-name "gimp_zoom_model_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_zoom_model_new
+  (c-name "gimp_zoom_model_new")
+  (is-constructor-of "GimpZoomModel")
+  (return-type "GimpZoomModel*")
+)
+
+(define-method set_range
+  (of-object "GimpZoomModel")
+  (c-name "gimp_zoom_model_set_range")
+  (return-type "none")
+  (parameters
+    '("gdouble" "min")
+    '("gdouble" "max")
+  )
+)
+
+(define-method zoom
+  (of-object "GimpZoomModel")
+  (c-name "gimp_zoom_model_zoom")
+  (return-type "none")
+  (parameters
+    '("GimpZoomType" "zoom_type")
+    '("gdouble" "scale")
+  )
+)
+
+(define-method get_factor
+  (of-object "GimpZoomModel")
+  (c-name "gimp_zoom_model_get_factor")
+  (return-type "gdouble")
+)
+
+(define-method get_fraction
+  (of-object "GimpZoomModel")
+  (c-name "gimp_zoom_model_get_fraction")
+  (return-type "none")
+  (parameters
+    '("gint*" "numerator")
+    '("gint*" "denominator")
+  )
+)
+
+(define-function gimp_zoom_button_new
+  (c-name "gimp_zoom_button_new")
+  (is-constructor-of "GimpZoomButton")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpZoomModel*" "model")
+    '("GimpZoomType" "zoom_type")
+    '("GtkIconSize" "icon_size")
+  )
+)
+
+(define-function gimp_zoom_model_zoom_step
+  (c-name "gimp_zoom_model_zoom_step")
+  (return-type "gdouble")
+  (parameters
+    '("GimpZoomType" "zoom_type")
+    '("gdouble" "scale")
+  )
+)
+
+
+
+;; From gimpaspectpreview.h
+
+(define-function gimp_aspect_preview_get_type
+  (c-name "gimp_aspect_preview_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_aspect_preview_new
+  (c-name "gimp_aspect_preview_new")
+  (is-constructor-of "GimpAspectPreview")
+  (return-type "GtkWidget*")
+  (properties
+    '("drawable")
+    '("update" (optional))
+  )
+)
+
+
+
+;; From gimpdrawablepreview.h
+
+(define-function gimp_drawable_preview_get_type
+  (c-name "gimp_drawable_preview_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_drawable_preview_new
+  (c-name "gimp_drawable_preview_new")
+  (is-constructor-of "GimpDrawablePreview")
+  (return-type "GtkWidget*")
+  (properties
+    '("drawable")
+  )
+)
+
+(define-method get_drawable
+  (of-object "GimpDrawablePreview")
+  (c-name "gimp_drawable_preview_get_drawable")
+  (return-type "GimpDrawable*")
+)
+
+(define-method draw_region
+  (of-object "GimpDrawablePreview")
+  (c-name "gimp_drawable_preview_draw_region")
+  (return-type "none")
+  (parameters
+    '("const-GimpPixelRgn*" "region")
+  )
+)
+
+
+
+;; From gimpimagecombobox.h
+
+(define-function gimp_image_combo_box_get_type
+  (c-name "gimp_image_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_image_combo_box_new
+  (c-name "gimp_image_combo_box_new")
+  (is-constructor-of "GimpImageComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpImageConstraintFunc" "constraint")
+    '("gpointer" "data")
+  )
+)
+
+
+
+;; From gimpitemcombobox.h
+
+(define-function gimp_drawable_combo_box_get_type
+  (c-name "gimp_drawable_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_channel_combo_box_get_type
+  (c-name "gimp_channel_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_layer_combo_box_get_type
+  (c-name "gimp_layer_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_vectors_combo_box_get_type
+  (c-name "gimp_vectors_combo_box_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_drawable_combo_box_new
+  (c-name "gimp_drawable_combo_box_new")
+  (is-constructor-of "GimpDrawableComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpDrawableConstraintFunc" "constraint")
+    '("gpointer" "data")
+  )
+)
+
+(define-function gimp_channel_combo_box_new
+  (c-name "gimp_channel_combo_box_new")
+  (is-constructor-of "GimpChannelComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpDrawableConstraintFunc" "constraint")
+    '("gpointer" "data")
+  )
+)
+
+(define-function gimp_layer_combo_box_new
+  (c-name "gimp_layer_combo_box_new")
+  (is-constructor-of "GimpLayerComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpDrawableConstraintFunc" "constraint")
+    '("gpointer" "data")
+  )
+)
+
+(define-function gimp_vectors_combo_box_new
+  (c-name "gimp_vectors_combo_box_new")
+  (is-constructor-of "GimpVectorsComboBox")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GimpVectorsConstraintFunc" "constraint")
+    '("gpointer" "data")
+  )
+)
+
+
+
+;; From gimppatternselect.h
+
+(define-function gimp_pattern_select_new
+  (c-name "gimp_pattern_select_new")
+  (is-constructor-of "GimpPatternSelect")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "title")
+    '("const-gchar*" "pattern_name")
+    '("GimpRunPatternCallback" "callback")
+    '("gpointer" "data")
+  )
+)
+
+(define-function gimp_pattern_select_destroy
+  (c-name "gimp_pattern_select_destroy")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "pattern_callback")
+  )
+)
+
+
+
+;; From gimpprocbrowserdialog.h
+
+(define-function gimp_proc_browser_dialog_get_type
+  (c-name "gimp_proc_browser_dialog_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_proc_browser_dialog_new
+  (c-name "gimp_proc_browser_dialog_new")
+  (is-constructor-of "GimpProcBrowserDialog")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "title")
+    '("const-gchar*" "role")
+    '("GimpHelpFunc" "help_func")
+    '("const-gchar*" "help_id")
+  )
+  (varargs #t)
+)
+
+(define-method get_selected
+  (of-object "GimpProcBrowserDialog")
+  (c-name "gimp_proc_browser_dialog_get_selected")
+  (return-type "gchar*")
+)
+
+
+
+;; From gimpprocview.h
+
+(define-function gimp_proc_view_new
+  (c-name "gimp_proc_view_new")
+  (is-constructor-of "GimpProcView")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "name")
+    '("const-gchar*" "menu_path")
+    '("const-gchar*" "blurb")
+    '("const-gchar*" "help")
+    '("const-gchar*" "author")
+    '("const-gchar*" "copyright")
+    '("const-gchar*" "date")
+    '("GimpPDBProcType" "type")
+    '("gint" "n_params")
+    '("gint" "n_return_vals")
+    '("GimpParamDef*" "params")
+    '("GimpParamDef*" "return_vals")
+  )
+)
+
+
+
+;; From gimpzoompreview.h
+
+(define-function gimp_zoom_preview_get_type
+  (c-name "gimp_zoom_preview_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_zoom_preview_new_with_model
+  (c-name "gimp_zoom_preview_new_with_model")
+  (is-constructor-of "GimpZoomPreview")
+  (return-type "GtkWidget*")
+  (properties
+    '("drawable")
+    '("model" (optional))
+  )
+)
+
+(define-method get_source
+  (of-object "GimpZoomPreview")
+  (c-name "gimp_zoom_preview_get_source")
+  (return-type "guchar*")
+  (parameters
+    '("gint*" "width")
+    '("gint*" "height")
+    '("gint*" "bpp")
+  )
+)
+
+(define-method get_drawable
+  (of-object "GimpZoomPreview")
+  (c-name "gimp_zoom_preview_get_drawable")
+  (return-type "GimpDrawable*")
+)
+
+(define-method get_model
+  (of-object "GimpZoomPreview")
+  (c-name "gimp_zoom_preview_get_model")
+  (return-type "GimpZoomModel*")
+)
+
+(define-method get_factor
+  (of-object "GimpZoomPreview")
+  (c-name "gimp_zoom_preview_get_factor")
+  (return-type "gdouble")
+)
+
+
+
+;; From gimpprogressbar.h
+
+(define-function gimp_progress_bar_get_type
+  (c-name "gimp_progress_bar_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_progress_bar_new
+  (c-name "gimp_progress_bar_new")
+  (is-constructor-of "GimpProgressBar")
+  (return-type "GtkWidget*")
+)
+
+
+
+;; From gimpbrushselectbutton.h
+
+(define-function gimp_brush_select_button_get_type
+  (c-name "gimp_brush_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_brush_select_button_new
+  (c-name "gimp_brush_select_button_new")
+  (is-constructor-of "GimpBrushSelectButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("brush-name" (argname "brush_name") (optional))
+    '("brush-opacity" (argname "opacity") (optional))
+    '("brush-spacing" (argname "spacing") (optional))
+    '("brush-paint-mode" (argname "paint_mode") (optional))
+  )
+)
+
+(define-method get_brush
+  (of-object "GimpBrushSelectButton")
+  (c-name "gimp_brush_select_button_get_brush")
+  (return-type "const-gchar*")
+  (parameters
+    '("gdouble*" "opacity")
+    '("gint*" "spacing")
+    '("GimpLayerMode*" "paint_mode")
+  )
+)
+
+(define-method set_brush
+  (of-object "GimpBrushSelectButton")
+  (c-name "gimp_brush_select_button_set_brush")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "brush_name")
+    '("gdouble" "opacity")
+    '("gint" "spacing")
+    '("GimpLayerMode" "paint_mode")
+  )
+)
+
+
+
+;; From gimpfontselectbutton.h
+
+(define-function gimp_font_select_button_get_type
+  (c-name "gimp_font_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_font_select_button_new
+  (c-name "gimp_font_select_button_new")
+  (is-constructor-of "GimpFontSelectButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("font-name" (argname "font_name") (optional))
+  )
+)
+
+(define-method get_font
+  (of-object "GimpFontSelectButton")
+  (c-name "gimp_font_select_button_get_font")
+  (return-type "const-gchar*")
+)
+
+(define-method set_font
+  (of-object "GimpFontSelectButton")
+  (c-name "gimp_font_select_button_set_font")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "font_name")
+  )
+)
+
+
+
+;; From gimpgradientselectbutton.h
+
+(define-function gimp_gradient_select_button_get_type
+  (c-name "gimp_gradient_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_gradient_select_button_new
+  (c-name "gimp_gradient_select_button_new")
+  (is-constructor-of "GimpGradientSelectButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("gradient-name" (argname "gradient_name") (optional))
+  )
+)
+
+(define-method get_gradient
+  (of-object "GimpGradientSelectButton")
+  (c-name "gimp_gradient_select_button_get_gradient")
+  (return-type "const-gchar*")
+)
+
+(define-method set_gradient
+  (of-object "GimpGradientSelectButton")
+  (c-name "gimp_gradient_select_button_set_gradient")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "gradient_name")
+  )
+)
+
+
+
+;; From gimppaletteselectbutton.h
+
+(define-function gimp_palette_select_button_get_type
+  (c-name "gimp_palette_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_palette_select_button_new
+  (c-name "gimp_palette_select_button_new")
+  (is-constructor-of "GimpPaletteSelectButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("palette-name" (argname "palette_name") (optional))
+  )
+)
+
+(define-method get_palette
+  (of-object "GimpPaletteSelectButton")
+  (c-name "gimp_palette_select_button_get_palette")
+  (return-type "const-gchar*")
+)
+
+(define-method set_palette
+  (of-object "GimpPaletteSelectButton")
+  (c-name "gimp_palette_select_button_set_palette")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "palette_name")
+  )
+)
+
+
+
+;; From gimppatternselectbutton.h
+
+(define-function gimp_pattern_select_button_get_type
+  (c-name "gimp_pattern_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_pattern_select_button_new
+  (c-name "gimp_pattern_select_button_new")
+  (is-constructor-of "GimpPatternSelectButton")
+  (return-type "GtkWidget*")
+  (properties
+    '("title" (optional))
+    '("pattern-name" (argname "pattern_name") (optional))
+  )
+)
+
+(define-method get_pattern
+  (of-object "GimpPatternSelectButton")
+  (c-name "gimp_pattern_select_button_get_pattern")
+  (return-type "const-gchar*")
+)
+
+(define-method set_pattern
+  (of-object "GimpPatternSelectButton")
+  (c-name "gimp_pattern_select_button_set_pattern")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "pattern_name")
+  )
+)
+
+
+
+;; From gimpselectbutton.h
+
+(define-function gimp_select_button_get_type
+  (c-name "gimp_select_button_get_type")
+  (return-type "GType")
+)
+
+(define-method close_popup
+  (of-object "GimpSelectButton")
+  (c-name "gimp_select_button_close_popup")
+  (return-type "none")
+)
+
+
+
+;; From gimpwidgetsenums.h
+
+(define-function gimp_aspect_type_get_type
+  (c-name "gimp_aspect_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_chain_position_get_type
+  (c-name "gimp_chain_position_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_area_type_get_type
+  (c-name "gimp_color_area_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_color_selector_channel_get_type
+  (c-name "gimp_color_selector_channel_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_page_selector_target_get_type
+  (c-name "gimp_page_selector_target_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_size_entry_update_policy_get_type
+  (c-name "gimp_size_entry_update_policy_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_zoom_type_get_type
+  (c-name "gimp_zoom_type_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gimpruler.h
+
+(define-function gimp_ruler_get_type
+  (c-name "gimp_ruler_get_type")
+  (return-type "GType")
+)
+
+(define-function gimp_ruler_new
+  (c-name "gimp_ruler_new")
+  (is-constructor-of "GimpRuler")
+  (return-type "GtkWidget*")
+  (properties
+    '("orientation")
+    '("lower" (optional))
+    '("upper" (optional))
+    '("max-size" (argname "max_size") (optional))
+  )
+)
+
+(define-method set_unit
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_set_unit")
+  (return-type "none")
+  (parameters
+    '("GimpUnit" "unit")
+  )
+)
+
+(define-method get_unit
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_get_unit")
+  (return-type "GimpUnit")
+)
+
+(define-method set_position
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_set_position")
+  (return-type "none")
+  (parameters
+    '("gdouble" "position")
+  )
+)
+
+(define-method get_position
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_get_position")
+  (return-type "gdouble")
+)
+
+(define-method set_range
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_set_range")
+  (return-type "none")
+  (parameters
+    '("gdouble" "lower")
+    '("gdouble" "upper")
+    '("gdouble" "max_size")
+  )
+)
+
+(define-method get_range
+  (of-object "GimpRuler")
+  (c-name "gimp_ruler_get_range")
+  (return-type "none")
+  (parameters
+    '("gdouble*" "lower")
+    '("gdouble*" "upper")
+    '("gdouble*" "max_size")
+  )
+)
+
+
diff --git a/plug-ins/pygimp/gimpui.override b/plug-ins/pygimp/gimpui.override
new file mode 100644
index 0000000..5851989
--- /dev/null
+++ b/plug-ins/pygimp/gimpui.override
@@ -0,0 +1,2075 @@
+headers
+#include <Python.h>
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include <pycairo.h>
+extern Pycairo_CAPI_t *Pycairo_CAPI;
+
+#define GIMP_DISABLE_DEPRECATION_WARNINGS
+#include <libgimp/gimp.h>
+#undef GIMP_DISABLE_DEPRECATED
+#include <libgimp/gimpui.h>
+#define GIMP_DISABLE_DEPRECATED
+
+#define NO_IMPORT_PYGIMP
+#include "pygimp-api.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+typedef struct {
+    PyObject *constraint;
+    PyObject *user_data;
+} PyGimpConstraintData;
+
+typedef struct {
+    PyObject *sensitivity_func;
+    PyObject *user_data;
+} PyGimpIntSensitivityData;
+
+/* TODO: Add a header for these */
+void gimpui_register_classes(PyObject *d);
+void gimpui_add_constants(PyObject *module, const gchar *strip_prefix);
+
+static void
+pygimp_decref_callback(PyObject* obj) {
+    Py_XDECREF (obj);
+}
+
+%%
+modulename gimpui
+%%
+import gobject.GObject as PyGObject_Type
+import gtk.gdk.Pixbuf as PyGdkPixbuf_Type
+import gtk.Object as PyGtkObject_Type
+import gtk.Widget as PyGtkWidget_Type
+import gtk.Dialog as PyGtkDialog_Type
+import gtk.Window as PyGtkWindow_Type
+import gtk.Label as PyGtkLabel_Type
+import gtk.Button as PyGtkButton_Type
+import gtk.ToggleButton as PyGtkToggleButton_Type
+import gtk.RadioButton as PyGtkRadioButton_Type
+import gtk.SpinButton as PyGtkSpinButton_Type
+import gtk.Entry as PyGtkEntry_Type
+import gtk.DrawingArea as PyGtkDrawingArea_Type
+import gtk.Table as PyGtkTable_Type
+import gtk.Frame as PyGtkFrame_Type
+import gtk.HBox as PyGtkHBox_Type
+import gtk.VBox as PyGtkVBox_Type
+import gtk.HPaned as PyGtkHPaned_Type
+import gtk.VPaned as PyGtkVPaned_Type
+import gtk.Scale as PyGtkScale_Type
+import gtk.ProgressBar as PyGtkProgressBar_Type
+import gtk.OptionMenu as PyGtkOptionMenu_Type
+import gtk.ComboBox as PyGtkComboBox_Type
+import gtk.ListStore as PyGtkListStore_Type
+import gtk.TreeModel as PyGtkTreeModel_Type
+import gtk.CellRenderer as PyGtkCellRenderer_Type
+import gtk.CellRendererToggle as PyGtkCellRendererToggle_Type
+import gimp.Parasite as PyGimpParasite_Type
+%%
+ignore
+  gimp_dialog_add_buttons
+  gimp_int_combo_box_connect
+  gimp_color_profile_combo_box_new
+  gimp_enum_store_new_with_values
+  gimp_int_combo_box_new_array
+%%
+ignore-glob
+  *_get_type
+  *_valist
+  gimp_resolution_*
+%%
+ignore-type
+  GimpIntStoreColumns 
+%%
+override gimp_drawable_combo_box_new kwargs
+static gboolean
+pygimp_drawable_constraint_marshal(gint32 image_id, gint32 drawable_id,
+                                   gpointer user_data)
+{
+    PyObject *img, *drw, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    drw = pygimp_drawable_new(NULL, drawable_id);
+    if (!drw) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, drw,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, drw, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(drw);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_drawable_combo_box_new(PyGObject *self, PyObject *args,
+                                  PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.DrawableComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_XINCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_drawable_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_drawable_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_DRAWABLE_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.DrawableComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+define GimpDrawableComboBox.set_active_drawable kwargs
+static PyObject *
+_wrap_gimp_drawable_combo_box_set_active_drawable(PyGObject *self, PyObject *args,
+                                                  PyObject *kwargs)
+{
+    PyGimpDrawable *drw;
+
+    static char *kwlist[] = { "drawable", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpDrawableComboBox.set_active_drawable",
+                                     kwlist,
+                                     PyGimpDrawable_Type, &drw))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), drw->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Drawable (ID %d) does not exist in GimpDrawableComboBox",
+                     drw->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define GimpDrawableComboBox.get_active_drawable noargs
+static PyObject *
+_wrap_gimp_drawable_combo_box_get_active_drawable(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_drawable_new(NULL, value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_channel_combo_box_new kwargs
+static gboolean
+pygimp_channel_constraint_marshal(gint32 image_id, gint32 channel_id,
+                                  gpointer user_data)
+{
+    PyObject *img, *chn, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    chn = pygimp_channel_new(channel_id);
+    if (!chn) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, chn,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, chn, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(chn);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_channel_combo_box_new(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.ChannelComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_channel_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_channel_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_CHANNEL_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.ChannelComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+define GimpChannelComboBox.set_active_channel kwargs
+static PyObject *
+_wrap_gimp_channel_combo_box_set_active_channel(PyGObject *self, PyObject *args,
+                                                PyObject *kwargs)
+{
+    PyGimpChannel *chn;
+
+    static char *kwlist[] = { "channel", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                    "O!:GimpChannelComboBox.set_active_channel",
+                                    kwlist,
+                                    PyGimpChannel_Type, &chn))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), chn->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Channel (ID %d) does not exist in GimpChannelComboBox",
+                     chn->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define GimpChannelComboBox.get_active_channel noargs
+static PyObject *
+_wrap_gimp_channel_combo_box_get_active_channel(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_channel_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_layer_combo_box_new kwargs
+static gboolean
+pygimp_layer_constraint_marshal(gint32 image_id, gint32 layer_id,
+                                gpointer user_data)
+{
+    PyObject *img, *lay, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    lay = pygimp_layer_new(layer_id);
+    if (!lay) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, lay,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, lay, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(lay);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_layer_combo_box_new(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpDrawableConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.LayerComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_layer_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_layer_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_LAYER_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.LayerComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+define GimpLayerComboBox.set_active_layer kwargs
+static PyObject *
+_wrap_gimp_layer_combo_box_set_active_layer(PyGObject *self, PyObject *args,
+                                            PyObject *kwargs)
+{
+    PyGimpLayer *lay;
+
+    static char *kwlist[] = { "layer", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpLayerComboBox.set_active_layer",
+                                     kwlist,
+                                     PyGimpLayer_Type, &lay))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), lay->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Layer (ID %d) does not exist in GimpLayerComboBox",
+                     lay->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define GimpLayerComboBox.get_active_layer noargs
+static PyObject *
+_wrap_gimp_layer_combo_box_get_active_layer(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_layer_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_vectors_combo_box_new kwargs
+static gboolean
+pygimp_vectors_constraint_marshal(gint32 image_id, gint32 vectors_id,
+                                  gpointer user_data)
+{
+    PyObject *img, *vect, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    vect = pygimp_vectors_new(vectors_id);
+    if (!vect) {
+        PyErr_Print();
+        Py_DECREF(img);
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, vect,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, vect, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(vect);
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_vectors_combo_box_new(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpVectorsConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.VectorsComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_vectors_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_vectors_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_VECTORS_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.VectorsComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+define GimpVectorsComboBox.set_active_vectors kwargs
+static PyObject *
+_wrap_gimp_vectors_combo_box_set_active_vectors(PyGObject *self, PyObject *args,
+                                                PyObject *kwargs)
+{
+    PyGimpVectors *vect;
+
+    static char *kwlist[] = { "vectors", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                   "O!:GimpVectorsComboBox.set_active_vectors",
+                                   kwlist,
+                                   PyGimpVectors_Type, &vect))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), vect->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Vectors (ID %d) does not exist in GimpVectorsComboBox",
+                     vect->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define GimpVectorsComboBox.get_active_vectors noargs
+static PyObject *
+_wrap_gimp_vectors_combo_box_get_active_vectors(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_vectors_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_image_combo_box_new kwargs
+static gboolean
+pygimp_image_constraint_marshal(gint32 image_id, gpointer user_data)
+{
+    PyObject *img, *ret;
+    gboolean res;
+    PyGimpConstraintData *data = user_data;
+
+    img = pygimp_image_new(image_id);
+    if (!img) {
+        PyErr_Print();
+        return FALSE;
+    }
+
+    if (data->user_data && data->user_data != Py_None)
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img,
+                                           data->user_data, NULL);
+    else
+        ret = PyObject_CallFunctionObjArgs(data->constraint, img, NULL);
+
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(img);
+
+    return res;
+}
+
+static int
+_wrap_gimp_image_combo_box_new(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    PyObject *constraint = NULL, *user_data = NULL;
+    GimpImageConstraintFunc func = NULL;
+    PyGimpConstraintData *data = NULL;
+
+    static char *kwlist[] = { "constraint", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|OO:gimpui.ImageComboBox.__init__",
+                                     kwlist,
+                                     &constraint, &user_data))
+        return -1;
+
+    if (constraint && constraint != Py_None) {
+        if (!PyCallable_Check(constraint)) {
+            PyErr_SetString(PyExc_TypeError, "first arg must be callable");
+            return -1;
+        }
+
+        data = g_new(PyGimpConstraintData, 1);
+
+        data->constraint = constraint;
+        Py_INCREF(constraint);
+
+        data->user_data = user_data;
+        Py_XINCREF(user_data);
+
+        func = pygimp_image_constraint_marshal;
+    }
+
+    self->obj = (GObject *)gimp_image_combo_box_new(func, data);
+
+    Py_XDECREF(constraint);
+    Py_XDECREF(user_data);
+    g_free(data);
+
+    if (pyg_type_from_object((PyObject *)self) != GIMP_TYPE_IMAGE_COMBO_BOX) {
+        PyErr_SetString(PyExc_RuntimeError, "__gobject_init__ must be used "
+                        "when subclassing gimpui.ImageComboBox");
+        return -1;
+    }
+
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+define GimpImageComboBox.set_active_image kwargs
+static PyObject *
+_wrap_gimp_image_combo_box_set_active_image(PyGObject *self, PyObject *args,
+                                            PyObject *kwargs)
+{
+    PyGimpImage *img;
+
+    static char *kwlist[] = { "image", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O!:GimpImageComboBox.set_active_image",
+                                     kwlist,
+                                     PyGimpImage_Type, &img))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), img->ID)) {
+        PyErr_Format(pygimp_error,
+                     "Image (ID %d) does not exist in GimpImageComboBox",
+                     img->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+define GimpImageComboBox.get_active_image noargs
+static PyObject *
+_wrap_gimp_image_combo_box_get_active_image(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return pygimp_image_new(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_dialog_new kwargs
+static void
+pygimp_help_func_marshal(const gchar *help_id, gpointer help_data)
+{
+    GObject *dialog = help_data;
+    PyObject *py_dialog, *help_func, *ret;
+
+    py_dialog = g_object_get_data(dialog, "pygimp-dialog-pyobject");
+    help_func = g_object_get_data(dialog, "pygimp-dialog-help_func");
+
+    ret = PyObject_CallFunction(help_func, "sO", help_id, py_dialog);
+
+    if (ret)
+        Py_DECREF(ret);
+    else
+        PyErr_Print();
+}
+
+static void
+pygimp_help_func_destroy(gpointer data)
+{
+    PyObject *help_func = data;
+
+    Py_DECREF(help_func);
+}
+
+static void
+pygimp_dialog_close(GtkWidget *widget)
+{
+    /* Synthesize delete_event to close dialog. */
+
+    if (gtk_widget_get_window (widget)) {
+        GdkEvent *event = gdk_event_new(GDK_DELETE);
+
+        event->any.window     = g_object_ref (gtk_widget_get_window (widget));
+        event->any.send_event = TRUE;
+
+        gtk_main_do_event(event);
+        gdk_event_free(event);
+    }
+}
+
+static int
+_wrap_gimp_dialog_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *title, *role;
+    PyGObject *py_window = NULL;
+    PyObject *py_flags = NULL, *py_buttons = Py_None;
+    PyObject *help_func = NULL;
+    gchar *help_id = NULL;
+    GtkDialogFlags flags = 0;
+    int len, i;
+    GtkWidget *parent;
+    GimpHelpFunc func;
+
+    static char *kwlist[] = { "title", "role", "parent", "flags",
+                              "help_func", "help_id", "buttons", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "zz|OOOzO:gimpui.GimpDialog.__init__",
+                                     kwlist,
+                                     &title, &role, &py_window, &py_flags,
+                                     &help_func, &help_id, &py_buttons))
+        return -1;
+
+    if (py_window == NULL || (PyObject*)py_window == Py_None)
+        parent = NULL;
+    else if (pygobject_check(py_window, &PyGtkWindow_Type))
+        parent = GTK_WIDGET(py_window->obj);
+    else {
+        PyErr_SetString(PyExc_TypeError, "parent must be a GtkWindow or None");
+        return -1;
+    }
+
+    if (pyg_flags_get_value(GTK_TYPE_DIALOG_FLAGS, py_flags, (gint *)&flags))
+        return -1;
+
+    if (py_buttons == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_buttons))
+        len = PyTuple_Size(py_buttons);
+    else {
+        PyErr_SetString(PyExc_TypeError, "buttons must be a tuple containing text/response pairs or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "buttons tuple must contain text/response id pairs");
+        return -1;
+    }
+
+    if (help_func) {
+        if (help_func != Py_None) {
+            if (!PyCallable_Check(help_func)) {
+                PyErr_SetString(PyExc_TypeError, "help_func must be callable");
+                return -1;
+            }
+
+            func = pygimp_help_func_marshal;
+
+       } else {
+            func = gimp_standard_help_func;
+        }
+    } else {
+        func = gimp_standard_help_func;
+    }
+
+    pygobject_construct(self,
+                        "title",     title,
+                        "role",      role,
+                        "modal",     (flags & GTK_DIALOG_MODAL),
+                        "help-func", func,
+                        "help-id",   help_id,
+                        NULL);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpDialog object");
+        return -1;
+    }
+
+   if (parent) {
+        if (GTK_IS_WINDOW(parent))
+            gtk_window_set_transient_for(GTK_WINDOW(self->obj),
+                                         GTK_WINDOW(parent));
+        else
+            gtk_window_set_screen(GTK_WINDOW(self->obj),
+                                  gtk_widget_get_screen(parent));
+
+        if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
+            g_signal_connect_object(parent, "destroy",
+                                    G_CALLBACK(pygimp_dialog_close),
+                                    self->obj, G_CONNECT_SWAPPED);
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *text = PyTuple_GetItem(py_buttons, i);
+        PyObject *id = PyTuple_GetItem(py_buttons, i + 1);
+        if (!PyString_Check(text) && !PyUnicode_Check(text)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each text/response id pair "
+                            "must be a string");
+            return -1;
+        }
+        if (!PyInt_Check(id)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each text/response id pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_dialog_add_button(GIMP_DIALOG(self->obj), PyString_AsString(text),
+                               PyInt_AsLong(id));
+    }
+
+    if (help_func && help_func != Py_None) {
+        g_object_set_data(self->obj, "pygimp-dialog-help-data", self);
+
+        Py_INCREF(help_func);
+        g_object_set_data_full(self->obj, "pygimp-dialog-help-func",
+                               help_func, pygimp_help_func_destroy);
+    }
+
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_DIALOG
+%%
+override gimp_color_button_get_color noargs
+static PyObject *
+_wrap_gimp_color_button_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_button_get_color(GIMP_COLOR_BUTTON(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_brush_select_button_get_brush noargs
+static PyObject *
+_wrap_gimp_brush_select_button_get_brush(PyGObject *self)
+{
+    const gchar *brush_name;
+    gdouble opacity;
+    gint spacing;
+    GimpLayerMode paint_mode;
+
+    brush_name =
+        gimp_brush_select_button_get_brush(GIMP_BRUSH_SELECT_BUTTON(self->obj),
+                                           &opacity, &spacing, &paint_mode);
+
+    return Py_BuildValue("(sdiN)", brush_name, opacity, spacing,
+                         pyg_enum_from_gtype(GIMP_TYPE_LAYER_MODE,
+                                             paint_mode));
+}
+%%
+override gimp_window_set_transient
+static PyObject *
+_wrap_gimp_window_set_transient(PyGObject *self)
+{
+    gimp_window_set_transient(GTK_WINDOW(self->obj));
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_color_button_new kwargs
+static int
+_wrap_gimp_color_button_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gchar *title = NULL;
+    gint width = -1, height = -1;
+    PyObject *py_color = NULL, *py_type = NULL;
+    GimpRGB *color, default_color = { 0.0, 0.0, 0.0, 100.0 };
+    GimpColorAreaType type;
+    
+    static char *kwlist[] = { "title", "width", "height", "color", "type",
+                              NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|ziiOO:gimpui.ColorButton.__init__",
+                                     kwlist,
+                                     &title, &width, &height,
+                                     &py_color, &py_type))
+        return -1;
+
+    if (py_color == NULL || (PyObject*)py_color == Py_None)
+        color = &default_color;
+    else if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
+        color = pyg_boxed_get(py_color, GimpRGB);
+    else {
+        PyErr_SetString(PyExc_TypeError, "color should be a GimpRGB or None");
+        return -1;
+    }
+
+    if (py_type == NULL || (PyObject*)py_type == Py_None)
+       type = GIMP_COLOR_AREA_FLAT;
+    else if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type,
+                                (gint*)&type))
+       return -1;
+
+    if (pygobject_construct(self,
+                            "title",       title,
+                            "type",        type,
+                            "color",       color,
+                            "area-width",  width,
+			    "area-height", height,
+                            NULL))
+        return -1;
+
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_COLOR_BUTTON
+%%
+override gimp_color_scale_new kwargs
+static int
+_wrap_gimp_color_scale_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_orientation, *py_channel;
+    GtkOrientation orientation;
+    GimpColorSelectorChannel channel;
+
+    static char *kwlist[] = { "orientation", "channel", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "OO:gimpui.ColorScale.__init__",
+                                     kwlist,
+                                     &py_orientation, &py_channel))
+        return -1;
+
+    if (pyg_enum_get_value(GTK_TYPE_ORIENTATION, py_orientation,
+                           (gint*)&orientation))
+        return -1;
+
+    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, 
+                           (gint*)&channel))
+        return -1;
+
+    if (pygobject_construct(self,
+                            "orientation", orientation,
+                            "channel",     channel,
+                            NULL))
+        return -1;
+
+    gtk_range_set_flippable (GTK_RANGE (self->obj),
+                             orientation == GTK_ORIENTATION_HORIZONTAL);
+    
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_COLOR_SCALE
+%%
+override gimp_enum_label_new kwargs
+static int
+_wrap_gimp_enum_label_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_enum_type = NULL;
+    GType enum_type;
+    gint value;
+
+    static char *kwlist[] = { "enum_type", "value", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "Oi:gimpui.GimpEnumLabel.__init__",
+                                     kwlist,
+                                     &py_enum_type, &value))
+        return -1;
+
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return -1;
+
+    if (pygobject_construct(self,
+                            "enum-type",  enum_type,
+                            "enum-value", value,
+                            NULL))
+        return -1;
+
+    return 0; 
+}
+%%
+new-constructor GIMP_TYPE_ENUM_LABEL
+%%
+override gimp_int_combo_box_new kwargs
+static int
+_wrap_gimp_int_combo_box_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_items = NULL;
+    int len, i;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|O:gimpui.IntComboBox.__init__",
+                                     kwlist,
+                                     &py_items))
+        return -1; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return -1;
+    }
+
+    if (pygobject_construct(self, NULL))
+        return -1;
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return -1;
+        }
+
+        if (!PyInt_Check(value)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_int_combo_box_append(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_INT_COMBO_BOX
+%%
+override gimp_int_combo_box_set_sensitivity kwargs
+static gboolean
+pygimp_int_combo_box_sensitivity_marshal(gint value, gpointer user_data)
+{
+    PyObject *py_value;
+    PyGimpIntSensitivityData *data;
+    PyObject *ret;
+    gboolean res;
+
+    data = user_data;
+
+    py_value = PyInt_FromLong(value);
+
+    ret = PyObject_CallFunctionObjArgs(data->sensitivity_func, py_value,
+                                       data->user_data, NULL);
+    
+    if (!ret) {
+        PyErr_Print();
+        res = FALSE;
+    } else {
+        res = PyObject_IsTrue(ret);
+        Py_DECREF(ret);
+    }
+
+    Py_DECREF(py_value);
+
+    return res;
+}
+
+static void
+pygimp_int_combo_box_sensitivity_data_destroy(gpointer user_data)
+{
+    PyGimpIntSensitivityData *data;
+    data = user_data;
+
+    Py_DECREF(data->sensitivity_func);
+    Py_XDECREF(data->user_data);
+
+    g_free(data);
+}
+
+static PyObject *
+_wrap_gimp_int_combo_box_set_sensitivity(PyGObject *self, PyObject *args,
+                                         PyObject *kwargs)
+{
+    PyObject *py_sensitivity_func;
+    PyObject *py_user_data = NULL;
+    PyGimpIntSensitivityData *data;
+
+    static char *kwlist[] = { "sensitivity_func", "user_data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "O|O:GimpIntComboBox.set_sensitivity",
+                                     kwlist, &py_sensitivity_func,
+                                     &py_user_data))
+        return NULL;
+
+    if (!PyCallable_Check(py_sensitivity_func)) {
+        PyErr_SetString(PyExc_TypeError, "first argument must be callable.");
+        return NULL;
+    }
+
+    data = g_new(PyGimpIntSensitivityData, 1);
+
+    data->sensitivity_func = py_sensitivity_func;
+    Py_INCREF(data->sensitivity_func);
+    
+   if (py_user_data == NULL || py_user_data == Py_None)
+        data->user_data = NULL;
+    else {
+       data->user_data = py_user_data;
+       Py_INCREF(data->user_data);
+    }
+
+    gimp_int_combo_box_set_sensitivity(GIMP_INT_COMBO_BOX(self->obj),
+                                pygimp_int_combo_box_sensitivity_marshal,
+                                data,
+                                pygimp_int_combo_box_sensitivity_data_destroy);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_int_combo_box_get_active noargs
+static PyObject *
+_wrap_gimp_int_combo_box_get_active(PyGObject *self)
+{
+    int value;
+
+    if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(self->obj), &value))
+        return PyLong_FromLong(value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_int_combo_box_set_active kwargs
+static PyObject *
+_wrap_gimp_int_combo_box_set_active(PyGObject *self, PyObject *args,
+                                    PyObject *kwargs)
+{
+    int value;
+
+    static char *kwlist[] = { "value", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "i:GimpIntComboBox.set_active", kwlist,
+                                     &value))
+        return NULL;
+
+    if (!gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(self->obj), value)) {
+        PyErr_Format(pygimp_error,
+                     "Value %d does not exist in GimpIntComboBox",
+                     value);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_int_combo_box_append kwargs
+static PyObject *
+_wrap_gimp_int_combo_box_append(PyGObject *self, PyObject *args,
+                                PyObject *kwargs)
+{
+    PyObject *py_items;
+    int i, len;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O:gimpui.IntComboBox.append",
+                                     kwlist,
+                                     &py_items))
+        return NULL; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return NULL;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return NULL;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return NULL;
+        }
+
+        if (!PyInt_Check(value)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return NULL;
+        }
+
+        gimp_int_combo_box_append(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_int_combo_box_prepend kwargs
+static PyObject *
+_wrap_gimp_int_combo_box_prepend(PyGObject *self, PyObject *args,
+                                 PyObject *kwargs)
+{
+    PyObject *py_items;
+    int i, len;
+
+    static char *kwlist[] = { "items", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O:gimpui.IntComboBox.prepend",
+                                     kwlist,
+                                     &py_items))
+        return NULL; 
+
+    if (py_items == NULL || py_items == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_items))
+        len = PyTuple_Size(py_items);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "items must be a tuple containing label/value pairs "
+                        "or None");
+        return NULL;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "items tuple must contain label/value pairs");
+        return NULL;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *label = PyTuple_GetItem(py_items, i);
+        PyObject *value = PyTuple_GetItem(py_items, i + 1);
+
+        if (!PyString_Check(label)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each label/value pair "
+                            "must be a string");
+            return NULL;
+        }
+
+        if (!PyInt_Check(value)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each label/value pair "
+                            "must be a number");
+            return NULL;
+        }
+
+        gimp_int_combo_box_prepend(GIMP_INT_COMBO_BOX(self->obj),
+                                  GIMP_INT_STORE_LABEL,
+                                  PyString_AsString(label),
+                                  GIMP_INT_STORE_VALUE,
+                                  PyInt_AsLong(value),
+                                  -1);
+    }
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_browser_add_search_types args
+static PyObject *
+_wrap_gimp_browser_add_search_types(PyGObject *self, PyObject *args)
+{
+    GimpBrowser *browser;
+    int len, i;
+    PyObject *element;
+    gchar *label;
+    gint id;
+
+    browser = GIMP_BROWSER(self->obj);
+
+    len = PyTuple_Size(args);
+
+    for (i = 0; i < len; ++i) {
+        element = PyTuple_GetItem(args, i);
+        if (!PyTuple_Check(element)) {
+            PyErr_SetString(PyExc_TypeError, "GimpBrowser.add_search_types: Arguments must be tuples");
+            return NULL;
+        }
+        if (!PyArg_ParseTuple(element, "si",  &label, &id))
+            return NULL;
+        gimp_browser_add_search_types(browser, label, id, NULL);
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_proc_browser_dialog_new kwargs
+static int
+_wrap_gimp_proc_browser_dialog_new(PyGObject *self, PyObject *args,
+                                   PyObject *kwargs)
+{
+    gchar *title, *role;
+    PyObject *py_buttons = Py_None;
+    PyObject *help_func = NULL;
+    gchar *help_id = NULL;
+    int len, i;
+    GimpHelpFunc func;
+
+    static char *kwlist[] = { "title", "role", "help_func", "help_id",
+                              "buttons", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "zz|OzO:gimpui.GimpProcBrowserDialog.__init__",
+                                     kwlist,
+                                     &title, &role, &help_func, &help_id,
+                                     &py_buttons))
+        return -1;
+
+    if (py_buttons == Py_None)
+        len = 0;
+    else if (PyTuple_Check(py_buttons))
+        len = PyTuple_Size(py_buttons);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "buttons must be a tuple containing text/response "
+                        "pairs or None");
+        return -1;
+    }
+
+    if (len % 2) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "buttons tuple must contain text/response id pairs");
+        return -1;
+    }
+
+    if (help_func) {
+        if (help_func != Py_None) {
+            if (!PyCallable_Check(help_func)) {
+                PyErr_SetString(PyExc_TypeError, "help_func must be callable");
+                return -1;
+            }
+
+            func = pygimp_help_func_marshal;
+
+       } else {
+            func = gimp_standard_help_func;
+        }
+    } else {
+        func = gimp_standard_help_func;
+    }
+
+    pygobject_construct(self,
+                        "title",     title,
+                        "role",      role,
+                        "help-func", func,
+                        "help-id",   help_id,
+                        NULL);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpProcBrowserDialog object");
+        return -1;
+    }
+
+    for (i = 0; i < len; i += 2) {
+        PyObject *text = PyTuple_GetItem(py_buttons, i);
+        PyObject *id = PyTuple_GetItem(py_buttons, i + 1);
+        if (!PyString_Check(text) && !PyUnicode_Check(text)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "first member of each text/response id pair "
+                            "must be a string");
+            return -1;
+        }
+        if (!PyInt_Check(id)) {
+            gtk_object_destroy(GTK_OBJECT(self->obj));
+            self->obj = NULL;
+            PyErr_SetString(PyExc_RuntimeError,
+                            "second member of each text/response id pair "
+                            "must be a number");
+            return -1;
+        }
+
+        gimp_dialog_add_button(GIMP_DIALOG(self->obj), PyString_AsString(text),
+                               PyInt_AsLong(id));
+    }
+
+    if (help_func && help_func != Py_None) {
+        g_object_set_data(self->obj, "pygimp-dialog-help-data", self);
+
+        Py_INCREF(help_func);
+        g_object_set_data_full(self->obj, "pygimp-dialog-help-func",
+                               help_func, pygimp_help_func_destroy);
+    }
+
+    g_signal_emit_by_name(GIMP_PROC_BROWSER_DIALOG(self->obj)->browser,
+                          "search", "", 0, self->obj);
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_PROC_BROWSER_DIALOG
+%%
+override gimp_number_pair_entry_get_values noargs
+static PyObject *
+_wrap_gimp_number_pair_entry_get_values(PyGObject *self)
+{
+    gdouble left, right;
+
+    gimp_number_pair_entry_get_values(GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                      &left, &right);
+
+    return Py_BuildValue("(dd)", left, right);   
+}
+%%
+override gimp_number_pair_entry_get_default_values noargs
+static PyObject *
+_wrap_gimp_number_pair_entry_get_default_values(PyGObject *self)
+{
+    gdouble left, right;
+
+    gimp_number_pair_entry_get_default_values(
+                                             GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                             &left, &right);
+
+    return Py_BuildValue("(dd)", left, right);
+}
+%%
+override gimp_number_pair_entry_get_aspect noargs
+static PyObject *
+_wrap_gimp_number_pair_entry_get_aspect(PyGObject *self)
+{
+    GimpAspectType aspect;
+
+    aspect =
+          gimp_number_pair_entry_get_aspect(GIMP_NUMBER_PAIR_ENTRY(self->obj));
+
+    return pyg_enum_from_gtype(GIMP_TYPE_ASPECT_TYPE, aspect);
+}
+%%
+override gimp_number_pair_entry_set_aspect kwargs
+static PyObject *
+_wrap_gimp_number_pair_entry_set_aspect(PyGObject *self, PyObject *args,
+                                        PyObject *kwargs)
+{
+    PyObject *py_aspect;
+    GimpAspectType aspect;
+
+    static char *kwlist[] = {"aspect", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                    "O:GimpNumberPairEntry.set_aspect",
+                                    kwlist, &py_aspect))
+        return NULL;
+
+    if (pyg_enum_get_value(GIMP_TYPE_ASPECT_TYPE, py_aspect, (gint*)&aspect))
+    {
+        Py_XDECREF(py_aspect);
+        return NULL;
+    }
+
+    gimp_number_pair_entry_set_aspect(GIMP_NUMBER_PAIR_ENTRY(self->obj),
+                                      aspect);
+
+    Py_DECREF(py_aspect);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_page_selector_get_selected_pages noargs
+static PyObject *
+_wrap_gimp_page_selector_get_selected_pages(PyGObject *self)
+{
+    gint *selected_pages;
+    gint n_selected_pages;
+    PyObject *py_selected_pages;
+    int i;
+
+    selected_pages = gimp_page_selector_get_selected_pages(
+                                                GIMP_PAGE_SELECTOR (self->obj),
+                                                &n_selected_pages);
+    
+    py_selected_pages = PyTuple_New(n_selected_pages);
+    for (i = 0; i < n_selected_pages; ++i)
+        PyTuple_SetItem(py_selected_pages, i,
+                        PyInt_FromLong(selected_pages[i]));
+
+    g_free(selected_pages);
+
+    return py_selected_pages;
+}
+%%
+override gimp_preview_get_position noargs
+static PyObject *
+_wrap_gimp_preview_get_position(PyGObject *self)
+{
+    gint x;
+    gint y;
+  
+    gimp_preview_get_position(GIMP_PREVIEW(self->obj), &x, &y);
+
+    return Py_BuildValue("(ii)", x, y);
+}
+%%
+override gimp_preview_get_size noargs
+static PyObject *
+_wrap_gimp_preview_get_size(PyGObject *self)
+{
+    gint width;
+    gint height;
+  
+    gimp_preview_get_size(GIMP_PREVIEW(self->obj), &width, &height);
+
+    return Py_BuildValue("(ii)", width, height);
+}
+%%
+override gimp_preview_transform kwargs
+static PyObject *
+_wrap_gimp_preview_transform(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    gint src_x;
+    gint src_y;
+    gint dest_x;
+    gint dest_y;
+
+    static char *kwlist[] = {"x", "y", NULL};
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:GimpPreview.transform",
+                                     kwlist, &src_x, &src_y))
+        return NULL;
+
+    gimp_preview_transform(GIMP_PREVIEW(self->obj), src_x, src_y, &dest_x,
+                           &dest_y);
+
+    return Py_BuildValue("(ii)", dest_x, dest_y);
+}
+%%
+override gimp_preview_untransform kwargs
+static PyObject *
+_wrap_gimp_preview_untransform(PyGObject *self, PyObject *args,
+                               PyObject *kwargs)
+{
+    gint src_x;
+    gint src_y;
+    gint dest_x;
+    gint dest_y;
+
+    static char *kwlist[] = {"x", "y", NULL};
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "ii:GimpPreview.untransform",
+                                     kwlist, &src_x, &src_y))
+        return NULL;
+
+    gimp_preview_untransform(GIMP_PREVIEW(self->obj), src_x, src_y, &dest_x,
+                             &dest_y);
+
+    return Py_BuildValue("(ii)", dest_x, dest_y);
+}
+%%
+override gimp_zoom_model_get_fraction noargs
+static PyObject *
+_wrap_gimp_zoom_model_get_fraction(PyGObject *self)
+{
+    gint numerator;
+    gint denominator;
+
+    gimp_zoom_model_get_fraction(GIMP_ZOOM_MODEL(self->obj), &numerator,
+                                 &denominator);
+
+    return Py_BuildValue("(ii)", numerator, denominator);
+}
+%%
+override gimp_drawable_preview_get_drawable noargs
+static PyObject *
+_wrap_gimp_drawable_preview_get_drawable(PyGObject *self)
+{
+    PyObject *drawable;
+    
+    drawable = g_object_get_data(self->obj, 
+                                 "pygimp-drawable-preview-pydrawable");
+    Py_INCREF(drawable);
+    return drawable;
+}
+%%
+override gimp_zoom_preview_get_drawable noargs
+static PyObject *
+_wrap_gimp_zoom_preview_get_drawable(PyGObject *self)
+{
+    PyObject *drawable;
+    
+    drawable = g_object_get_data(self->obj,
+                                 "pygimp-zoom-preview-pydrawable");
+    Py_INCREF(drawable);
+    return drawable;
+}
+%%
+override gimp_drawable_preview_draw_region kwargs
+static PyObject *
+_wrap_gimp_drawable_preview_draw_region(PyGObject *self, PyObject *args,
+                                        PyObject *kwargs)
+{
+/*    PyGimpPixelRgn *pypixelrgn;
+
+    static char *kwlist[] = {"drawable", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                    "O!:GimpDrawablePreview.draw_region",
+                                    kwlist, PyGimpPixelRgn_Type, &pypixelrgn))
+        return NULL;
+
+    gimp_drawable_preview_draw_region(GIMP_DRAWABLE_PREVIEW(self->obj),
+                                      &pypixelrgn->pr);
+*/
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_int_store_lookup_by_value
+static PyObject *
+_wrap_gimp_int_store_lookup_by_value(PyGObject *self, PyObject *args,
+                                     PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", NULL };
+    int value, ret;
+    GtkTreeIter iter;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                               "i:GimpIntStore.gimp_int_store_lookup_by_value",
+                               kwlist, &value))
+        return NULL;
+
+    ret = gimp_int_store_lookup_by_value(GTK_TREE_MODEL(self->obj), value,
+                                         &iter);
+    if (ret)
+        pyg_boxed_new(GTK_TYPE_TREE_ITER, &iter, TRUE, TRUE);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_memsize_entry_new
+static int
+_wrap_gimp_memsize_entry_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", "lower", "upper", NULL };
+    guint64 value, lower, upper;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "LLL:GimpMemsizeEntry.__init__",
+                                     kwlist, &value, &lower, &upper))
+        return -1;
+    
+    self->obj = (GObject *)gimp_memsize_entry_new(value, lower, upper);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "could not create GimpMemsizeEntry object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+override gimp_memsize_entry_set_value
+static PyObject *
+_wrap_gimp_memsize_entry_set_value(PyGObject *self, PyObject *args,
+                                   PyObject *kwargs)
+{
+    static char *kwlist[] = { "value", NULL };
+    guint64 value;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "L:GimpMemsizeEntry.set_value",
+                                     kwlist, &value))
+        return NULL;
+
+    gimp_memsize_entry_set_value(GIMP_MEMSIZE_ENTRY(self->obj), value);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gimp_color_area_get_color noargs
+static PyObject *
+_wrap_gimp_color_area_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_area_get_color(GIMP_COLOR_AREA(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_color_hex_entry_get_color noargs
+static PyObject *
+_wrap_gimp_color_hex_entry_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_hex_entry_get_color(GIMP_COLOR_HEX_ENTRY(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_color_notebook_get_color noargs
+static PyObject *
+_wrap_gimp_color_notebook_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_notebook_get_color(GIMP_COLOR_NOTEBOOK(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_color_selection_get_color noargs
+static PyObject *
+_wrap_gimp_color_selection_get_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_selection_get_color(GIMP_COLOR_SELECTION(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_color_selection_get_old_color noargs
+static PyObject *
+_wrap_gimp_color_selection_get_old_color(PyGObject *self)
+{
+    GimpRGB rgb;
+
+    gimp_color_selection_get_old_color(GIMP_COLOR_SELECTION(self->obj), &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+%%
+override gimp_enum_store_new kwargs
+static int
+_wrap_gimp_enum_store_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "enum_type", "minimum", "maximum", NULL };
+    PyObject *py_enum_type = NULL;
+    PyObject *py_minimum = NULL;
+    PyObject *py_maximum = NULL;
+    GType enum_type;
+    GEnumClass *enum_class;
+    gint minimum, maximum;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O|O!O!:GimpEnumStore.__init__", kwlist,
+                                      &py_enum_type, &PyInt_Type, &py_minimum,
+                                      &PyInt_Type, &py_maximum))
+        return -1;
+    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
+        return -1;
+
+    enum_class = g_type_class_ref(enum_type);
+
+    if (py_minimum == NULL)
+        minimum = enum_class->minimum;
+    else
+        minimum = PyInt_AsLong(py_minimum);
+    
+    if (py_maximum == NULL)
+        maximum = enum_class->maximum;
+    else
+        maximum = PyInt_AsLong(py_maximum);
+    
+    g_type_class_unref(enum_class);
+
+    self->obj = (GObject *)gimp_enum_store_new_with_range(enum_type, minimum, maximum);
+
+    if (!self->obj) {
+        PyErr_SetString(PyExc_RuntimeError, "could not create GimpEnumStore object");
+        return -1;
+    }
+    pygobject_register_wrapper((PyObject *)self);
+    return 0;
+}
+%%
+override gimp_zoom_preview_new_with_model kwargs
+static int
+_wrap_gimp_zoom_preview_new_with_model(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", "model", NULL };
+    PyGimpDrawable *py_drawable;
+    PyGObject *py_zoom_model = NULL;
+    GimpZoomModel *zoom_model;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|O!:GimpZoomPreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable,
+                                     &PyGimpZoomModel_Type, &py_zoom_model))
+        return -1;
+
+    if (py_zoom_model)
+        zoom_model = (GimpZoomModel*)py_zoom_model->obj;
+    else
+        zoom_model = NULL;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, "model", zoom_model, NULL))
+        return -1;
+
+    g_object_set_data_full(self->obj, "pygimp-zoom-preview-pydrawable",
+                           py_drawable,
+                           (GDestroyNotify)pygimp_decref_callback);
+
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_ZOOM_PREVIEW
+%%
+override gimp_aspect_preview_new kwargs
+static int
+_wrap_gimp_aspect_preview_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", NULL };
+    PyGimpDrawable *py_drawable;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|:GimpAspectPreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable))
+        return -1;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+    
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, NULL))
+        return -1;
+    
+    g_signal_connect_swapped(self->obj, "destroy",
+                             (GCallback)pygimp_decref_callback, py_drawable);
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+%%
+new-constructor GIMP_TYPE_ASPECT_PREVIEW
+%%
+override gimp_drawable_preview_new kwargs
+static int
+_wrap_gimp_drawable_preview_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "drawable", NULL };
+    PyGimpDrawable *py_drawable;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|:GimpDrawablePreview.__init__", kwlist,
+                                     PyGimpDrawable_Type, &py_drawable))
+        return -1;
+
+    if (!py_drawable->drawable)
+        py_drawable->drawable = gimp_drawable_get(py_drawable->ID);
+  
+    if (pygobject_construct(self, "drawable", py_drawable->drawable, NULL))
+        return -1;
+
+    g_object_set_data_full(self->obj, "pygimp-drawable-preview-pydrawable",
+                           py_drawable, 
+                           (GDestroyNotify)pygimp_decref_callback);
+
+    Py_INCREF(py_drawable);
+
+    return 0;
+}
+
+%%
+new-constructor GIMP_TYPE_DRAWABLE_PREVIEW
+%%
+override gimp_ruler_get_range noargs
+static PyObject *
+_wrap_gimp_ruler_get_range(PyGObject *self)
+{
+    gdouble lower, upper, max_size;
+
+    gimp_ruler_get_range(GIMP_RULER(self->obj), &lower, &upper, &max_size);
+
+    return Py_BuildValue("(ddd)", lower, upper, max_size);
+}
+%%
+override gimp_color_display_convert_surface kwargs
+static PyObject *
+_wrap_gimp_color_display_convert_surface(PyGObject *self, PyObject *args,
+                                         PyObject *kwargs)
+{
+  PycairoSurface *pysurface;
+
+  static char *kwlist[] = { "surface", NULL };
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                   "O!:GimpColorDisplay.convert_surface",
+                                   kwlist,
+                                   &PycairoSurface_Type, &pysurface))
+    return NULL;
+
+  gimp_color_display_convert_surface(GIMP_COLOR_DISPLAY(self->obj),
+                                     pysurface->surface);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+%%
+override gimp_color_display_stack_convert_surface kwargs
+static PyObject *
+_wrap_gimp_color_display_stack_convert_surface(PyGObject *self, PyObject *args,
+                                               PyObject *kwargs)
+{
+  PycairoSurface *pysurface;
+
+  static char *kwlist[] = { "surface", NULL };
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                   "O!:GimpColorDisplayStack.convert_surface",
+                                   kwlist,
+                                   &PycairoSurface_Type, &pysurface))
+    return NULL;
+
+  gimp_color_display_stack_convert_surface(GIMP_COLOR_DISPLAY_STACK(self->obj),
+                                           pysurface->surface);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+%%
+override gimp_zoom_preview_get_source noargs
+static PyObject *
+_wrap_gimp_zoom_preview_get_source(PyGObject *self)
+{
+  gint width, height, bpp;
+  guchar *image;
+  PyObject *pyimage;
+
+  image = gimp_zoom_preview_get_source(GIMP_ZOOM_PREVIEW(self->obj),
+                                       &width, &height, &bpp);
+
+  if (image)
+    {
+      pyimage = PyByteArray_FromStringAndSize((const char *)image,
+                                              width * height * bpp);
+      g_free (image);
+    }
+  else
+    {
+      Py_INCREF(Py_None);
+      pyimage = Py_None;
+    }
+
+  return Py_BuildValue("(Niii)", pyimage, width, height, bpp);
+}
+%%
+override gimp_ui_init noargs
+static PyObject *
+_wrap_gimp_ui_init(PyObject *self)
+{
+  extern const char *prog_name;
+
+  gimp_ui_init (prog_name, FALSE);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
diff --git a/plug-ins/pygimp/gimpui.py b/plug-ins/pygimp/gimpui.py
new file mode 100644
index 0000000..76ee584
--- /dev/null
+++ b/plug-ins/pygimp/gimpui.py
@@ -0,0 +1,227 @@
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#    This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+'''This module implements the UI items found in the libgimpui library.
+It requires pygtk to work.  These functions take use to callbacks -- one
+is a constraint function, and the other is the callback object.  The
+constraint function takes an image object as its first argument, and
+a drawable object as its second if appropriate.  The callback functions
+get the selected object as their first argument, and the user data as
+the second.
+
+It also implements a number of selector widgets, which can be used to select
+various gimp data types.  Each of these selectors takes default as an argument
+to the constructor, and has a get_value() method for retrieving the result.
+'''
+
+import pygtk
+pygtk.require('2.0')
+
+import gtk, gobject, gimp, gimpcolor
+
+from _gimpui import *
+
+import gettext
+t = gettext.translation('gimp20-python', gimp.locale_directory, fallback=True)
+_ = t.ugettext
+
+def _callbackWrapper(menu_item, callback, data):
+    callback(menu_item.get_data("Gimp-ID"), data)
+
+def _createMenu(items, callback, data):
+    menu = gtk.Menu()
+    if not items:
+        items = [("(none)", None)]
+    for label, id in items:
+        menu_item = gtk.MenuItem(label)
+        menu_item.set_data("Gimp-ID", id)
+        menu.add(menu_item)
+        if callback:
+            menu_item.connect("activate", _callbackWrapper,
+                              callback, data)
+        menu_item.show()
+    return menu
+
+
+def ImageMenu(constraint=None, callback=None, data=None):
+    items = []
+    for img in gimp.image_list():
+        if constraint and not constraint(img):
+            continue
+        if not img.filename:
+            filename = img.name
+        else:
+            filename = img.filename
+        items.append((filename, img))
+    items.sort()
+    return _createMenu(items, callback, data)
+
+def LayerMenu(constraint=None, callback=None, data=None):
+    items = []
+    for img in gimp.image_list():
+        filename = img.filename
+        if not filename:
+            filename = img.name
+        for layer in img.layers:
+            if constraint and not constraint(img, layer):
+                continue
+            name = filename + "/" + layer.name
+            items.append((name, layer))
+    items.sort()
+    return _createMenu(items, callback, data)
+
+def ChannelMenu(constraint=None, callback=None, data=None):
+    items = []
+    for img in gimp.image_list():
+        filename = img.filename
+        if not filename:
+            filename = img.name
+        for channel in img.channels:
+            if constraint and not constraint(img, channel):
+                continue
+            name = filename + "/" + channel.name
+            items.append((name, channel))
+    items.sort()
+    return _createMenu(items, callback, data)
+
+def DrawableMenu(constraint=None, callback=None, data=None):
+    items = []
+    for img in gimp.image_list():
+        filename = img.filename
+        if not filename:
+            filename = img.name
+        for drawable in img.layers + img.channels:
+            if constraint and not constraint(img, drawable):
+                continue
+            name = filename + "/" + drawable.name
+            items.append((name, drawable))
+    items.sort()
+    return _createMenu(items, callback, data)
+
+def VectorsMenu(constraint=None, callback=None, data=None):
+    items = []
+    for img in gimp.image_list():
+        filename = img.filename
+        if not filename:
+            filename = img.name
+        for vectors in img.vectors:
+            if constraint and not constraint(img, vectors):
+                continue
+            name = filename + "/" + vectors.name
+            items.append((name, vectors))
+    items.sort()
+    return _createMenu(items, callback, data)
+
+class ImageSelector(ImageComboBox):
+    def __init__(self, default=None):
+        ImageComboBox.__init__(self)
+        if default is not None:
+            self.set_active_image(default)
+    def get_value(self):
+        return self.get_active_image()
+
+class LayerSelector(LayerComboBox):
+    def __init__(self, default=None):
+        LayerComboBox.__init__(self)
+        if default is not None:
+            self.set_active_layer(default)
+    def get_value(self):
+        return self.get_active_layer()
+
+class ChannelSelector(ChannelComboBox):
+    def __init__(self, default=None):
+        ChannelComboBox.__init__(self)
+        if default is not None:
+            self.set_active_channel(default)
+    def get_value(self):
+        return self.get_active_channel()
+
+class DrawableSelector(DrawableComboBox):
+    def __init__(self, default=None):
+        DrawableComboBox.__init__(self)
+        if default is not None:
+            self.set_active_drawable(default)
+    def get_value(self):
+        return self.get_active_drawable()
+
+class VectorsSelector(VectorsComboBox):
+    def __init__(self, default=None):
+        VectorsComboBox.__init__(self)
+        if default is not None:
+            self.set_active_vectors(default)
+    def get_value(self):
+        return self.get_active_vectors()
+
+class ColorSelector(ColorButton):
+    def __init__(self, default=gimpcolor.RGB(1.0, 0, 0)):
+        if isinstance(default, gimpcolor.RGB):
+            color = default
+        elif isinstance(default, tuple):
+            color = apply(gimpcolor.RGB, default)
+        elif isinstance(default, str):
+            color = gimpcolor.rgb_parse_css(default)
+        ColorButton.__init__(self, _("Python-Fu Color Selection"), 100, 20,
+                             color, COLOR_AREA_FLAT)
+    def get_value(self):
+        return self.get_color();
+
+class PatternSelector(PatternSelectButton):
+    def __init__(self, default=""):
+        PatternSelectButton.__init__(self)
+        if default:
+            self.set_pattern(default)
+    def get_value(self):
+        return self.get_pattern()
+
+class BrushSelector(BrushSelectButton):
+    def __init__(self, default=""):
+        BrushSelectButton.__init__(self)
+        if default:
+            self.set_brush(default, -1.0, -1, -1)
+    def get_value(self):
+        return self.get_brush()[0]
+
+class GradientSelector(GradientSelectButton):
+    def __init__(self, default=""):
+        GradientSelectButton.__init__(self)
+        if default:
+            self.set_gradient(default)
+    def get_value(self):
+        return self.get_gradient()
+
+class PaletteSelector(PaletteSelectButton):
+    def __init__(self, default=""):
+        PaletteSelectButton.__init__(self)
+        if default:
+            self.set_palette(default)
+    def get_value(self):
+        return self.get_palette()
+
+class FontSelector(FontSelectButton):
+    def __init__(self, default="Sans"):
+        FontSelectButton.__init__(self)
+        if default:
+            self.set_font(default)
+    def get_value(self):
+        return self.get_font()
+
+class FileSelector(gtk.FileChooserButton):
+    def __init__(self, default=""):
+        gtk.FileChooserButton.__init__(self, _("Python-Fu File Selection"))
+        if default:
+            self.set_filename(default)
+    def get_value(self):
+        return self.get_filename()
diff --git a/plug-ins/pygimp/gimpuimodule.c b/plug-ins/pygimp/gimpuimodule.c
new file mode 100644
index 0000000..ab4e31d
--- /dev/null
+++ b/plug-ins/pygimp/gimpuimodule.c
@@ -0,0 +1,97 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <Python.h>
+
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+#include <pycairo.h>
+Pycairo_CAPI_t *Pycairo_CAPI;
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "pygimpcolor-api.h"
+#include "pygimp-api.h"
+#include "pygimp-util.h"
+
+
+void gimpui_register_classes(PyObject *d);
+void gimpui_add_constants(PyObject *module, const gchar *strip_prefix);
+extern PyMethodDef gimpui_functions[];
+
+
+static char gimpui_doc[] =
+"This module provides interfaces to allow you to write gimp plug-ins"
+;
+
+void init_gimpui(void);
+
+static gboolean
+init_pycairo(void)
+{
+  Pycairo_IMPORT;
+  if (Pycairo_CAPI == NULL)
+    return FALSE;
+
+  return TRUE;
+}
+
+extern const char *prog_name;
+
+const char *prog_name = "pygimp";
+
+PyMODINIT_FUNC
+init_gimpui(void)
+{
+    PyObject *m, *d;
+    PyObject *av;
+
+    av = PySys_GetObject("argv");
+    if (av != NULL) {
+	if (PyList_Check(av) && PyList_Size(av) > 0 &&
+	    PyString_Check(PyList_GetItem(av, 0)))
+	    prog_name = PyString_AsString(PyList_GetItem(av, 0));
+	else
+	    PyErr_Warn(PyExc_Warning,
+		       "ignoring sys.argv: it must be a list of strings");
+    }
+
+
+    pygimp_init_pygobject();
+
+    init_pygtk();
+    if (!init_pycairo())
+      return;
+    init_pygimpcolor();
+    init_pygimp();
+
+    m = Py_InitModule3("_gimpui", gimpui_functions, gimpui_doc);
+    d = PyModule_GetDict(m);
+
+    gimpui_register_classes(d);
+    gimpui_add_constants(m, "GIMP_");
+
+    if (PyErr_Occurred())
+	Py_FatalError("can't initialize module _gimpui");
+}
diff --git a/plug-ins/pygimp/plug-ins/Makefile.am b/plug-ins/pygimp/plug-ins/Makefile.am
new file mode 100644
index 0000000..751f524
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/Makefile.am
@@ -0,0 +1,64 @@
+## Process this file with automake to produce Makefile.in
+
+pluginexecdir = $(gimpplugindir)/plug-ins
+
+source_scripts = \
+	colorxhtml.py			\
+	file-openraster.py		\
+	foggify.py			\
+	gradients-save-as-css.py	\
+	histogram-export.py     	\
+	palette-offset.py		\
+	palette-sort.py			\
+	palette-to-gradient.py		\
+	py-slice.py			\
+	python-eval.py			\
+	spyro_plus.py			\
+					\
+	benchmark-foreground-extract.py	\
+	clothify.py			\
+	shadow_bevel.py			\
+	sphere.py			\
+	whirlpinch.py
+
+scripts = \
+	colorxhtml/colorxhtml.py			\
+	file-openraster/file-openraster.py		\
+	foggify/foggify.py				\
+	gradients-save-as-css/gradients-save-as-css.py	\
+	histogram-export/histogram-export.py     	\
+	palette-offset/palette-offset.py		\
+	palette-sort/palette-sort.py			\
+	palette-to-gradient/palette-to-gradient.py	\
+	py-slice/py-slice.py				\
+	python-eval/python-eval.py			\
+	spyro_plus/spyro_plus.py
+
+test_scripts = \
+	benchmark-foreground-extract/benchmark-foreground-extract.py	\
+	clothify/clothify.py						\
+	shadow_bevel/shadow_bevel.py					\
+	sphere/sphere.py						\
+	whirlpinch/whirlpinch.py
+
+$(scripts) $(test_scripts): $(source_scripts)
+	$(AM_V_GEN) mkdir -p $(@D) && cp -f "$(srcdir)/$(@F)" $@
+
+nobase_pluginexec_SCRIPTS = $(scripts)
+
+if GIMP_UNSTABLE
+nobase_pluginexec_SCRIPTS += $(test_scripts)
+endif
+
+# python-console has a data file.
+# Therefore let's move it to its own sub-directory.
+consoleexecdir = $(gimpplugindir)/plug-ins/python-console
+console_scripts = python-console.py
+consoleexec_SCRIPTS = $(console_scripts)
+dist_consoleexec_DATA = pyconsole.py
+
+EXTRA_DIST = \
+	$(source_scripts)	\
+	$(console_scripts)
+
+CLEANFILES = $(scripts) $(test_scripts)
diff --git a/plug-ins/pygimp/plug-ins/Makefile.in b/plug-ins/pygimp/plug-ins/Makefile.in
new file mode 100644
index 0000000..a7c7feb
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/Makefile.in
@@ -0,0 +1,946 @@
+# Makefile.in generated by automake 1.16.3 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2020 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@GIMP_UNSTABLE_TRUE@am__append_1 = $(test_scripts)
+subdir = plug-ins/pygimp/plug-ins
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/m4macros/alsa.m4 \
+	$(top_srcdir)/m4macros/ax_compare_version.m4 \
+	$(top_srcdir)/m4macros/ax_cxx_compile_stdcxx.m4 \
+	$(top_srcdir)/m4macros/ax_gcc_func_attribute.m4 \
+	$(top_srcdir)/m4macros/ax_prog_cc_for_build.m4 \
+	$(top_srcdir)/m4macros/ax_prog_perl_version.m4 \
+	$(top_srcdir)/m4macros/detectcflags.m4 \
+	$(top_srcdir)/m4macros/pythondev.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(dist_consoleexec_DATA) \
+	$(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(consoleexecdir)" \
+	"$(DESTDIR)$(pluginexecdir)" "$(DESTDIR)$(consoleexecdir)"
+SCRIPTS = $(consoleexec_SCRIPTS) $(nobase_pluginexec_SCRIPTS)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+DATA = $(dist_consoleexec_DATA)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+am__DIST_COMMON = $(srcdir)/Makefile.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+AA_LIBS = @AA_LIBS@
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+ALL_LINGUAS = @ALL_LINGUAS@
+ALSA_CFLAGS = @ALSA_CFLAGS@
+ALSA_LIBS = @ALSA_LIBS@
+ALTIVEC_EXTRA_CFLAGS = @ALTIVEC_EXTRA_CFLAGS@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+APPSTREAM_UTIL = @APPSTREAM_UTIL@
+AR = @AR@
+AS = @AS@
+ATK_CFLAGS = @ATK_CFLAGS@
+ATK_LIBS = @ATK_LIBS@
+ATK_REQUIRED_VERSION = @ATK_REQUIRED_VERSION@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BABL_CFLAGS = @BABL_CFLAGS@
+BABL_LIBS = @BABL_LIBS@
+BABL_REQUIRED_VERSION = @BABL_REQUIRED_VERSION@
+BUG_REPORT_URL = @BUG_REPORT_URL@
+BUILD_EXEEXT = @BUILD_EXEEXT@
+BUILD_OBJEXT = @BUILD_OBJEXT@
+BZIP2_LIBS = @BZIP2_LIBS@
+CAIRO_CFLAGS = @CAIRO_CFLAGS@
+CAIRO_LIBS = @CAIRO_LIBS@
+CAIRO_PDF_CFLAGS = @CAIRO_PDF_CFLAGS@
+CAIRO_PDF_LIBS = @CAIRO_PDF_LIBS@
+CAIRO_PDF_REQUIRED_VERSION = @CAIRO_PDF_REQUIRED_VERSION@
+CAIRO_REQUIRED_VERSION = @CAIRO_REQUIRED_VERSION@
+CATALOGS = @CATALOGS@
+CATOBJEXT = @CATOBJEXT@
+CC = @CC@
+CCAS = @CCAS@
+CCASDEPMODE = @CCASDEPMODE@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CC_FOR_BUILD = @CC_FOR_BUILD@
+CC_VERSION = @CC_VERSION@
+CFLAGS = @CFLAGS@
+CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@
+CPP_FOR_BUILD = @CPP_FOR_BUILD@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DATADIRNAME = @DATADIRNAME@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DESKTOP_DATADIR = @DESKTOP_DATADIR@
+DESKTOP_FILE_VALIDATE = @DESKTOP_FILE_VALIDATE@
+DLLTOOL = @DLLTOOL@
+DOC_SHOOTER = @DOC_SHOOTER@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+FILE_AA = @FILE_AA@
+FILE_EXR = @FILE_EXR@
+FILE_HEIF = @FILE_HEIF@
+FILE_JP2_LOAD = @FILE_JP2_LOAD@
+FILE_JPEGXL = @FILE_JPEGXL@
+FILE_MNG = @FILE_MNG@
+FILE_PDF_SAVE = @FILE_PDF_SAVE@
+FILE_PS = @FILE_PS@
+FILE_WMF = @FILE_WMF@
+FILE_XMC = @FILE_XMC@
+FILE_XPM = @FILE_XPM@
+FONTCONFIG_CFLAGS = @FONTCONFIG_CFLAGS@
+FONTCONFIG_LIBS = @FONTCONFIG_LIBS@
+FONTCONFIG_REQUIRED_VERSION = @FONTCONFIG_REQUIRED_VERSION@
+FREETYPE2_REQUIRED_VERSION = @FREETYPE2_REQUIRED_VERSION@
+FREETYPE_CFLAGS = @FREETYPE_CFLAGS@
+FREETYPE_LIBS = @FREETYPE_LIBS@
+GDBUS_CODEGEN = @GDBUS_CODEGEN@
+GDK_PIXBUF_CFLAGS = @GDK_PIXBUF_CFLAGS@
+GDK_PIXBUF_CSOURCE = @GDK_PIXBUF_CSOURCE@
+GDK_PIXBUF_LIBS = @GDK_PIXBUF_LIBS@
+GDK_PIXBUF_REQUIRED_VERSION = @GDK_PIXBUF_REQUIRED_VERSION@
+GEGL = @GEGL@
+GEGL_CFLAGS = @GEGL_CFLAGS@
+GEGL_LIBS = @GEGL_LIBS@
+GEGL_MAJOR_MINOR_VERSION = @GEGL_MAJOR_MINOR_VERSION@
+GEGL_REQUIRED_VERSION = @GEGL_REQUIRED_VERSION@
+GETTEXT_PACKAGE = @GETTEXT_PACKAGE@
+GEXIV2_CFLAGS = @GEXIV2_CFLAGS@
+GEXIV2_LIBS = @GEXIV2_LIBS@
+GEXIV2_REQUIRED_VERSION = @GEXIV2_REQUIRED_VERSION@
+GIMP_API_VERSION = @GIMP_API_VERSION@
+GIMP_APP_VERSION = @GIMP_APP_VERSION@
+GIMP_BINARY_AGE = @GIMP_BINARY_AGE@
+GIMP_COMMAND = @GIMP_COMMAND@
+GIMP_DATA_VERSION = @GIMP_DATA_VERSION@
+GIMP_FULL_NAME = @GIMP_FULL_NAME@
+GIMP_INTERFACE_AGE = @GIMP_INTERFACE_AGE@
+GIMP_MAJOR_VERSION = @GIMP_MAJOR_VERSION@
+GIMP_MICRO_VERSION = @GIMP_MICRO_VERSION@
+GIMP_MINOR_VERSION = @GIMP_MINOR_VERSION@
+GIMP_MKENUMS = @GIMP_MKENUMS@
+GIMP_MODULES = @GIMP_MODULES@
+GIMP_PACKAGE_REVISION = @GIMP_PACKAGE_REVISION@
+GIMP_PKGCONFIG_VERSION = @GIMP_PKGCONFIG_VERSION@
+GIMP_PLUGINS = @GIMP_PLUGINS@
+GIMP_PLUGIN_VERSION = @GIMP_PLUGIN_VERSION@
+GIMP_REAL_VERSION = @GIMP_REAL_VERSION@
+GIMP_RELEASE = @GIMP_RELEASE@
+GIMP_SYSCONF_VERSION = @GIMP_SYSCONF_VERSION@
+GIMP_TOOL_VERSION = @GIMP_TOOL_VERSION@
+GIMP_UNSTABLE = @GIMP_UNSTABLE@
+GIMP_USER_VERSION = @GIMP_USER_VERSION@
+GIMP_VERSION = @GIMP_VERSION@
+GIO_CFLAGS = @GIO_CFLAGS@
+GIO_LIBS = @GIO_LIBS@
+GIO_UNIX_CFLAGS = @GIO_UNIX_CFLAGS@
+GIO_UNIX_LIBS = @GIO_UNIX_LIBS@
+GIO_WINDOWS_CFLAGS = @GIO_WINDOWS_CFLAGS@
+GIO_WINDOWS_LIBS = @GIO_WINDOWS_LIBS@
+GLIB_CFLAGS = @GLIB_CFLAGS@
+GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@
+GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
+GLIB_LIBS = @GLIB_LIBS@
+GLIB_MKENUMS = @GLIB_MKENUMS@
+GLIB_REQUIRED_VERSION = @GLIB_REQUIRED_VERSION@
+GMODULE_NO_EXPORT_CFLAGS = @GMODULE_NO_EXPORT_CFLAGS@
+GMODULE_NO_EXPORT_LIBS = @GMODULE_NO_EXPORT_LIBS@
+GMOFILES = @GMOFILES@
+GMSGFMT = @GMSGFMT@
+GOBJECT_QUERY = @GOBJECT_QUERY@
+GREP = @GREP@
+GS_LIBS = @GS_LIBS@
+GTKDOC_CHECK = @GTKDOC_CHECK@
+GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
+GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
+GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
+GTKDOC_MKPDF = @GTKDOC_MKPDF@
+GTKDOC_REBASE = @GTKDOC_REBASE@
+GTK_CFLAGS = @GTK_CFLAGS@
+GTK_LIBS = @GTK_LIBS@
+GTK_MAC_INTEGRATION_CFLAGS = @GTK_MAC_INTEGRATION_CFLAGS@
+GTK_MAC_INTEGRATION_LIBS = @GTK_MAC_INTEGRATION_LIBS@
+GTK_REQUIRED_VERSION = @GTK_REQUIRED_VERSION@
+GTK_UPDATE_ICON_CACHE = @GTK_UPDATE_ICON_CACHE@
+GUDEV_CFLAGS = @GUDEV_CFLAGS@
+GUDEV_LIBS = @GUDEV_LIBS@
+HARFBUZZ_CFLAGS = @HARFBUZZ_CFLAGS@
+HARFBUZZ_LIBS = @HARFBUZZ_LIBS@
+HARFBUZZ_REQUIRED_VERSION = @HARFBUZZ_REQUIRED_VERSION@
+HAVE_CXX14 = @HAVE_CXX14@
+HAVE_FINITE = @HAVE_FINITE@
+HAVE_ISFINITE = @HAVE_ISFINITE@
+HAVE_VFORK = @HAVE_VFORK@
+HOST_GLIB_COMPILE_RESOURCES = @HOST_GLIB_COMPILE_RESOURCES@
+HTML_DIR = @HTML_DIR@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INSTOBJEXT = @INSTOBJEXT@
+INTLLIBS = @INTLLIBS@
+INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@
+INTLTOOL_MERGE = @INTLTOOL_MERGE@
+INTLTOOL_PERL = @INTLTOOL_PERL@
+INTLTOOL_REQUIRED_VERSION = @INTLTOOL_REQUIRED_VERSION@
+INTLTOOL_UPDATE = @INTLTOOL_UPDATE@
+INTLTOOL_V_MERGE = @INTLTOOL_V_MERGE@
+INTLTOOL_V_MERGE_OPTIONS = @INTLTOOL_V_MERGE_OPTIONS@
+INTLTOOL__v_MERGE_ = @INTLTOOL__v_MERGE_@
+INTLTOOL__v_MERGE_0 = @INTLTOOL__v_MERGE_0@
+INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@
+ISO_CODES_LOCALEDIR = @ISO_CODES_LOCALEDIR@
+ISO_CODES_LOCATION = @ISO_CODES_LOCATION@
+JPEG_LIBS = @JPEG_LIBS@
+JSON_GLIB_CFLAGS = @JSON_GLIB_CFLAGS@
+JSON_GLIB_LIBS = @JSON_GLIB_LIBS@
+JXL_CFLAGS = @JXL_CFLAGS@
+JXL_LIBS = @JXL_LIBS@
+JXL_THREADS_CFLAGS = @JXL_THREADS_CFLAGS@
+JXL_THREADS_LIBS = @JXL_THREADS_LIBS@
+LCMS_CFLAGS = @LCMS_CFLAGS@
+LCMS_LIBS = @LCMS_LIBS@
+LCMS_REQUIRED_VERSION = @LCMS_REQUIRED_VERSION@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
+LIBBACKTRACE_LIBS = @LIBBACKTRACE_LIBS@
+LIBHEIF_CFLAGS = @LIBHEIF_CFLAGS@
+LIBHEIF_LIBS = @LIBHEIF_LIBS@
+LIBHEIF_REQUIRED_VERSION = @LIBHEIF_REQUIRED_VERSION@
+LIBJXL_REQUIRED_VERSION = @LIBJXL_REQUIRED_VERSION@
+LIBLZMA_REQUIRED_VERSION = @LIBLZMA_REQUIRED_VERSION@
+LIBMYPAINT_CFLAGS = @LIBMYPAINT_CFLAGS@
+LIBMYPAINT_LIBS = @LIBMYPAINT_LIBS@
+LIBMYPAINT_REQUIRED_VERSION = @LIBMYPAINT_REQUIRED_VERSION@
+LIBOBJS = @LIBOBJS@
+LIBPNG_REQUIRED_VERSION = @LIBPNG_REQUIRED_VERSION@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBUNWIND_CFLAGS = @LIBUNWIND_CFLAGS@
+LIBUNWIND_LIBS = @LIBUNWIND_LIBS@
+LIBUNWIND_REQUIRED_VERSION = @LIBUNWIND_REQUIRED_VERSION@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_CURRENT_MINUS_AGE = @LT_CURRENT_MINUS_AGE@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+LT_VERSION_INFO = @LT_VERSION_INFO@
+LZMA_CFLAGS = @LZMA_CFLAGS@
+LZMA_LIBS = @LZMA_LIBS@
+MAIL = @MAIL@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MIME_INFO_CFLAGS = @MIME_INFO_CFLAGS@
+MIME_INFO_LIBS = @MIME_INFO_LIBS@
+MIME_TYPES = @MIME_TYPES@
+MKDIR_P = @MKDIR_P@
+MKINSTALLDIRS = @MKINSTALLDIRS@
+MMX_EXTRA_CFLAGS = @MMX_EXTRA_CFLAGS@
+MNG_CFLAGS = @MNG_CFLAGS@
+MNG_LIBS = @MNG_LIBS@
+MSGFMT = @MSGFMT@
+MSGFMT_OPTS = @MSGFMT_OPTS@
+MSGMERGE = @MSGMERGE@
+MYPAINT_BRUSHES_CFLAGS = @MYPAINT_BRUSHES_CFLAGS@
+MYPAINT_BRUSHES_LIBS = @MYPAINT_BRUSHES_LIBS@
+NATIVE_GLIB_CFLAGS = @NATIVE_GLIB_CFLAGS@
+NATIVE_GLIB_LIBS = @NATIVE_GLIB_LIBS@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPENEXR_CFLAGS = @OPENEXR_CFLAGS@
+OPENEXR_LIBS = @OPENEXR_LIBS@
+OPENEXR_REQUIRED_VERSION = @OPENEXR_REQUIRED_VERSION@
+OPENJPEG_CFLAGS = @OPENJPEG_CFLAGS@
+OPENJPEG_LIBS = @OPENJPEG_LIBS@
+OPENJPEG_REQUIRED_VERSION = @OPENJPEG_REQUIRED_VERSION@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PANGOCAIRO_CFLAGS = @PANGOCAIRO_CFLAGS@
+PANGOCAIRO_LIBS = @PANGOCAIRO_LIBS@
+PANGOCAIRO_REQUIRED_VERSION = @PANGOCAIRO_REQUIRED_VERSION@
+PATHSEP = @PATHSEP@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PERL = @PERL@
+PERL_REQUIRED_VERSION = @PERL_REQUIRED_VERSION@
+PERL_VERSION = @PERL_VERSION@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+PNG_CFLAGS = @PNG_CFLAGS@
+PNG_LIBS = @PNG_LIBS@
+POFILES = @POFILES@
+POPPLER_CFLAGS = @POPPLER_CFLAGS@
+POPPLER_DATA_CFLAGS = @POPPLER_DATA_CFLAGS@
+POPPLER_DATA_LIBS = @POPPLER_DATA_LIBS@
+POPPLER_DATA_REQUIRED_VERSION = @POPPLER_DATA_REQUIRED_VERSION@
+POPPLER_LIBS = @POPPLER_LIBS@
+POPPLER_REQUIRED_VERSION = @POPPLER_REQUIRED_VERSION@
+POSUB = @POSUB@
+PO_IN_DATADIR_FALSE = @PO_IN_DATADIR_FALSE@
+PO_IN_DATADIR_TRUE = @PO_IN_DATADIR_TRUE@
+PYBIN_PATH = @PYBIN_PATH@
+PYCAIRO_CFLAGS = @PYCAIRO_CFLAGS@
+PYCAIRO_LIBS = @PYCAIRO_LIBS@
+PYGIMP_EXTRA_CFLAGS = @PYGIMP_EXTRA_CFLAGS@
+PYGTK_CFLAGS = @PYGTK_CFLAGS@
+PYGTK_CODEGEN = @PYGTK_CODEGEN@
+PYGTK_DEFSDIR = @PYGTK_DEFSDIR@
+PYGTK_LIBS = @PYGTK_LIBS@
+PYLINK_LIBS = @PYLINK_LIBS@
+PYTHON = @PYTHON@
+PYTHON2_REQUIRED_VERSION = @PYTHON2_REQUIRED_VERSION@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_INCLUDES = @PYTHON_INCLUDES@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+RSVG_REQUIRED_VERSION = @RSVG_REQUIRED_VERSION@
+RT_LIBS = @RT_LIBS@
+SCREENSHOT_LIBS = @SCREENSHOT_LIBS@
+SED = @SED@
+SENDMAIL = @SENDMAIL@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SOCKET_LIBS = @SOCKET_LIBS@
+SSE2_EXTRA_CFLAGS = @SSE2_EXTRA_CFLAGS@
+SSE4_1_EXTRA_CFLAGS = @SSE4_1_EXTRA_CFLAGS@
+SSE_EXTRA_CFLAGS = @SSE_EXTRA_CFLAGS@
+STRIP = @STRIP@
+SVG_CFLAGS = @SVG_CFLAGS@
+SVG_LIBS = @SVG_LIBS@
+SYMPREFIX = @SYMPREFIX@
+TIFF_LIBS = @TIFF_LIBS@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+WEBKIT_CFLAGS = @WEBKIT_CFLAGS@
+WEBKIT_LIBS = @WEBKIT_LIBS@
+WEBKIT_REQUIRED_VERSION = @WEBKIT_REQUIRED_VERSION@
+WEBPDEMUX_CFLAGS = @WEBPDEMUX_CFLAGS@
+WEBPDEMUX_LIBS = @WEBPDEMUX_LIBS@
+WEBPMUX_CFLAGS = @WEBPMUX_CFLAGS@
+WEBPMUX_LIBS = @WEBPMUX_LIBS@
+WEBP_CFLAGS = @WEBP_CFLAGS@
+WEBP_LIBS = @WEBP_LIBS@
+WEBP_REQUIRED_VERSION = @WEBP_REQUIRED_VERSION@
+WEB_PAGE = @WEB_PAGE@
+WIN32_LARGE_ADDRESS_AWARE = @WIN32_LARGE_ADDRESS_AWARE@
+WINDRES = @WINDRES@
+WMF_CFLAGS = @WMF_CFLAGS@
+WMF_CONFIG = @WMF_CONFIG@
+WMF_LIBS = @WMF_LIBS@
+WMF_REQUIRED_VERSION = @WMF_REQUIRED_VERSION@
+XDG_EMAIL = @XDG_EMAIL@
+XFIXES_CFLAGS = @XFIXES_CFLAGS@
+XFIXES_LIBS = @XFIXES_LIBS@
+XGETTEXT = @XGETTEXT@
+XGETTEXT_REQUIRED_VERSION = @XGETTEXT_REQUIRED_VERSION@
+XMC_CFLAGS = @XMC_CFLAGS@
+XMC_LIBS = @XMC_LIBS@
+XMKMF = @XMKMF@
+XMLLINT = @XMLLINT@
+XMU_LIBS = @XMU_LIBS@
+XPM_LIBS = @XPM_LIBS@
+XSLTPROC = @XSLTPROC@
+XVFB_RUN = @XVFB_RUN@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+Z_LIBS = @Z_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CC_FOR_BUILD = @ac_ct_CC_FOR_BUILD@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+gimpdatadir = @gimpdatadir@
+gimpdir = @gimpdir@
+gimplocaledir = @gimplocaledir@
+gimpplugindir = @gimpplugindir@
+gimpsysconfdir = @gimpsysconfdir@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+intltool__v_merge_options_ = @intltool__v_merge_options_@
+intltool__v_merge_options_0 = @intltool__v_merge_options_0@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+manpage_gimpdir = @manpage_gimpdir@
+mkdir_p = @mkdir_p@
+ms_librarian = @ms_librarian@
+mypaint_brushes_dir = @mypaint_brushes_dir@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+pluginexecdir = $(gimpplugindir)/plug-ins
+source_scripts = \
+	colorxhtml.py			\
+	file-openraster.py		\
+	foggify.py			\
+	gradients-save-as-css.py	\
+	histogram-export.py     	\
+	palette-offset.py		\
+	palette-sort.py			\
+	palette-to-gradient.py		\
+	py-slice.py			\
+	python-eval.py			\
+	spyro_plus.py			\
+					\
+	benchmark-foreground-extract.py	\
+	clothify.py			\
+	shadow_bevel.py			\
+	sphere.py			\
+	whirlpinch.py
+
+scripts = \
+	colorxhtml/colorxhtml.py			\
+	file-openraster/file-openraster.py		\
+	foggify/foggify.py				\
+	gradients-save-as-css/gradients-save-as-css.py	\
+	histogram-export/histogram-export.py     	\
+	palette-offset/palette-offset.py		\
+	palette-sort/palette-sort.py			\
+	palette-to-gradient/palette-to-gradient.py	\
+	py-slice/py-slice.py				\
+	python-eval/python-eval.py			\
+	spyro_plus/spyro_plus.py
+
+test_scripts = \
+	benchmark-foreground-extract/benchmark-foreground-extract.py	\
+	clothify/clothify.py						\
+	shadow_bevel/shadow_bevel.py					\
+	sphere/sphere.py						\
+	whirlpinch/whirlpinch.py
+
+nobase_pluginexec_SCRIPTS = $(scripts) $(am__append_1)
+
+# python-console has a data file.
+# Therefore let's move it to its own sub-directory.
+consoleexecdir = $(gimpplugindir)/plug-ins/python-console
+console_scripts = python-console.py
+consoleexec_SCRIPTS = $(console_scripts)
+dist_consoleexec_DATA = pyconsole.py
+EXTRA_DIST = \
+	$(source_scripts)	\
+	$(console_scripts)
+
+CLEANFILES = $(scripts) $(test_scripts)
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu plug-ins/pygimp/plug-ins/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu plug-ins/pygimp/plug-ins/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-consoleexecSCRIPTS: $(consoleexec_SCRIPTS)
+	@$(NORMAL_INSTALL)
+	@list='$(consoleexec_SCRIPTS)'; test -n "$(consoleexecdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(consoleexecdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(consoleexecdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n' \
+	    -e 'h;s|.*|.|' \
+	    -e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) { files[d] = files[d] " " $$1; \
+	      if (++n[d] == $(am__install_max)) { \
+		print "f", d, files[d]; n[d] = 0; files[d] = "" } } \
+	    else { print "f", d "/" $$4, $$1 } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	     if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	     test -z "$$files" || { \
+	       echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(consoleexecdir)$$dir'"; \
+	       $(INSTALL_SCRIPT) $$files "$(DESTDIR)$(consoleexecdir)$$dir" || exit $$?; \
+	     } \
+	; done
+
+uninstall-consoleexecSCRIPTS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(consoleexec_SCRIPTS)'; test -n "$(consoleexecdir)" || exit 0; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	       sed -e 's,.*/,,;$(transform)'`; \
+	dir='$(DESTDIR)$(consoleexecdir)'; $(am__uninstall_files_from_dir)
+install-nobase_pluginexecSCRIPTS: $(nobase_pluginexec_SCRIPTS)
+	@$(NORMAL_INSTALL)
+	@list='$(nobase_pluginexec_SCRIPTS)'; test -n "$(pluginexecdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pluginexecdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pluginexecdir)" || exit 1; \
+	fi; \
+	$(am__nobase_strip_setup); \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n' \
+	    -e "s|$$srcdirstrip/||" -e 'h;s|[^/]*$$||; s|^$$|.|' \
+	    -e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) { files[d] = files[d] " " $$1; \
+	      if (++n[d] == $(am__install_max)) { \
+		print "f", d, files[d]; n[d] = 0; files[d] = "" } } \
+	    else { print "f", d "/" $$4, $$1 } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	  case $$type in \
+	  d) echo " $(MKDIR_P) '$(DESTDIR)$(pluginexecdir)/$$dir'"; \
+	     $(MKDIR_P) "$(DESTDIR)$(pluginexecdir)/$$dir" || exit $$?;; \
+	  f) \
+	     if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	     test -z "$$files" || { \
+	       echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(pluginexecdir)$$dir'"; \
+	       $(INSTALL_SCRIPT) $$files "$(DESTDIR)$(pluginexecdir)$$dir" || exit $$?; \
+	     } \
+	  ;; esac \
+	; done
+
+uninstall-nobase_pluginexecSCRIPTS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(nobase_pluginexec_SCRIPTS)'; test -n "$(pluginexecdir)" || exit 0; \
+	$(am__nobase_strip_setup); \
+	files=`$(am__nobase_strip) \
+	       -e 'h;s,.*/,,;$(transform);x;s|[^/]*$$||;G;s,\n,,'`; \
+	dir='$(DESTDIR)$(pluginexecdir)'; $(am__uninstall_files_from_dir)
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-dist_consoleexecDATA: $(dist_consoleexec_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(dist_consoleexec_DATA)'; test -n "$(consoleexecdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(consoleexecdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(consoleexecdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(consoleexecdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(consoleexecdir)" || exit $$?; \
+	done
+
+uninstall-dist_consoleexecDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(dist_consoleexec_DATA)'; test -n "$(consoleexecdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(consoleexecdir)'; $(am__uninstall_files_from_dir)
+tags TAGS:
+
+ctags CTAGS:
+
+cscope cscopelist:
+
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(SCRIPTS) $(DATA)
+installdirs:
+	for dir in "$(DESTDIR)$(consoleexecdir)" "$(DESTDIR)$(pluginexecdir)" "$(DESTDIR)$(consoleexecdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-consoleexecSCRIPTS \
+	install-dist_consoleexecDATA install-nobase_pluginexecSCRIPTS
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-consoleexecSCRIPTS \
+	uninstall-dist_consoleexecDATA \
+	uninstall-nobase_pluginexecSCRIPTS
+
+.MAKE: install-am install-strip
+
+.PHONY: all all-am check check-am clean clean-generic clean-libtool \
+	cscopelist-am ctags-am distclean distclean-generic \
+	distclean-libtool distdir dvi dvi-am html html-am info info-am \
+	install install-am install-consoleexecSCRIPTS install-data \
+	install-data-am install-dist_consoleexecDATA install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-nobase_pluginexecSCRIPTS install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \
+	uninstall-am uninstall-consoleexecSCRIPTS \
+	uninstall-dist_consoleexecDATA \
+	uninstall-nobase_pluginexecSCRIPTS
+
+.PRECIOUS: Makefile
+
+
+$(scripts) $(test_scripts): $(source_scripts)
+	$(AM_V_GEN) mkdir -p $(@D) && cp -f "$(srcdir)/$(@F)" $@
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/plug-ins/pygimp/plug-ins/benchmark-foreground-extract.py b/plug-ins/pygimp/plug-ins/benchmark-foreground-extract.py
new file mode 100755
index 0000000..2637547
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/benchmark-foreground-extract.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python2
+
+#   Foreground Extraction Benchmark
+#   Copyright 2005  Sven Neumann <sven@gimp.org>
+#
+#   This is a from-scratch implementation of the benchmark proposed in
+#   "GrabCut": interactive foreground extraction using iterated graph
+#   cuts published in the Proceedings of the 2004 SIGGRAPH Conference.
+#
+#   No guarantee is made that this benchmark produces the same results
+#   as the cited benchmark but the goal is that it does. So if you find
+#   any bugs or inaccuracies in this code, please let us know.
+#
+#   The benchmark has been adapted work with the SIOX algorithm
+#   (http://www.siox.org). which is (currently) the only
+#   implementation of gimp_drawable_foreground_extract(). If other
+#   implementations are being added, this benchmark should be changed
+#   accordingly.
+#
+#   You will need a set of test images to run this benchmark, preferably
+#   the original set of 50 images. Some of these images are from the
+#   Berkeley Segmentation Dataset
+#   (http://www.cs.berkeley.edu/projects/vision/grouping/segbench/).
+#   See also http://www.siox.org/details.html for trimaps.
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import os, re, struct, sys, time
+
+from gimpfu import *
+
+
+def benchmark (folder, save_output):
+    folder = os.path.abspath (folder)
+    if not os.path.exists (folder):
+        gimp.message("Folder '" + folder + "' doesn't exist.\n")
+        return;
+
+    total_unclassified = 0
+    total_misclassified = 0
+    total_time = 0.0
+
+    images = os.path.join (folder, "images")
+    for name in os.listdir (images):
+
+        try:
+            gimp.delete (image_display)
+            gimp.delete (mask_display)
+        except UnboundLocalError:
+            pass
+
+        image_name = os.path.join (images, name)
+
+        # FIXME: improve this!
+        name = re.sub (r'\.jpg$', '', name)
+        name = re.sub (r'\.JPG$', '', name)
+        name = re.sub (r'\.bmp$', '', name)
+
+        mask_name = os.path.join (folder, "cm_bmp", name + '.png')
+        truth_name = os.path.join (folder, "truth", name + '.bmp')
+
+        image = pdb.gimp_file_load (image_name, image_name)
+        image_layer = image.active_layer;
+
+        mask = pdb.gimp_file_load (mask_name, mask_name)
+        convert_grayscale (mask)
+        mask_layer = mask.active_layer;
+
+        truth = pdb.gimp_file_load (truth_name, truth_name)
+        convert_grayscale (truth)
+        truth_layer = truth.active_layer;
+
+        unclassified = unclassified_pixels (mask_layer, truth_layer)
+
+        sys.stderr.write (os.path.basename (image_name))
+
+        start = time.time ()
+        pdb.gimp_drawable_foreground_extract (image_layer,
+                                              FOREGROUND_EXTRACT_SIOX,
+                                              mask_layer)
+        end = time.time ()
+
+        sys.stderr.write (" ")
+
+        mask_layer.flush ()
+
+        # Ignore errors when creating image displays;
+        # allows us to be used without a display.
+        try:
+            image_display = pdb.gimp_display_new (image)
+            mask_display = pdb.gimp_display_new (mask)
+
+            gimp.displays_flush ()
+            time.sleep (1.0)
+        except:
+            pass
+
+        gimp.delete (image)
+
+        misclassified = misclassified_pixels (mask_layer, truth_layer)
+
+        sys.stderr.write ("%d %d %.2f%% %.3fs\n" %
+                          (unclassified, misclassified,
+                           (misclassified * 100.0 / unclassified),
+                           end - start))
+
+        total_unclassified += unclassified
+        total_misclassified += misclassified
+        total_time += end - start
+
+        gimp.delete (truth)
+
+        if save_output:
+            filename = os.path.join (folder, "output", name + '.png')
+            pdb.gimp_file_save (mask, mask_layer, filename, filename)
+
+        gimp.delete (mask)
+
+    # for loop ends
+
+    try:
+        gimp.delete (image_display)
+        gimp.delete (mask_display)
+    except UnboundLocalError:
+        pass
+
+    sys.stderr.write ("Total: %d %d %.2f%% %.3fs\n" %
+                      (total_unclassified, total_misclassified,
+                       (total_misclassified * 100.0 / total_unclassified),
+                       total_time))
+
+def convert_grayscale (image):
+    if image.base_type != GRAY:
+        pdb.gimp_image_convert_grayscale (image)
+
+
+def unclassified_pixels (mask, truth):
+    (mean, std_dev, median, pixels,
+     count, percentile) = pdb.gimp_histogram (mask, HISTOGRAM_VALUE, 1, 254)
+
+    return count
+
+
+def misclassified_pixels (mask, truth):
+    image = truth.image
+
+    copy = pdb.gimp_layer_new_from_drawable (mask, image)
+    copy.name = "Difference"
+    copy.mode = DIFFERENCE_MODE
+
+    image.insert_layer (copy)
+
+    # The assumption made here is that the output of
+    # foreground_extract is a strict black and white mask. The truth
+    # however may contain unclassified pixels. These are considered
+    # unknown, a strict segmentation isn't possible here.
+    #
+    # The result of using the Difference mode as done here is that
+    # pure black pixels in the result can be considered correct.
+    # White pixels are wrong. Gray values were unknown in the truth
+    # and thus are not counted as wrong.
+
+    (mean, std_dev, median, pixels,
+     count, percentile) = pdb.gimp_histogram (image.flatten (),
+                                              HISTOGRAM_VALUE, 255, 255)
+
+    return count
+
+
+register (
+    "python-fu-benchmark-foreground-extract",
+    "Benchmark and regression test for the SIOX algorithm",
+    "",
+    "Sven Neumann",
+    "Sven Neumann",
+    "2005",
+    "Foreground Extraction",
+    "",
+    [ (PF_FILE,   "image-folder", "Image folder",
+                  "~/segmentation/msbench/imagedata"),
+      (PF_TOGGLE, "save-output",  "Save output images", False) ],
+    [],
+    benchmark, menu="<Image>/Filters/Extensions/Benchmark")
+
+main ()
diff --git a/plug-ins/pygimp/plug-ins/clothify.py b/plug-ins/pygimp/plug-ins/clothify.py
new file mode 100755
index 0000000..258329c
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/clothify.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import math
+from gimpfu import *
+
+def clothify(timg, tdrawable, bx=9, by=9, azimuth=135, elevation=45, depth=3):
+    width = tdrawable.width
+    height = tdrawable.height
+
+    img = gimp.Image(width, height, RGB)
+    img.disable_undo()
+
+    layer_one = gimp.Layer(img, "X Dots", width, height, RGB_IMAGE,
+                           100, NORMAL_MODE)
+    img.insert_layer(layer_one)
+    pdb.gimp_edit_fill(layer_one, BACKGROUND_FILL)
+
+    pdb.plug_in_noisify(img, layer_one, 0, 0.7, 0.7, 0.7, 0.7)
+
+    layer_two = layer_one.copy()
+    layer_two.mode = MULTIPLY_MODE
+    layer_two.name = "Y Dots"
+    img.insert_layer(layer_two)
+
+    pdb.plug_in_gauss_rle(img, layer_one, bx, 1, 0)
+    pdb.plug_in_gauss_rle(img, layer_two, by, 0, 1)
+
+    img.flatten()
+
+    bump_layer = img.active_layer
+
+    pdb.plug_in_c_astretch(img, bump_layer)
+    pdb.plug_in_noisify(img, bump_layer, 0, 0.2, 0.2, 0.2, 0.2)
+    pdb.plug_in_bump_map(img, tdrawable, bump_layer, azimuth,
+                         elevation, depth, 0, 0, 0, 0, True, False, 0)
+
+    gimp.delete(img)
+
+register(
+        "python-fu-clothify",
+        "Make the image look like it is printed on cloth",
+        "Make the specified layer look like it is printed on cloth",
+        "James Henstridge",
+        "James Henstridge",
+        "1997-1999",
+        "_Clothify...",
+        "RGB*, GRAY*",
+        [
+            (PF_IMAGE, "image", "Input image", None),
+            (PF_DRAWABLE, "drawable", "Input drawable", None),
+            (PF_INT, "x-blur", "X blur", 9),
+            (PF_INT, "y-blur", "Y blur", 9),
+            (PF_INT, "azimuth", "Azimuth", 135),
+            (PF_INT, "elevation", "Elevation", 45),
+            (PF_INT, "depth", "Depth", 3)
+        ],
+        [],
+        clothify, menu="<Image>/Filters/Artistic")
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/colorxhtml.py b/plug-ins/pygimp/plug-ins/colorxhtml.py
new file mode 100755
index 0000000..011f8ca
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/colorxhtml.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 2003, 2005  Manish Singh <yosh@gimp.org>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import string
+import struct
+import inspect
+import os.path
+
+import gimp
+from gimpfu import *
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+all_source_types = (CHARS_SOURCE, CHARS_FILE, CHARS_PARAMETER) = range(3)
+
+escape_table = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;'
+}
+
+style_def = """body {
+   width: 100%%;
+   font-size: %dpx;
+   background-color: #000000;
+   color: #ffffff;
+}
+"""
+
+preamble = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+                   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<title>CSS Color XHTML written by GIMP</title>
+%s
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+</head>
+<body>
+<pre>
+"""
+
+postamble = """\n</pre>\n</body>\n</html>\n"""
+
+def colorxhtml(img, drawable, filename, raw_filename,
+        source_type, characters, size, separate):
+    width = drawable.width
+    height = drawable.height
+    bpp = drawable.bpp
+
+    if not drawable.is_rgb or drawable.has_alpha:
+        return
+
+    if source_type not in all_source_types:
+        return
+
+    gimp.tile_cache_ntiles(width / gimp.tile_width() + 1)
+
+    html = file(filename, 'w')
+
+    if separate:
+        dirname, cssfile = os.path.split(filename)
+        cssfile = os.path.splitext(cssfile)[0] + '.css'
+        cssname = os.path.join(dirname, cssfile)
+
+        css = file(cssname, 'w')
+
+    if source_type == CHARS_SOURCE:
+        chars = file(inspect.getsourcefile(colorxhtml)).read()
+    elif source_type == CHARS_FILE:
+        chars = file(characters).read()
+    elif source_type == CHARS_PARAMETER:
+        chars = characters
+
+    allchars = string.maketrans('', '')
+
+    goodchars = string.digits + string.ascii_letters + string.punctuation
+    badchars = ''.join([c for c in allchars if c not in goodchars])
+
+    chars = chars.translate(allchars, badchars)
+
+    data = []
+
+    for c in chars:
+        data.append(escape_table.get(c, c))
+
+    if data:
+        data.reverse()
+    else:
+        data = list('X' * 80)
+
+    pr = drawable.get_pixel_rgn(0, 0, width, height, False, False)
+
+    gimp.progress_init(_("Saving as colored XHTML"))
+
+    style = style_def % size
+
+    if separate:
+        ss = '<link rel="stylesheet" type="text/css" href="%s" />' % cssfile
+        css.write(style)
+    else:
+        ss = '<style type="text/css">\n%s</style>' % style
+
+    html.write(preamble % ss)
+
+    colors = {}
+    chars = []
+
+    for y in range(0, height):
+        row = pr[0:width, y]
+
+        while len(chars) < width:
+            chars[0:0] = data
+
+        for pixel in RowIterator(row, bpp):
+            color = '%02x%02x%02x' % pixel
+            style = 'background-color:black; color:#%s;' % color
+            char = chars.pop()
+
+            if separate:
+                if color not in colors:
+                    css.write('span.N%s { %s }\n' % (color, style))
+                    colors[color] = 1
+
+                html.write('<span class="N%s">%s</span>' % (color, char))
+
+            else:
+                html.write('<span style="%s">%s</span>' % (style, char))
+
+        html.write('\n')
+
+        gimp.progress_update(y / float(height))
+
+    html.write(postamble)
+
+    html.close()
+
+    if separate:
+        css.close()
+
+def register_save():
+    gimp.register_save_handler("file-colorxhtml-save", "xhtml", "")
+
+class RowIterator:
+    def __init__(self, row, bpp):
+        self.row = row
+        self.bpp = bpp
+
+        self.start = 0
+        self.stop = bpp
+
+        self.length = len(row)
+        self.fmt = 'B' * bpp
+
+    def __iter__(self):
+        return iter(self.get_pixel, None)
+
+    def get_pixel(self):
+        if self.stop > self.length:
+            return None
+
+        pixel = struct.unpack(self.fmt, self.row[self.start:self.stop])
+
+        self.start += self.bpp
+        self.stop += self.bpp
+
+        return pixel
+
+register(
+    "file-colorxhtml-save",
+    N_("Save as colored XHTML"),
+    "Saves the image as colored XHTML text (based on Perl version by Marc Lehmann)",
+    "Manish Singh and Carol Spears",
+    "Manish Singh and Carol Spears",
+    "2003",
+    N_("Colored XHTML"),
+    "RGB",
+    [
+        (PF_IMAGE, "image", "Input image", None),
+        (PF_DRAWABLE, "drawable", "Input drawable", None),
+        (PF_STRING, "filename", "The name of the file", None),
+        (PF_STRING, "raw-filename", "The name of the file", None),
+        (PF_RADIO, "source", _("Character _source"), 0,
+                   ((_("Source code"), CHARS_SOURCE),
+                    (_("Text file"),   CHARS_FILE),
+                    (_("Entry box"),   CHARS_PARAMETER))),
+        (PF_FILE,  "characters", _("_File to read or characters to use"),
+                   ""),
+        (PF_INT,   "font-size",  _("Fo_nt size in pixels"), 10),
+        (PF_BOOL,  "separate",   _("_Write a separate CSS file"),   True)
+    ],
+    [],
+    colorxhtml, on_query=register_save,
+    menu="<Save>", domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/file-openraster.py b/plug-ins/pygimp/plug-ins/file-openraster.py
new file mode 100755
index 0000000..c55b1b6
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/file-openraster.py
@@ -0,0 +1,404 @@
+#!/usr/bin/env python2
+
+# GIMP Plug-in for the OpenRaster file format
+# http://create.freedesktop.org/wiki/OpenRaster
+
+# Copyright (C) 2009 by Jon Nordby <jononor@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# Based on MyPaint source code by Martin Renold
+# http://gitorious.org/mypaint/mypaint/blobs/edd84bcc1e091d0d56aa6d26637aa8a925987b6a/lib/document.py
+
+import os, sys, tempfile, zipfile
+import xml.etree.ElementTree as ET
+
+
+from gimpfu import *
+
+NESTED_STACK_END = object()
+
+
+layermodes_map = {
+    "svg:src-over": LAYER_MODE_NORMAL,
+    "svg:multiply": LAYER_MODE_MULTIPLY_LEGACY,
+    "svg:screen": LAYER_MODE_SCREEN_LEGACY,
+    "svg:overlay": LAYER_MODE_OVERLAY,
+    "svg:darken": LAYER_MODE_DARKEN_ONLY_LEGACY,
+    "svg:lighten": LAYER_MODE_LIGHTEN_ONLY_LEGACY,
+    "svg:color-dodge": LAYER_MODE_DODGE_LEGACY,
+    "svg:color-burn": LAYER_MODE_BURN_LEGACY,
+    "svg:hard-light": LAYER_MODE_HARDLIGHT_LEGACY,
+    "svg:soft-light": LAYER_MODE_SOFTLIGHT_LEGACY,
+    "svg:difference": LAYER_MODE_DIFFERENCE_LEGACY,
+    "svg:color": LAYER_MODE_HSL_COLOR_LEGACY,
+    "svg:luminosity": LAYER_MODE_HSV_VALUE_LEGACY,
+    "svg:hue": LAYER_MODE_HSV_HUE_LEGACY,
+    "svg:saturation": LAYER_MODE_HSV_SATURATION_LEGACY,
+    "svg:plus": LAYER_MODE_ADDITION_LEGACY,
+}
+
+def reverse_map(mapping):
+    return dict((v,k) for k, v in mapping.iteritems())
+
+def get_image_attributes(orafile):
+    xml = orafile.read('stack.xml')
+    image = ET.fromstring(xml)
+    stack = image.find('stack')
+    w = int(image.attrib.get('w', ''))
+    h = int(image.attrib.get('h', ''))
+
+    return stack, w, h
+
+def get_layer_attributes(layer):
+    a = layer.attrib
+    path = a.get('src', '')
+    name = a.get('name', '')
+    x = int(a.get('x', '0'))
+    y = int(a.get('y', '0'))
+    opac = float(a.get('opacity', '1.0'))
+    visible = a.get('visibility', 'visible') != 'hidden'
+    m = a.get('composite-op', 'svg:src-over')
+    layer_mode = layermodes_map.get(m, LAYER_MODE_NORMAL)
+
+    return path, name, x, y, opac, visible, layer_mode
+
+def get_group_layer_attributes(layer):
+    a = layer.attrib
+    name = a.get('name', '')
+    opac = float(a.get('opacity', '1.0'))
+    visible = a.get('visibility', 'visible') != 'hidden'
+    m = a.get('composite-op', 'svg:src-over')
+    layer_mode = layermodes_map.get(m, NORMAL_MODE)
+
+    return name, 0, 0, opac, visible, layer_mode
+
+def thumbnail_ora(filename, thumb_size):
+    # FIXME: Untested. Does not seem to be used at all? should be run
+    # when registered and there is no thumbnail in cache
+    tempdir = tempfile.mkdtemp('gimp-plugin-file-openraster')
+    original_name = filename
+    try:
+        if not isinstance(filename, str):
+            filename = filename.decode("utf-8")
+        orafile = zipfile.ZipFile(filename.encode(sys.getfilesystemencoding() or "utf-8"))
+    except (UnicodeDecodeError, IOError):
+        # Someone may try to open an actually garbled name, and pass a raw
+        # non-utf 8 filename:
+        orafile = zipfile.ZipFile(original_name)
+    orafile = zipfile.ZipFile(filename)
+    stack, w, h = get_image_attributes(orafile)
+
+    # create temp file
+    tmp = os.path.join(tempdir, 'tmp.png')
+    f = open(tmp, 'wb')
+    f.write(orafile.read('Thumbnails/thumbnail.png'))
+    f.close()
+
+    img = pdb['file-png-load'](tmp, 'tmp.png')
+    # TODO: scaling
+    os.remove(tmp)
+    os.rmdir(tempdir)
+
+    return (img, w, h)
+
+def save_ora(img, drawable, filename, raw_filename):
+    def write_file_str(zfile, fname, data):
+        # work around a permission bug in the zipfile library:
+        # http://bugs.python.org/issue3394
+        zi = zipfile.ZipInfo(fname)
+        zi.external_attr = int("100644", 8) << 16
+        zfile.writestr(zi, data)
+
+    tempdir = tempfile.mkdtemp('gimp-plugin-file-openraster')
+
+    if isinstance(filename, str):
+        try:
+            filename = filename.decode("utf-8")
+        except UnicodeDecodeError:
+            # 1 - 1 correspondence between raw_bytes and UCS-2 used by Python
+            # Unicode characters
+            filename = filename.decode("latin1")
+    encoding = sys.getfilesystemencoding() or "utf-8"
+    filename = filename.encode(encoding)
+    tmp_sufix = ".tmpsave".encode(encoding)
+    # use .tmpsave extension, so we don't overwrite a valid file if
+    # there is an exception
+    orafile = zipfile.ZipFile(filename + tmp_sufix, 'w', compression=zipfile.ZIP_STORED)
+
+    write_file_str(orafile, 'mimetype', 'image/openraster') # must be the first file written
+
+    # build image attributes
+    image = ET.Element('image')
+    stack = ET.SubElement(image, 'stack')
+    a = image.attrib
+    a['w'] = str(img.width)
+    a['h'] = str(img.height)
+
+    def store_layer(img, drawable, path):
+        tmp = os.path.join(tempdir, 'tmp.png')
+        interlace, compression = 0, 2
+        png_chunks = (1, 1, 0, 1, 1) # write all PNG chunks except oFFs(ets)
+        pdb['file-png-save'](img, drawable, tmp, 'tmp.png',
+                             interlace, compression, *png_chunks)
+        orafile.write(tmp, path)
+        os.remove(tmp)
+
+    def add_layer(parent, x, y, opac, gimp_layer, path, visible=True):
+        store_layer(img, gimp_layer, path)
+        # create layer attributes
+        layer = ET.Element('layer')
+        parent.append(layer)
+        a = layer.attrib
+        a['src'] = path
+        a['name'] = gimp_layer.name
+        a['x'] = str(x)
+        a['y'] = str(y)
+        a['opacity'] = str(opac)
+        a['visibility'] = 'visible' if visible else 'hidden'
+        a['composite-op'] = reverse_map(layermodes_map).get(gimp_layer.mode, 'svg:src-over')
+        return layer
+
+    def add_group_layer(parent, opac, gimp_layer, visible=True):
+        # create layer attributes
+        group_layer = ET.Element('stack')
+        parent.append(group_layer)
+        a = group_layer.attrib
+        a['name'] = gimp_layer.name
+        a['opacity'] = str(opac)
+        a['visibility'] = 'visible' if visible else 'hidden'
+        a['composite-op'] = reverse_map(layermodes_map).get(gimp_layer.mode, 'svg:src-over')
+        return group_layer
+
+
+    def enumerate_layers(group):
+        for layer in group.layers:
+            if not isinstance(layer, gimp.GroupLayer):
+                yield layer
+            else:
+                yield layer
+                for sublayer in enumerate_layers(layer):
+                    yield sublayer
+                yield NESTED_STACK_END
+
+    # save layers
+    parent_groups = []
+    i = 0
+    for lay in enumerate_layers(img):
+        if lay is NESTED_STACK_END:
+            parent_groups.pop()
+            continue
+        x, y = lay.offsets
+        opac = lay.opacity / 100.0 # needs to be between 0.0 and 1.0
+
+        if not parent_groups:
+            path_name = 'data/{:03d}.png'.format(i)
+            i += 1
+        else:
+            path_name = 'data/{}-{:03d}.png'.format(
+                parent_groups[-1][1], parent_groups[-1][2])
+            parent_groups[-1][2] += 1
+
+        parent = stack if not parent_groups else parent_groups[-1][0]
+
+        if isinstance(lay, gimp.GroupLayer):
+            group = add_group_layer(parent, opac, lay, lay.visible)
+            group_path = ("{:03d}".format(i) if not parent_groups else
+                parent_groups[-1][1] + "-{:03d}".format(parent_groups[-1][2]))
+            parent_groups.append([group, group_path , 0])
+        else:
+            add_layer(parent, x, y, opac, lay, path_name, lay.visible)
+
+    # save mergedimage
+    thumb = pdb['gimp-image-duplicate'](img)
+    thumb_layer = thumb.merge_visible_layers (CLIP_TO_IMAGE)
+    store_layer (thumb, thumb_layer, 'mergedimage.png')
+
+    # save thumbnail
+    w, h = img.width, img.height
+    if max (w, h) > 256:
+        # should be at most 256x256, without changing aspect ratio
+        if w > h:
+            w, h = 256, max(h*256/w, 1)
+        else:
+            w, h = max(w*256/h, 1), 256
+        thumb_layer.scale(w, h)
+    if thumb.precision != PRECISION_U8_GAMMA:
+        pdb.gimp_image_convert_precision (thumb, PRECISION_U8_GAMMA)
+    store_layer(thumb, thumb_layer, 'Thumbnails/thumbnail.png')
+    gimp.delete(thumb)
+
+    # write stack.xml
+    xml = ET.tostring(image, encoding='UTF-8')
+    write_file_str(orafile, 'stack.xml', xml)
+
+    # finish up
+    orafile.close()
+    os.rmdir(tempdir)
+    if os.path.exists(filename):
+        os.remove(filename) # win32 needs that
+    os.rename(filename + tmp_sufix, filename)
+
+
+def load_ora(filename, raw_filename):
+    tempdir = tempfile.mkdtemp('gimp-plugin-file-openraster')
+    original_name = filename
+    try:
+        if not isinstance(filename, str):
+            filename = filename.decode("utf-8")
+        orafile = zipfile.ZipFile(filename.encode(sys.getfilesystemencoding() or "utf-8"))
+    except (UnicodeDecodeError, IOError):
+        # Someone may try to open an actually garbled name, and pass a raw
+        # non-utf 8 filename:
+        orafile = zipfile.ZipFile(original_name)
+    stack, w, h = get_image_attributes(orafile)
+
+    img = gimp.Image(w, h, RGB)
+    img.filename = filename
+
+    def get_layers(root):
+        """iterates over layers and nested stacks"""
+        for item in root:
+            if item.tag == 'layer':
+                yield item
+            elif item.tag == 'stack':
+                yield item
+                for subitem in get_layers(item):
+                    yield subitem
+                yield NESTED_STACK_END
+
+    parent_groups = []
+
+    layer_no = 0
+    for item in get_layers(stack):
+
+        if item is NESTED_STACK_END:
+            parent_groups.pop()
+            continue
+
+        if item.tag == 'stack':
+            name, x, y, opac, visible, layer_mode = get_group_layer_attributes(item)
+            gimp_layer = gimp.GroupLayer(img)
+
+        else:
+            path, name, x, y, opac, visible, layer_mode = get_layer_attributes(item)
+
+            if not path.lower().endswith('.png'):
+                continue
+            if not name:
+                # use the filename without extension as name
+                n = os.path.basename(path)
+                name = os.path.splitext(n)[0]
+
+            # create temp file. Needed because gimp cannot load files from inside a zip file
+            tmp = os.path.join(tempdir, 'tmp.png')
+            f = open(tmp, 'wb')
+            try:
+                data = orafile.read(path)
+            except KeyError:
+                # support for bad zip files (saved by old versions of this plugin)
+                data = orafile.read(path.encode('utf-8'))
+                print 'WARNING: bad OpenRaster ZIP file. There is an utf-8 encoded filename that does not have the utf-8 flag set:', repr(path)
+            f.write(data)
+            f.close()
+
+            # import layer, set attributes and add to image
+            gimp_layer = pdb['gimp-file-load-layer'](img, tmp)
+            os.remove(tmp)
+        gimp_layer.name = name
+        gimp_layer.mode = layer_mode
+        gimp_layer.set_offsets(x, y)  # move to correct position
+        gimp_layer.opacity = opac * 100  # a float between 0 and 100
+        gimp_layer.visible = visible
+
+        pdb.gimp_image_insert_layer(img, gimp_layer,
+                                    parent_groups[-1][0] if parent_groups else None,
+                                    parent_groups[-1][1] if parent_groups else layer_no)
+        if parent_groups:
+            parent_groups[-1][1] += 1
+        else:
+            layer_no += 1
+
+        if isinstance(gimp_layer, gimp.GroupLayer):
+            parent_groups.append([gimp_layer, 0])
+
+    os.rmdir(tempdir)
+
+    return img
+
+
+def register_load_handlers():
+    gimp.register_load_handler('file-openraster-load', 'ora', '')
+    pdb['gimp-register-file-handler-mime']('file-openraster-load', 'image/openraster')
+    pdb['gimp-register-thumbnail-loader']('file-openraster-load', 'file-openraster-load-thumb')
+
+def register_save_handlers():
+    gimp.register_save_handler('file-openraster-save', 'ora', '')
+
+register(
+    'file-openraster-load-thumb', #name
+    'loads a thumbnail from an OpenRaster (.ora) file', #description
+    'loads a thumbnail from an OpenRaster (.ora) file',
+    'Jon Nordby', #author
+    'Jon Nordby', #copyright
+    '2009', #year
+    None,
+    None, #image type
+    [   #input args. Format (type, name, description, default [, extra])
+        (PF_STRING, 'filename', 'The name of the file to load', None),
+        (PF_INT, 'thumb-size', 'Preferred thumbnail size', None),
+    ],
+    [   #results. Format (type, name, description)
+        (PF_IMAGE, 'image', 'Thumbnail image'),
+        (PF_INT, 'image-width', 'Width of full-sized image'),
+        (PF_INT, 'image-height', 'Height of full-sized image')
+    ],
+    thumbnail_ora, #callback
+    run_mode_param = False
+)
+
+register(
+    'file-openraster-save', #name
+    'save an OpenRaster (.ora) file', #description
+    'save an OpenRaster (.ora) file',
+    'Jon Nordby', #author
+    'Jon Nordby', #copyright
+    '2009', #year
+    'OpenRaster',
+    '*',
+    [   #input args. Format (type, name, description, default [, extra])
+        (PF_IMAGE, "image", "Input image", None),
+        (PF_DRAWABLE, "drawable", "Input drawable", None),
+        (PF_STRING, "filename", "The name of the file", None),
+        (PF_STRING, "raw-filename", "The name of the file", None),
+    ],
+    [], #results. Format (type, name, description)
+    save_ora, #callback
+    on_query = register_save_handlers,
+    menu = '<Save>'
+)
+
+register(
+    'file-openraster-load', #name
+    'load an OpenRaster (.ora) file', #description
+    'load an OpenRaster (.ora) file',
+    'Jon Nordby', #author
+    'Jon Nordby', #copyright
+    '2009', #year
+    'OpenRaster',
+    None, #image type
+    [   #input args. Format (type, name, description, default [, extra])
+        (PF_STRING, 'filename', 'The name of the file to load', None),
+        (PF_STRING, 'raw-filename', 'The name entered', None),
+    ],
+    [(PF_IMAGE, 'image', 'Output image')], #results. Format (type, name, description)
+    load_ora, #callback
+    on_query = register_load_handlers,
+    menu = "<Load>",
+)
+
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/foggify.py b/plug-ins/pygimp/plug-ins/foggify.py
new file mode 100755
index 0000000..4964d8c
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/foggify.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+import time
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def foggify(img, layer, name, colour, turbulence, opacity):
+
+    gimp.context_push()
+    img.undo_group_start()
+
+    if img.base_type is RGB:
+        type = RGBA_IMAGE
+    else:
+        type = GRAYA_IMAGE
+    fog = gimp.Layer(img, name,
+                     layer.width, layer.height, type, opacity, NORMAL_MODE)
+    fog.fill(FILL_TRANSPARENT)
+    img.insert_layer(fog)
+
+    gimp.set_background(colour)
+    pdb.gimp_edit_fill(fog, FILL_BACKGROUND)
+
+    # create a layer mask for the new layer
+    mask = fog.create_mask(0)
+    fog.add_mask(mask)
+
+    # add some clouds to the layer
+    pdb.plug_in_plasma(img, mask, int(time.time()), turbulence)
+
+    # apply the clouds to the layer
+    fog.remove_mask(MASK_APPLY)
+
+    img.undo_group_end()
+    gimp.context_pop()
+
+register(
+    "python-fu-foggify",
+    N_("Add a layer of fog"),
+    "Adds a layer of fog to the image.",
+    "James Henstridge",
+    "James Henstridge",
+    "1999,2007",
+    N_("_Fog..."),
+    "RGB*, GRAY*",
+    [
+        (PF_IMAGE, "image",       "Input image", None),
+        (PF_DRAWABLE, "drawable", "Input drawable", None),
+        (PF_STRING, "name",       _("_Layer name"), _("Clouds")),
+        (PF_COLOUR, "colour",     _("_Fog color"),  (240, 180, 70)),
+        (PF_SLIDER, "turbulence", _("_Turbulence"), 1.0, (0, 7, 0.1)),
+        (PF_SLIDER, "opacity",    _("Op_acity"),    100, (0, 100, 1)),
+    ],
+    [],
+    foggify,
+    menu="<Image>/Filters/Decor",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/gradients-save-as-css.py b/plug-ins/pygimp/plug-ins/gradients-save-as-css.py
new file mode 100755
index 0000000..44179e4
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/gradients-save-as-css.py
@@ -0,0 +1,104 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#   Allows saving (TODO: and loading) CSS gradient files
+#   Copyright (C) 2011 João S. O. Bueno <gwidion@gmail.com>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+# Currently this exports all color segments as RGB linear centered segments.
+# TODO: Respect gradient alpha, off-center segments, different blending
+# functions and HSV colors 
+    
+from gimpfu import *
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+w3c_template = """background-image: linear-gradient(top, %s);\n"""
+moz_template = """background-image: -moz-linear-gradient(center top, %s);\n"""
+webkit_template = """background-image: -webkit-gradient(linear, """ \
+                  """left top, left bottom, %s);\n"""
+
+color_to_html = lambda c: "rgb(%d,%d,%d)" % tuple(c)[:3]
+
+def format_text(text):
+    counter = 0
+    new_text = []
+    for token in text.split(","):
+        if counter + len(token) > 77:
+            token = "\n    " + token
+            counter = 4
+        new_text.append(token)
+        if "\n" in token:
+            counter = len(token.rsplit("\n")[-1]) + 1
+        else:
+            counter += len(token) + 1
+        
+    return ",".join(new_text)
+    
+def gradient_css_save(gradient, file_name):
+    stops = []
+    wk_stops = []
+    n_segments = pdb.gimp_gradient_get_number_of_segments(gradient)
+    last_stop = None
+    for index in xrange(n_segments):
+        lcolor, lopacity = pdb.gimp_gradient_segment_get_left_color(
+                                gradient,
+                                index)
+        rcolor, ropacity = pdb.gimp_gradient_segment_get_right_color(
+                                gradient,
+                                index)
+        lpos = pdb.gimp_gradient_segment_get_left_pos(gradient, index)
+        rpos = pdb.gimp_gradient_segment_get_right_pos(gradient, index)
+        
+        lstop = color_to_html(lcolor) + " %d%%" % int(100 * lpos)
+        wk_lstop = "color-stop(%.03f, %s)" %(lpos, color_to_html(lcolor))
+        if lstop != last_stop:
+            stops.append(lstop)
+            wk_stops.append(wk_lstop)
+        
+        rstop = color_to_html(rcolor) + " %d%%" % int(100 * rpos)
+        wk_rstop = "color-stop(%.03f, %s)" %(rpos, color_to_html(rcolor))
+        
+        stops.append(rstop)
+        wk_stops.append(wk_rstop)
+        last_stop = rstop
+    
+    final_text = w3c_template % ", ".join(stops)
+    final_text += moz_template % ",".join(stops)
+    final_text += webkit_template % ",".join(wk_stops)
+    
+    with open(file_name, "wt") as file_:
+        file_.write(format_text(final_text))
+
+register(
+        "gradient-save-as-css",
+        "Creates a new palette from a given gradient",
+        "palette_from_gradient (gradient, number, segment_colors) -> None",
+        "Joao S. O. Bueno",
+        "(c) GPL V3.0 or later",
+        "2011",
+        "Save as CSS...",
+        "",
+        [
+          (PF_GRADIENT, "gradient", N_("Gradient to use"),""),
+          (PF_FILENAME, "file_name", N_("File Name"), ""),
+        ],
+        [],
+        gradient_css_save,
+        menu="<Gradients>",
+        domain=("gimp20-python", gimp.locale_directory)
+        )
+main()
\ No newline at end of file
diff --git a/plug-ins/pygimp/plug-ins/histogram-export.py b/plug-ins/pygimp/plug-ins/histogram-export.py
new file mode 100755
index 0000000..11da1ba
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/histogram-export.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python2
+#coding: utf-8
+
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Exports the image histogram to a text file,
+so that it can be used by other programs
+and loaded into spreadsheets.
+
+The resulting file is a CSV file (Comma Separated
+Values), which can be imported
+directly in most spreadsheet programs.
+
+The first two collums are the bucket boundaries,
+followed by the selected columns. The histogram
+refers to the selected image area, and
+can use either Sample Average data or data
+from the current drawable only.;
+
+The output is in "weighted pixels" - meaning
+all fully transparent pixels are not counted.
+
+Check the gimp-histogram call
+"""
+
+
+from gimpfu import *
+import csv
+import gettext
+
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def histogram_export(img, drw, filename,
+                     bucket_size, sample_average, output_format):
+    if sample_average:
+        new_img = pdb.gimp_image_duplicate(img)
+        drw = pdb.gimp_image_merge_visible_layers(new_img, CLIP_TO_IMAGE)
+    # TODO: grey images, alpha and non alpha images.
+    channels_txt = ["Value"] 
+    channels_gimp = [HISTOGRAM_VALUE]
+    if drw.is_rgb:
+        channels_txt += ["Red", "Green", "Blue"]
+        channels_gimp += [HISTOGRAM_RED, HISTOGRAM_GREEN, HISTOGRAM_BLUE]
+    if drw.has_alpha:
+        channels_txt += ["Alpha"]
+        channels_gimp += [HISTOGRAM_ALPHA]
+    with open(filename, "wt") as hfile:
+        writer = csv.writer(hfile)
+        #headers:
+        writer.writerow(["Range start"] + channels_txt)
+
+        # FIXME: Will need a specialized 'range' for FP color numbers
+        bucket_size = int(bucket_size)
+        for start_range in range(0, 256, bucket_size):
+            row = [start_range]
+            for channel in channels_gimp:
+                result = pdb.gimp_histogram(
+                             drw, channel,
+                             start_range,
+                             min(start_range + bucket_size - 1, 255)
+                            )
+                if output_format == "pixel count":
+                    count = result[4]
+                else:
+                    count = (result[4] / result[3]) if result[3] else 0
+                    if output_format == "percent":
+                        count = "%.2f%%" % (count * 100)
+                row.append(str(count))
+            writer.writerow(row)
+    if sample_average:
+        pdb.gimp_image_delete(new_img)
+
+register(
+    "histogram-export",
+    N_("Exports the image histogram to a text file (CSV)"),
+    globals()["__doc__"], # This includes the docstring, on the top of the file
+    "João S. O. Bueno",
+    "João S. O. Bueno, 2014",
+    "2014",
+    N_("_Export histogram..."),
+    "*",
+    [(PF_IMAGE,  "img", _("_Image"), None),
+     (PF_DRAWABLE, "drw", _("_Drawable"), None),
+     (PF_FILENAME, "filename", _("Histogram _File"), ""),
+     (PF_FLOAT, "bucket_size", _("_Bucket Size"), 1.0),
+     (PF_BOOL, "sample_average", _("Sample _Average"), False),
+     (PF_RADIO, "output_format", _("Output format"), "pixel count",
+            ((_("Pixel count"), "pixel count"),
+             (_("Normalized"), "normalized"),
+             (_("Percent"), "percent"),
+            )
+     )
+    ],
+    [],
+    histogram_export,
+    menu="<Image>/Colors/Info",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/palette-offset.py b/plug-ins/pygimp/plug-ins/palette-offset.py
new file mode 100644
index 0000000..8ba0bfe
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/palette-offset.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def palette_offset(palette, amount):
+    #If palette is read only, work on a copy:
+    editable = pdb.gimp_palette_is_editable(palette)
+    if not editable:palette = pdb.gimp_palette_duplicate (palette)
+
+    num_colors = pdb.gimp_palette_get_info (palette)
+
+    tmp_entry_array = []
+    for i in xrange (num_colors):
+        tmp_entry_array.append  ((pdb.gimp_palette_entry_get_name (palette, i),
+                                  pdb.gimp_palette_entry_get_color (palette, i)))
+    for i in xrange (num_colors):
+        target_index = i + amount
+        if target_index >= num_colors:
+            target_index -= num_colors
+        elif target_index < 0:
+            target_index += num_colors
+        pdb.gimp_palette_entry_set_name (palette, target_index, tmp_entry_array[i][0])
+        pdb.gimp_palette_entry_set_color (palette, target_index, tmp_entry_array[i][1])
+    return palette
+
+
+register(
+    "python-fu-palette-offset",
+    N_("Offset the colors in a palette"),
+    "palette_offset (palette, amount) -> modified_palette",
+    "Joao S. O. Bueno Calligaris, Carol Spears",
+    "(c) Joao S. O. Bueno Calligaris",
+    "2004, 2006",
+    N_("_Offset Palette..."),
+    "",
+    [
+     (PF_PALETTE, "palette", _("Palette"), ""),
+     (PF_INT,     "amount",  _("Off_set"),  1),
+    ],
+    [(PF_PALETTE, "new-palette", "Result")],
+    palette_offset,
+    menu="<Palettes>",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main ()
diff --git a/plug-ins/pygimp/plug-ins/palette-sort.py b/plug-ins/pygimp/plug-ins/palette-sort.py
new file mode 100644
index 0000000..c21b8ad
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/palette-sort.py
@@ -0,0 +1,357 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+# little known, colorsys is part of Python's stdlib
+from colorsys import rgb_to_yiq
+from textwrap import dedent
+from random import randint
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+AVAILABLE_CHANNELS = (_("Red"), _("Green"), _("Blue"),
+                      _("Luma (Y)"),
+                      _("Hue"), _("Saturation"), _("Value"),
+                      _("Saturation (HSL)"), _("Lightness (HSL)"),
+                      _("Index"),
+                      _("Random"))
+
+GRAIN_SCALE = (1.0, 1.0 , 1.0,
+              1.0,
+              360., 100., 100.,
+              100., 100.,
+              16384.,
+              float(0x7ffffff),
+              100., 256., 256.,
+              256., 360.,)
+
+SELECT_ALL = 0
+SELECT_SLICE = 1
+SELECT_AUTOSLICE = 2
+SELECT_PARTITIONED = 3
+SELECTIONS = (SELECT_ALL, SELECT_SLICE, SELECT_AUTOSLICE, SELECT_PARTITIONED)
+
+
+def noop(v, i):
+    return v
+
+
+def to_hsv(v, i):
+    return v.to_hsv()
+
+
+def to_hsl(v, i):
+    return v.to_hsl()
+
+
+def to_yiq(v, i):
+    return rgb_to_yiq(*v[:-1])
+
+
+def to_index(v, i):
+    return (i,)
+
+def to_random(v, i):
+    return (randint(0, 0x7fffffff),)
+
+
+channel_getters = [ (noop, 0), (noop, 1), (noop, 2),
+                    (to_yiq, 0),
+                    (to_hsv, 0), (to_hsv, 1), (to_hsv, 2),
+                    (to_hsl, 1), (to_hsl, 2),
+                    (to_index, 0),
+                    (to_random, 0)]
+
+
+try:
+    from colormath.color_objects import RGBColor, LabColor, LCHabColor
+    AVAILABLE_CHANNELS = AVAILABLE_CHANNELS + (_("Lightness (LAB)"),
+                                               _("A-color"), _("B-color"),
+                                               _("Chroma (LCHab)"),
+                                               _("Hue (LCHab)"))
+    to_lab = lambda v,i: RGBColor(*v[:-1]).convert_to('LAB').get_value_tuple()
+    to_lchab = (lambda v,i:
+                    RGBColor(*v[:-1]).convert_to('LCHab').get_value_tuple())
+    channel_getters.extend([(to_lab, 0), (to_lab, 1), (to_lab, 2),
+                            (to_lchab, 1), (to_lchab, 2)])
+except ImportError:
+    pass
+
+
+def parse_slice(s, numcolors):
+    """Parse a slice spec and return (start, nrows, length)
+    All items are optional. Omitting them makes the largest possible selection that
+    exactly fits the other items.
+
+    start:nrows,length
+
+
+    '' selects all items, as does ':'
+    ':4,' makes a 4-row selection out of all colors (length auto-determined)
+    ':4' also.
+    ':1,4' selects the first 4 colors
+    ':,4' selects rows of 4 colors (nrows auto-determined)
+    ':4,4' selects 4 rows of 4 colors
+    '4:' selects a single row of all colors after 4, inclusive.
+    '4:,4' selects rows of 4 colors, starting at 4 (nrows auto-determined)
+    '4:4,4' selects 4 rows of 4 colors (16 colors total), beginning at index 4.
+    '4' is illegal (ambiguous)
+
+
+    In general, slices are comparable to a numpy sub-array.
+    'start at element START, with shape (NROWS, LENGTH)'
+
+    """
+    s = s.strip()
+
+    def notunderstood():
+        raise ValueError('Slice %r not understood. Should be in format'
+                         ' START?:NROWS?,ROWLENGTH? eg. "0:4,16".' % s)
+    def _int(v):
+        try:
+            return int(v)
+        except ValueError:
+            notunderstood()
+    if s in ('', ':', ':,'):
+        return 0, 1, numcolors # entire palette, one row
+    if s.count(':') != 1:
+        notunderstood()
+    rowpos = s.find(':')
+    start = 0
+    if rowpos > 0:
+        start = _int(s[:rowpos])
+    numcolors -= start
+    nrows = 1
+    if ',' in s:
+        commapos = s.find(',')
+        nrows = s[rowpos+1:commapos]
+        length = s[commapos+1:]
+        if not nrows:
+            if not length:
+                notunderstood()
+            else:
+                length = _int(length)
+                if length == 0:
+                    notunderstood()
+                nrows = numcolors // length
+                if numcolors % length:
+                    nrows = -nrows
+        elif not length:
+            nrows = _int(nrows)
+            if nrows == 0:
+                notunderstood()
+            length = numcolors // nrows
+            if numcolors % nrows:
+                length = -length
+        else:
+            nrows = _int(nrows)
+            if nrows == 0:
+                notunderstood()
+            length = _int(length)
+            if length == 0:
+                notunderstood()
+    else:
+        nrows = _int(s[rowpos+1:])
+        if nrows == 0:
+            notunderstood()
+        length = numcolors // nrows
+        if numcolors % nrows:
+            length = -length
+    return start, nrows, length
+
+
+def quantization_grain(channel, g):
+    "Given a channel and a quantization, return the size of a quantization grain"
+    g = max(1.0, g)
+    if g <= 1.0:
+        g = 0.00001
+    else:
+        g = max(0.00001, GRAIN_SCALE[channel] / g)
+    return g
+
+
+def palette_sort(palette, selection, slice_expr, channel1, ascending1,
+                 channel2, ascending2, quantize, pchannel, pquantize):
+
+    grain1 = quantization_grain(channel1, quantize)
+    grain2 = quantization_grain(channel2, quantize)
+    pgrain = quantization_grain(pchannel, pquantize)
+
+    #If palette is read only, work on a copy:
+    editable = pdb.gimp_palette_is_editable(palette)
+    if not editable:
+        palette = pdb.gimp_palette_duplicate (palette)
+
+    num_colors = pdb.gimp_palette_get_info (palette)
+
+    start, nrows, length = None, None, None
+    if selection == SELECT_AUTOSLICE:
+        def find_index(color, startindex=0):
+            for i in range(startindex, num_colors):
+                c = pdb.gimp_palette_entry_get_color (palette, i)
+                if c == color:
+                    return i
+            return None
+        def hexcolor(c):
+            return "#%02x%02x%02x" % tuple(c[:-1])
+        fg = pdb.gimp_context_get_foreground()
+        bg = pdb.gimp_context_get_background()
+        start = find_index(fg)
+        end = find_index(bg)
+        if start is None:
+            raise ValueError("Couldn't find foreground color %r in palette" % list(fg))
+        if end is None:
+            raise ValueError("Couldn't find background color %r in palette" % list(bg))
+        if find_index(fg, start + 1):
+            raise ValueError('Autoslice cannot be used when more than one'
+                             ' instance of an endpoint'
+                             ' (%s) is present' % hexcolor(fg))
+        if find_index(bg, end + 1):
+            raise ValueError('Autoslice cannot be used when more than one'
+                             ' instance of an endpoint'
+                             ' (%s) is present' % hexcolor(bg))
+        if start > end:
+            end, start = start, end
+        length = (end - start) + 1
+        try:
+            _, nrows, _ = parse_slice(slice_expr, length)
+            nrows = abs(nrows)
+            if length % nrows:
+                raise ValueError('Total length %d not evenly divisible'
+                                 ' by number of rows %d' % (length, nrows))
+            length /= nrows
+        except ValueError:
+            # bad expression is okay here, just assume one row
+            nrows = 1
+        # remaining behaviour is implemented by SELECT_SLICE 'inheritance'.
+        selection= SELECT_SLICE
+    elif selection in (SELECT_SLICE, SELECT_PARTITIONED):
+        start, nrows, length = parse_slice(slice_expr, num_colors)
+
+    channels_getter_1, channel_index = channel_getters[channel1]
+    channels_getter_2, channel2_index = channel_getters[channel2]
+
+    def get_colors(start, end):
+        result = []
+        for i in range(start, end):
+            entry =  (pdb.gimp_palette_entry_get_name (palette, i),
+                      pdb.gimp_palette_entry_get_color (palette, i))
+            index1 = channels_getter_1(entry[1], i)[channel_index]
+            index2 = channels_getter_2(entry[1], i)[channel2_index]
+            index = ((index1 - (index1 % grain1)) * (1 if ascending1 else -1),
+                     (index2 - (index2 % grain2)) * (1 if ascending2 else -1)
+                    )
+            result.append((index, entry))
+        return result
+
+    if selection == SELECT_ALL:
+        entry_list = get_colors(0, num_colors)
+        entry_list.sort(key=lambda v:v[0])
+        for i in range(num_colors):
+            pdb.gimp_palette_entry_set_name (palette, i, entry_list[i][1][0])
+            pdb.gimp_palette_entry_set_color (palette, i, entry_list[i][1][1])
+
+    elif selection == SELECT_PARTITIONED:
+        if num_colors < (start + length * nrows) - 1:
+            raise ValueError('Not enough entries in palette to '
+                             'sort complete rows! Got %d, expected >=%d' %
+                             (num_colors, start + length * nrows))
+        pchannels_getter, pchannel_index = channel_getters[pchannel]
+        for row in range(nrows):
+            partition_spans = [1]
+            rowstart = start + (row * length)
+            old_color = pdb.gimp_palette_entry_get_color (palette,
+                                                          rowstart)
+            old_partition = pchannels_getter(old_color, rowstart)[pchannel_index]
+            old_partition = old_partition - (old_partition % pgrain)
+            for i in range(rowstart + 1, rowstart + length):
+                this_color = pdb.gimp_palette_entry_get_color (palette, i)
+                this_partition = pchannels_getter(this_color, i)[pchannel_index]
+                this_partition = this_partition - (this_partition % pgrain)
+                if this_partition == old_partition:
+                    partition_spans[-1] += 1
+                else:
+                    partition_spans.append(1)
+                    old_partition = this_partition
+            base = rowstart
+            for size in partition_spans:
+                palette_sort(palette, SELECT_SLICE, '%d:1,%d' % (base, size),
+                             channel1, ascending1, channel2, ascending2,
+                             quantize, 0, 1.0)
+                base += size
+    else:
+        stride = length
+        if num_colors < (start + stride * nrows) - 1:
+            raise ValueError('Not enough entries in palette to sort '
+                             'complete rows! Got %d, expected >=%d' %
+                             (num_colors, start + stride * nrows))
+
+        for row_start in range(start, start + stride * nrows, stride):
+            sublist = get_colors(row_start, row_start + stride)
+            sublist.sort(key=lambda v:v[0])
+            for i, entry in zip(range(row_start, row_start + stride), sublist):
+                pdb.gimp_palette_entry_set_name (palette, i, entry[1][0])
+                pdb.gimp_palette_entry_set_color (palette, i, entry[1][1])
+
+    return palette
+
+register(
+    "python-fu-palette-sort",
+    N_("Sort the colors in a palette"),
+    # FIXME: Write humanly readable help -
+    # (I can't figure out what the plugin does, or how to use the parameters after
+    # David's enhancements even looking at the code -
+    # let alone someone just using GIMP (JS) )
+    dedent("""\
+    palette_sort (palette, selection, slice_expr, channel,
+    channel2, quantize, ascending, pchannel, pquantize) -> new_palette
+    Sorts a palette, or part of a palette, using several options.
+    One can select two color channels over which to sort,
+    and several auxiliary parameters create a 2D sorted
+    palette with sorted rows, among other things.
+    One can optionally install colormath
+    (https://pypi.python.org/pypi/colormath/1.0.8)
+    to GIMP's Python to get even more channels to choose from.
+    """),
+    "João S. O. Bueno, Carol Spears, David Gowers",
+    "João S. O. Bueno, Carol Spears, David Gowers",
+    "2006-2014",
+    N_("_Sort Palette..."),
+    "",
+    [
+        (PF_PALETTE, "palette",  _("Palette"), ""),
+        (PF_OPTION, "selections", _("Se_lections"), SELECT_ALL,
+                    (_("All"), _("Slice / Array"), _("Autoslice (fg->bg)"),
+                     _("Partitioned"))),
+        (PF_STRING,    "slice-expr", _("Slice _expression"), ''),
+        (PF_OPTION,   "channel1",    _("Channel to _sort"), 3,
+                                    AVAILABLE_CHANNELS),
+        (PF_BOOL,  "ascending1", _("_Ascending"), True),
+        (PF_OPTION,   "channel2",    _("Secondary Channel to s_ort"), 5,
+                                    AVAILABLE_CHANNELS),
+        (PF_BOOL,   "ascending2", _("_Ascending"), True),
+        (PF_FLOAT,  "quantize", _("_Quantization"), 0.0),
+        (PF_OPTION,   "pchannel",    _("_Partitioning channel"), 3,
+                                            AVAILABLE_CHANNELS),
+        (PF_FLOAT,  "pquantize", _("Partition q_uantization"), 0.0),
+    ],
+    [],
+    palette_sort,
+    menu="<Palettes>",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main ()
diff --git a/plug-ins/pygimp/plug-ins/palette-to-gradient.py b/plug-ins/pygimp/plug-ins/palette-to-gradient.py
new file mode 100644
index 0000000..9b2da49
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/palette-to-gradient.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python2
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def make_gradient(palette, num_segments, num_colors):
+    gradient = pdb.gimp_gradient_new(palette)
+
+    if (num_segments > 1):
+        pdb.gimp_gradient_segment_range_split_uniform(gradient, 0, -1,
+                                                      num_segments)
+
+    for color_number in range(0,num_segments):
+        if (color_number == num_colors-1):color_number_next = 0
+        else: color_number_next = color_number + 1
+        color_left = pdb.gimp_palette_entry_get_color(palette,
+                                                      color_number)
+        color_right = pdb.gimp_palette_entry_get_color(palette,
+                                                       color_number_next)
+        pdb.gimp_gradient_segment_set_left_color(gradient,
+                                                 color_number, color_left,
+                                                 100.0)
+        pdb.gimp_gradient_segment_set_right_color(gradient,
+                                                  color_number, color_right,
+                                                  100.0)
+    pdb.gimp_context_set_gradient(gradient)
+    return gradient
+
+
+def palette_to_gradient_repeating(palette):
+    num_colors = pdb.gimp_palette_get_info(palette)
+    num_segments = num_colors
+    return make_gradient(palette, num_segments, num_colors)
+
+
+register(
+    "python-fu-palette-to-gradient-repeating",
+    N_("Create a repeating gradient using colors from the palette"),
+    "Create a new repeating gradient using colors from the palette.",
+    "Carol Spears, reproduced from previous work by Adrian Likins and Jeff Trefftz",
+    "Carol Spears",
+    "2006",
+    N_("Palette to _Repeating Gradient"),
+    "",
+    [(PF_PALETTE,  "palette", _("Palette"), "")],
+    [(PF_GRADIENT, "new-gradient", "Result")],
+    palette_to_gradient_repeating,
+    menu="<Palettes>",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+
+def palette_to_gradient(palette):
+    num_colors = pdb.gimp_palette_get_info(palette)
+    num_segments = num_colors - 1
+    return make_gradient(palette, num_segments, num_colors)
+
+register(
+    "python-fu-palette-to-gradient",
+    N_("Create a gradient using colors from the palette"),
+    "Create a new gradient using colors from the palette.",
+    "Carol Spears, reproduced from previous work by Adrian Likins and Jeff Trefftz",
+    "Carol Spears",
+    "2006",
+    N_("Palette to _Gradient"),
+    "",
+    [(PF_PALETTE,  "palette", _("Palette"), "")],
+    [(PF_GRADIENT, "new-gradient", "Result")],
+    palette_to_gradient,
+    menu="<Palettes>",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main ()
diff --git a/plug-ins/pygimp/plug-ins/py-slice.py b/plug-ins/pygimp/plug-ins/py-slice.py
new file mode 100755
index 0000000..90159aa
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/py-slice.py
@@ -0,0 +1,457 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+#Copyright (c) Manish Singh
+#javascript animation support by Joao S. O. Bueno Calligaris (2004)
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 2003, 2005  Manish Singh <yosh@gimp.org>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# (c) 2003 Manish Singh.
+#"Guillotine implemented ala python, with html output
+# (based on perlotine by Seth Burgess)",
+# Modified by João S. O. Bueno Calligaris to allow  dhtml animations (2005)
+
+import os
+
+from gimpfu import *
+import os.path
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def pyslice(image, drawable, save_path, html_filename,
+            image_basename, image_extension, separate,
+            image_path, cellspacing, animate, skip_caps):
+
+    cellspacing = int (cellspacing)
+
+    if animate:
+        count = 0
+        drw = []
+        #image.layers is a reversed list of the layers on the image
+        #so, count indexes from number of layers to 0.
+        for i in xrange (len (image.layers) -1, -1, -1):
+            if image.layers[i].visible:
+                drw.append(image.layers[i])
+                count += 1
+                if count == 3:
+                    break
+
+
+    vert, horz = get_guides(image)
+
+    if len(vert) == 0 and len(horz) == 0:
+        return
+
+    gimp.progress_init(_("Slice"))
+    progress_increment = 1 / ((len(horz) + 1) * (len(vert) + 1))
+    progress = 0.0
+
+    def check_path(path):
+        path = os.path.abspath(path)
+
+        if not os.path.exists(path):
+            os.mkdir(path)
+
+        return path
+
+    save_path = check_path(save_path)
+
+    if not os.path.isdir(save_path):
+        save_path = os.path.dirname(save_path)
+
+    if separate:
+        image_relative_path = image_path
+        if not image_relative_path.endswith("/"):
+            image_relative_path += "/"
+        image_path = check_path(os.path.join(save_path, image_path))
+    else:
+        image_relative_path = ''
+        image_path = save_path
+
+    tw = TableWriter(os.path.join(save_path, html_filename),
+                     cellspacing=cellspacing, animate=animate)
+
+    top = 0
+
+    for i in range(0, len(horz) + 1):
+        if i == len(horz):
+            bottom = image.height
+        else:
+            bottom = image.get_guide_position(horz[i])
+
+        tw.row_start()
+
+        left = 0
+
+        for j in range(0, len(vert) + 1):
+            if j == len(vert):
+                right = image.width
+            else:
+                right = image.get_guide_position(vert[j])
+            if (skip_caps   and
+                 (
+                   (len(horz) >= 2 and (i == 0 or i == len(horz) )) or
+                   (len(vert) >= 2 and (j == 0 or j == len(vert) ))
+                 )
+               ):
+                skip_stub = True
+            else:
+                skip_stub = False
+
+            if (not animate or skip_stub):
+                src = (image_relative_path +
+                       slice (image, None, image_path,
+                              image_basename, image_extension,
+                              left, right, top, bottom, i, j, ""))
+            else:
+                src = []
+                for layer, postfix in zip (drw, ("", "hover", "clicked")):
+                    src.append (image_relative_path +
+                                slice(image, layer, image_path,
+                                      image_basename, image_extension,
+                                      left, right, top, bottom, i, j, postfix))
+
+            tw.cell(src, right - left, bottom - top, i, j, skip_stub)
+
+            left = right + cellspacing
+
+            progress += progress_increment
+            gimp.progress_update(progress)
+
+        tw.row_end()
+
+        top = bottom + cellspacing
+
+    tw.close()
+
+def slice(image, drawable, image_path, image_basename, image_extension,
+          left, right, top, bottom, i, j, postfix):
+    if postfix:
+        postfix = "_" + postfix
+    src = "%s_%d_%d%s.%s" % (image_basename, i, j, postfix, image_extension)
+    filename = os.path.join(image_path, src)
+
+    if not drawable:
+        temp_image = image.duplicate()
+        temp_drawable = temp_image.active_layer
+    else:
+        if image.base_type == INDEXED:
+            #gimp_layer_new_from_drawable doesn't work for indexed images.
+            #(no colormap on new images)
+            original_active = image.active_layer
+            image.active_layer = drawable
+            temp_image = image.duplicate()
+            temp_drawable = temp_image.active_layer
+            image.active_layer = original_active
+            temp_image.disable_undo()
+            #remove all layers but the intended one
+            while len (temp_image.layers) > 1:
+                if temp_image.layers[0] != temp_drawable:
+                    pdb.gimp_image_remove_layer (temp_image, temp_image.layers[0])
+                else:
+                    pdb.gimp_image_remove_layer (temp_image, temp_image.layers[1])
+        else:
+            temp_image = pdb.gimp_image_new (drawable.width, drawable.height,
+                                         image.base_type)
+            temp_drawable = pdb.gimp_layer_new_from_drawable (drawable, temp_image)
+            temp_image.insert_layer (temp_drawable)
+
+    temp_image.disable_undo()
+    temp_image.crop(right - left, bottom - top, left, top)
+    if image_extension == "gif" and image.base_type == RGB:
+        pdb.gimp_image_convert_indexed (temp_image, CONVERT_DITHER_NONE,
+                                        CONVERT_PALETTE_GENERATE, 255,
+                                        True, False, False)
+    if image_extension == "jpg" and image.base_type == INDEXED:
+        pdb.gimp_image_convert_rgb (temp_image)
+
+    pdb.gimp_file_save(temp_image, temp_drawable, filename, filename)
+
+    gimp.delete(temp_image)
+    return src
+
+class GuideIter:
+    def __init__(self, image):
+        self.image = image
+        self.guide = 0
+
+    def __iter__(self):
+        return iter(self.next_guide, 0)
+
+    def next_guide(self):
+        self.guide = self.image.find_next_guide(self.guide)
+        return self.guide
+
+def get_guides(image):
+    vguides = []
+    hguides = []
+
+    for guide in GuideIter(image):
+        orientation = image.get_guide_orientation(guide)
+
+        guide_position = image.get_guide_position(guide)
+
+        if guide_position > 0:
+            if orientation == ORIENTATION_VERTICAL:
+                if guide_position < image.width:
+                    vguides.append((guide_position, guide))
+            elif orientation == ORIENTATION_HORIZONTAL:
+                if guide_position < image.height:
+                    hguides.append((guide_position, guide))
+
+    def position_sort(x, y):
+        return cmp(x[0], y[0])
+
+    vguides.sort(position_sort)
+    hguides.sort(position_sort)
+
+    vguides = [g[1] for g in vguides]
+    hguides = [g[1] for g in hguides]
+
+    return vguides, hguides
+
+class TableWriter:
+    def __init__(self, filename, cellpadding=0, cellspacing=0, border=0,
+                 animate=False):
+
+        self.filename = filename
+        self.table_attrs = {}
+
+        #Hellraisen IE 6 doesn't support CSS for table control.
+        self.table_attrs['cellpadding'] = cellpadding
+        self.table_attrs['cellspacing'] = cellspacing
+        self.table_attrs['border'] = border
+
+        self.image_prefix = os.path.basename (filename)
+        self.image_prefix = self.image_prefix.split(".")[0]
+        self.image_prefix = self.image_prefix.replace ("-", "_")
+        self.image_prefix = self.image_prefix.replace (" ", "_")
+
+
+        if animate:
+            self.animate = True
+            self.images = []
+        else:
+            self.animate = False
+
+        if os.path.exists (filename):
+            #The plug-in is running to overwrite a previous
+            #version of the file. This will parse the href targets already
+            #in the file to preserve them.
+            self.urls = self.parse_urls ()
+        else:
+            self.urls = []
+
+        self.url_index = 0
+
+        self.html = open(filename, 'wt')
+        self.open()
+
+    def next_url (self):
+        if self.url_index < len (self.urls):
+            self.url_index += 1
+            return self.urls [self.url_index - 1]
+        else:
+            #Default url to use in the anchor tags:
+            return ("#")
+
+    def write(self, s, vals=None):
+        if vals:
+            s = s % vals
+
+        self.html.write(s + '\n')
+
+    def open(self):
+        out = '''<!--HTML SNIPPET GENERATED BY GIMP
+
+WARNING!! This is NOT a fully valid HTML document, it is rather a piece of
+HTML generated by GIMP's py-slice plugin that should be embedded in an HTML
+or XHTML document to be valid.
+
+Replace the href targets in the anchor (<a >) for your URLS to have it working
+as a menu.
+ -->\n'''
+        out += '<table'
+
+        for attr, value in self.table_attrs.iteritems():
+            out += ' %s="%s"' % (attr, value)
+
+        out += '>'
+
+        self.write(out)
+
+    def close(self):
+        self.write('</table>\n')
+        prefix = self.image_prefix
+        if self.animate:
+            out = """
+<script language="javascript" type="text/javascript">
+/* Made with GIMP */
+
+/* Preload images: */
+    images_%s = new Array();
+                   \n"""    % prefix
+            for image in self.images:
+                for type_ in ("plain", "hover", "clicked"):
+                    if image.has_key(type_):
+                        image_index = ("%d_%d_%s" %
+                                       (image["index"][0],
+                                        image["index"][1], type_))
+                        out += ("    images_%s[\"%s\"] = new  Image();\n" %
+                                (prefix, image_index))
+                        out += ("    images_%s[\"%s\"].src = \"%s\";\n" %
+                            (prefix, image_index, image[type_]))
+
+            out+= """
+function exchange (image, images_array_name, event)
+  {
+    name = image.name;
+    images = eval (images_array_name);
+
+    switch (event)
+      {
+        case 0:
+          image.src = images[name + "_plain"].src;
+          break;
+        case 1:
+          image.src = images[name + "_hover"].src;
+          break;
+        case 2:
+          image.src = images[name + "_clicked"].src;
+          break;
+        case 3:
+          image.src = images[name + "_hover"].src;
+          break;
+      }
+
+  }
+</script>
+<!--
+End of the part generated by GIMP
+-->
+"""
+            self.write (out)
+
+
+    def row_start(self):
+        self.write('  <tr>')
+
+    def row_end(self):
+        self.write('</tr>\n')
+
+    def cell(self, src, width, height, row=0, col=0, skip_stub = False):
+        if isinstance (src, list):
+            prefix = "images_%s" % self.image_prefix
+            self.images.append ({"index" : (row, col), "plain" : src[0]})
+
+            out = ('    <td><a href="%s"><img alt="" src="%s" ' +
+                  'style="width: %dpx; height: %dpx; border-width: 0px" \n') %\
+                  (self.next_url(), src[0], width, height)
+            out += 'name="%d_%d" \n' % (row, col)
+            if len(src) >= 2:
+                self.images[-1]["hover"] = src [1]
+                out += """      onmouseout="exchange(this, '%s', 0);"\n""" % \
+                       prefix
+                out += """      onmouseover="exchange(this, '%s', 1);"\n""" % \
+                       prefix
+            if len(src) >= 3:
+                self.images[-1]["clicked"] = src [2]
+                out += """      onmousedown="exchange(this, '%s', 2);"\n""" % \
+                       prefix
+                out += """      onmouseup="exchange(this, '%s', 3);"\n""" % \
+                       prefix
+
+
+
+            out += "/></a></td>\n"
+
+        else:
+            if skip_stub:
+                out =  ('    <td><img alt=" " src="%s" style="width: %dpx; ' +
+                        ' height: %dpx; border-width: 0px;"></td>') % \
+                        (src, width, height)
+            else:
+                out = ('    <td><a href="#"><img alt=" " src="%s" ' +
+                      ' style="width: %dpx; height: %dpx; border-width: 0px;">' +
+                      '</a></td>') %  (src, width, height)
+        self.write(out)
+    def parse_urls (self):
+        """
+           This will parse any url targets in the href="XX" fields
+           of the given file and return then as a list
+        """
+        import re
+        url_list = []
+        try:
+            html_file = open (self.filename)
+
+            # Regular expression to pick everything up to the next
+            # doublequote character after finding the sequence 'href="'.
+            # The found sequences will be returned as a list by the
+            # "findall" method.
+            expr = re.compile (r"""href\=\"([^\"]*?)\"""")
+            url_list = expr.findall (html_file.read (2 ** 18))
+            html_file.close()
+
+        except:
+            # silently ignore any errors parsing this. The file being
+            # overwritten may not be a file created by py-slice.
+            pass
+
+        return url_list
+
+
+register(
+    "python-fu-slice",
+    # table snippet means a small piece of HTML code here
+    N_("Cuts an image along its guides, creates images and a HTML table snippet"),
+    """Add guides to an image. Then run this. It will cut along the guides,
+    and give you the html to reassemble the resulting images. If you
+    choose to generate javascript for onmouseover and clicked events, it
+    will use the lower three visible layers on the image for normal,
+    onmouseover and clicked states, in that order. If skip caps is
+    enabled, table cells on the edge of the table won't become animated,
+    and its images will be taken from the active layer.""",
+    "Manish Singh",
+    "Manish Singh",
+    "2003",
+    _("_Slice..."),
+    "*",
+    [
+        (PF_IMAGE, "image", "Input image", None),
+        (PF_DRAWABLE, "drawable", "Input drawable", None),
+        (PF_DIRNAME, "save-path",     _("Path for HTML export"), os.getcwd()),
+        (PF_STRING, "html-filename",  _("Filename for export"),  "slice.html"),
+        (PF_STRING, "image-basename", _("Image name prefix"),    "slice"),
+        (PF_RADIO, "image-extension", _("Image format"),         "gif", (("gif", "gif"), ("jpg", "jpg"), ("png", "png"))),
+        (PF_TOGGLE, "separate-image-dir",  _("Separate image folder"),
+         False),
+        (PF_STRING, "relative-image-path", _("Folder for image export"), "images"),
+        (PF_SPINNER, "cellspacing", _("Space between table elements"), 0,
+        (0,15,1)),
+        (PF_TOGGLE, "animate",      _("Javascript for onmouseover and clicked"),
+         False),
+        # table caps are table cells on the edge of the table
+        (PF_TOGGLE, "skip-caps",    _("Skip animation for table caps"), True)
+    ],
+    [],
+    pyslice,
+    menu="<Image>/Filters/Web",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/pyconsole.py b/plug-ins/pygimp/plug-ins/pyconsole.py
new file mode 100644
index 0000000..ee096d5
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/pyconsole.py
@@ -0,0 +1,749 @@
+#
+#   pyconsole.py
+#
+#   Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
+#   Portions of code by Geoffrey French.
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Lesser General Public version 2.1 as
+#   published by the Free Software Foundation.
+#
+#   See COPYING.lib file that comes with this distribution for full text
+#   of the license.
+#
+
+# This module 'runs' python interpreter in a TextView widget.
+# The main class is Console, usage is:
+# Console(locals=None, banner=None, completer=None, use_rlcompleter=True, start_script='') -
+# it creates the widget and 'starts' interactive session; see the end
+# of this file. If start_script is not empty, it pastes it as it was
+# entered from keyboard.
+#
+# Console has "command" signal which is emitted when code is about to
+# be executed. You may connect to it using console.connect or
+# console.connect_after to get your callback ran before or after the
+# code is executed.
+#
+# To modify output appearance, set attributes of console.stdout_tag and
+# console.stderr_tag.
+#
+# Console may subclass a type other than gtk.TextView, to allow syntax
+# highlighting and stuff,
+# e.g.:
+#   console_type = pyconsole.ConsoleType(moo.edit.TextView)
+#   console = console_type(use_rlcompleter=False, start_script="import moo\nimport gtk\n")
+#
+# This widget is not a replacement for real terminal with python running
+# inside: GtkTextView is not a terminal.
+# The use case is: you have a python program, you create this widget,
+# and inspect your program interiors.
+
+import gtk
+import gtk.gdk as gdk
+import gobject
+import pango
+import gtk.keysyms as _keys
+import code
+import sys
+import keyword
+import re
+
+# commonprefix() from posixpath
+def _commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m: return ''
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[:i+1] != item[:i+1]:
+                prefix = prefix[:i]
+                if i == 0:
+                    return ''
+                break
+    return prefix
+
+class _ReadLine(object):
+
+    class Output(object):
+        def __init__(self, console, tag_name):
+            object.__init__(self)
+            self.buffer = console.get_buffer()
+            self.tag_name = tag_name
+        def write(self, text):
+            pos = self.buffer.get_iter_at_mark(self.buffer.get_insert())
+            self.buffer.insert_with_tags_by_name(pos, text, self.tag_name)
+
+    class History(object):
+        def __init__(self):
+            object.__init__(self)
+            self.items = ['']
+            self.ptr = 0
+            self.edited = {}
+
+        def commit(self, text):
+            if text and self.items[-1] != text:
+                self.items.append(text)
+            self.ptr = 0
+            self.edited = {}
+
+        def get(self, dir, text):
+            if len(self.items) == 1:
+                return None
+
+            if text != self.items[self.ptr]:
+                self.edited[self.ptr] = text
+            elif self.edited.has_key(self.ptr):
+                del self.edited[self.ptr]
+
+            self.ptr = self.ptr + dir
+            if self.ptr >= len(self.items):
+                self.ptr = 0
+            elif self.ptr < 0:
+                self.ptr = len(self.items) - 1
+
+            try:
+                return self.edited[self.ptr]
+            except KeyError:
+                return self.items[self.ptr]
+
+    def __init__(self, quit_func=None):
+        object.__init__(self)
+
+        self.quit_func = quit_func
+
+        self.set_wrap_mode(gtk.WRAP_CHAR)
+        self.modify_font(pango.FontDescription("Monospace"))
+
+        self.buffer = self.get_buffer()
+        self.buffer.connect("insert-text", self.on_buf_insert)
+        self.buffer.connect("delete-range", self.on_buf_delete)
+        self.buffer.connect("mark-set", self.on_buf_mark_set)
+        self.do_insert = False
+        self.do_delete = False
+
+        self.stdout_tag = self.buffer.create_tag("stdout", foreground="#006000")
+        self.stderr_tag = self.buffer.create_tag("stderr", foreground="#B00000")
+        self._stdout = _ReadLine.Output(self, "stdout")
+        self._stderr = _ReadLine.Output(self, "stderr")
+
+        self.cursor = self.buffer.create_mark("cursor",
+                                              self.buffer.get_start_iter(),
+                                              False)
+        insert = self.buffer.get_insert()
+        self.cursor.set_visible(True)
+        insert.set_visible(False)
+
+        self.ps = ''
+        self.in_raw_input = False
+        self.in_modal_raw_input = False
+        self.run_on_raw_input = None
+        self.tab_pressed = 0
+        self.history = _ReadLine.History()
+        self.nonword_re = re.compile("[^\w\._]")
+
+    def freeze_undo(self):
+        try: self.begin_not_undoable_action()
+        except: pass
+
+    def thaw_undo(self):
+        try: self.end_not_undoable_action()
+        except: pass
+
+    def raw_input(self, ps=None):
+        '''Show prompt 'ps' and enter input mode until the current input
+        is committed.'''
+
+        if ps:
+            self.ps = ps
+        else:
+            self.ps = ''
+
+        iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
+
+        if ps:
+            self.freeze_undo()
+            self.buffer.insert(iter, self.ps)
+            self.thaw_undo()
+
+        self.__move_cursor_to(iter)
+        self.scroll_to_mark(self.cursor, 0.2)
+
+        self.in_raw_input = True
+
+        if self.run_on_raw_input:
+            run_now = self.run_on_raw_input
+            self.run_on_raw_input = None
+            self.buffer.insert_at_cursor(run_now + '\n')
+
+    def modal_raw_input(self, text):
+        '''Starts raw input in modal mode. The event loop is spinned until
+        the input is committed. Returns the text entered after the prompt.'''
+        orig_ps = self.ps
+
+        self.raw_input(text)
+        self.in_modal_raw_input = True
+
+        while self.in_modal_raw_input:
+            gtk.main_iteration()
+
+        self.ps = orig_ps
+        self.in_modal_raw_input = False
+        self.in_raw_input = False
+
+        return self.modal_raw_input_result
+
+    def modal_input(self, text):
+        return eval(self.modal_raw_input(text))
+
+    # Each time the insert mark is modified, move the cursor to it.
+    def on_buf_mark_set(self, buffer, iter, mark):
+        if mark is not buffer.get_insert():
+            return
+        start = self.__get_start()
+        end = self.__get_end()
+        if iter.compare(self.__get_start()) >= 0 and \
+           iter.compare(self.__get_end()) <= 0:
+                buffer.move_mark_by_name("cursor", iter)
+                self.scroll_to_mark(self.cursor, 0.2)
+
+    def __insert(self, iter, text):
+        self.do_insert = True
+        self.buffer.insert(iter, text)
+        self.do_insert = False
+
+    # Make sure that text insertions while in text input mode are properly
+    # committed to the history.
+    def on_buf_insert(self, buf, iter, text, len):
+        # Bail out if not in input mode.
+        if not self.in_raw_input or self.do_insert or not len:
+            return
+
+        buf.stop_emission("insert-text")
+        lines = text.splitlines()
+        need_eol = False
+        for l in lines:
+            if need_eol:
+                self._commit()
+                iter = self.__get_cursor()
+            else:
+                cursor = self.__get_cursor()
+                if iter.compare(self.__get_start()) < 0:
+                    iter = cursor
+                elif iter.compare(self.__get_end()) > 0:
+                    iter = cursor
+                else:
+                    self.__move_cursor_to(iter)
+            need_eol = True
+            self.__insert(iter, l)
+        self.__move_cursor(0)
+
+    def __delete(self, start, end):
+        self.do_delete = True
+        self.buffer.delete(start, end)
+        self.do_delete = False
+
+    def on_buf_delete(self, buf, start, end):
+        if not self.in_raw_input or self.do_delete:
+            return
+
+        buf.stop_emission("delete-range")
+
+        start.order(end)
+        line_start = self.__get_start()
+        line_end = self.__get_end()
+
+        if start.compare(line_end) > 0:
+            return
+        if end.compare(line_start) < 0:
+            return
+
+        self.__move_cursor(0)
+
+        if start.compare(line_start) < 0:
+            start = line_start
+        if end.compare(line_end) > 0:
+            end = line_end
+        self.__delete(start, end)
+
+    # We overload the key press event handler to handle "special keys"
+    # when in input mode to make history browsing, completions, etc. work.
+    def do_key_press_event(self, event, parent_type):
+        if not self.in_raw_input:
+            return parent_type.do_key_press_event(self, event)
+
+        tab_pressed = self.tab_pressed
+        self.tab_pressed = 0
+        handled = True
+
+        state = event.state & (gdk.SHIFT_MASK |
+                                gdk.CONTROL_MASK |
+                                gdk.MOD1_MASK)
+        keyval = event.keyval
+
+        if not state:
+            if keyval == _keys.Escape:
+                pass
+            elif keyval == _keys.Return:
+                self._commit()
+            elif keyval == _keys.Up:
+                self.__history(-1)
+            elif keyval == _keys.Down:
+                self.__history(1)
+            elif keyval == _keys.Left:
+                self.__move_cursor(-1)
+            elif keyval == _keys.Right:
+                self.__move_cursor(1)
+            elif keyval == _keys.Home:
+                self.__move_cursor(-10000)
+            elif keyval == _keys.End:
+                self.__move_cursor(10000)
+            elif keyval == _keys.Tab:
+                cursor = self.__get_cursor()
+                if cursor.starts_line():
+                    handled = False
+                else:
+                    cursor.backward_char()
+                    if cursor.get_char().isspace():
+                        handled = False
+                    else:
+                        self.tab_pressed = tab_pressed + 1
+                        self.__complete()
+            else:
+                handled = False
+        elif state == gdk.CONTROL_MASK:
+            if keyval == _keys.u:
+                start = self.__get_start()
+                end = self.__get_cursor()
+                self.__delete(start, end)
+            elif keyval == _keys.d:
+                if self.quit_func:
+                    self.quit_func()
+            else:
+                handled = False
+        else:
+            handled = False
+
+        # Handle ordinary keys
+        if not handled:
+            return parent_type.do_key_press_event(self, event)
+        else:
+            return True
+
+    def __history(self, dir):
+        text = self._get_line()
+        new_text = self.history.get(dir, text)
+        if not new_text is None:
+            self.__replace_line(new_text)
+        self.__move_cursor(0)
+        self.scroll_to_mark(self.cursor, 0.2)
+
+    def __get_cursor(self):
+        '''Returns an iterator at the current cursor position.'''
+        return self.buffer.get_iter_at_mark(self.cursor)
+
+    def __get_start(self):
+        '''Returns an iterator at the start of the input on the current
+        cursor line.'''
+
+        iter = self.__get_cursor()
+        iter.set_line(iter.get_line())
+        iter.forward_chars(len(self.ps))
+        return iter
+
+    def __get_end(self):
+        '''Returns an iterator at the end of the cursor line.'''
+        iter = self.__get_cursor()
+        if not iter.ends_line():
+            iter.forward_to_line_end()
+        return iter
+
+    def __get_text(self, start, end):
+        '''Get text between 'start' and 'end' markers.'''
+        return self.buffer.get_text(start, end, False)
+
+    def __move_cursor_to(self, iter):
+        self.buffer.place_cursor(iter)
+        self.buffer.move_mark_by_name("cursor", iter)
+
+    def __move_cursor(self, howmany):
+        iter = self.__get_cursor()
+        end = self.__get_cursor()
+        if not end.ends_line():
+            end.forward_to_line_end()
+        line_len = end.get_line_offset()
+        move_to = iter.get_line_offset() + howmany
+        move_to = min(max(move_to, len(self.ps)), line_len)
+        iter.set_line_offset(move_to)
+        self.__move_cursor_to(iter)
+
+    def __delete_at_cursor(self, howmany):
+        iter = self.__get_cursor()
+        end = self.__get_cursor()
+        if not end.ends_line():
+            end.forward_to_line_end()
+        line_len = end.get_line_offset()
+        erase_to = iter.get_line_offset() + howmany
+        if erase_to > line_len:
+            erase_to = line_len
+        elif erase_to < len(self.ps):
+            erase_to = len(self.ps)
+        end.set_line_offset(erase_to)
+        self.__delete(iter, end)
+
+    def __get_width(self):
+        '''Estimate the number of characters that will fit in the area
+        currently allocated to this widget.'''
+
+        if not (self.flags() & gtk.REALIZED):
+            return 80
+
+        context = self.get_pango_context()
+        metrics = context.get_metrics(context.get_font_description(),
+                                      context.get_language())
+        pix_width = metrics.get_approximate_char_width()
+        return self.allocation.width * pango.SCALE / pix_width
+
+    def __print_completions(self, completions):
+        line_start = self.__get_text(self.__get_start(), self.__get_cursor())
+        line_end = self.__get_text(self.__get_cursor(), self.__get_end())
+        iter = self.buffer.get_end_iter()
+        self.__move_cursor_to(iter)
+        self.__insert(iter, "\n")
+
+        width = max(self.__get_width(), 4)
+        max_width = max([len(s) for s in completions])
+        n_columns = max(int(width / (max_width + 1)), 1)
+        col_width = int(width / n_columns)
+        total = len(completions)
+        col_length = total / n_columns
+        if total % n_columns:
+            col_length = col_length + 1
+        col_length = max(col_length, 1)
+
+        if col_length == 1:
+            n_columns = total
+            col_width = width / total
+
+        for i in range(col_length):
+            for j in range(n_columns):
+                ind = i + j*col_length
+                if ind < total:
+                    if j == n_columns - 1:
+                        n_spaces = 0
+                    else:
+                        n_spaces = col_width - len(completions[ind])
+                    self.__insert(iter, completions[ind] + " " * n_spaces)
+            self.__insert(iter, "\n")
+
+        self.__insert(iter, "%s%s%s" % (self.ps, line_start, line_end))
+        iter.set_line_offset(len(self.ps) + len(line_start))
+        self.__move_cursor_to(iter)
+        self.scroll_to_mark(self.cursor, 0.2)
+
+    def __complete(self):
+        text = self.__get_text(self.__get_start(), self.__get_cursor())
+        start = ''
+        word = text
+        nonwords = self.nonword_re.findall(text)
+        if nonwords:
+            last = text.rfind(nonwords[-1]) + len(nonwords[-1])
+            start = text[:last]
+            word = text[last:]
+
+        completions = self.complete(word)
+
+        if completions:
+            prefix = _commonprefix(completions)
+            if prefix != word:
+                start_iter = self.__get_start()
+                start_iter.forward_chars(len(start))
+                end_iter = start_iter.copy()
+                end_iter.forward_chars(len(word))
+                self.__delete(start_iter, end_iter)
+                self.__insert(end_iter, prefix)
+            elif self.tab_pressed > 1:
+                self.freeze_undo()
+                self.__print_completions(completions)
+                self.thaw_undo()
+                self.tab_pressed = 0
+
+    def complete(self, text):
+        return None
+
+    def _get_line(self):
+        '''Return the current input behind the prompt.'''
+        start = self.__get_start()
+        end = self.__get_end()
+        return self.buffer.get_text(start, end, False)
+
+    def __replace_line(self, new_text):
+        '''Replace the current input with 'new_text' '''
+        start = self.__get_start()
+        end = self.__get_end()
+        self.__delete(start, end)
+        self.__insert(end, new_text)
+
+    def _commit(self):
+        '''Commit the input entered on the current line.'''
+
+        # Find iterator and end of cursor line.
+        end = self.__get_cursor()
+        if not end.ends_line():
+            end.forward_to_line_end()
+
+        # Get text at current line.
+        text = self._get_line()
+
+        # Move cursor to the end of the line, insert new line.
+        self.__move_cursor_to(end)
+        self.freeze_undo()
+        self.__insert(end, "\n")
+
+        self.history.commit(text)
+        if self.in_modal_raw_input:
+            self.in_modal_raw_input = False
+            self.modal_raw_input_result = text
+        else:
+            self.in_raw_input = False
+            self.do_raw_input(text)
+
+        self.thaw_undo()
+
+    def do_raw_input(self, text):
+        pass
+
+
+class _Console(_ReadLine, code.InteractiveInterpreter):
+    def __init__(self, locals=None, banner=None,
+                 completer=None, use_rlcompleter=True,
+                 start_script=None, quit_func=None):
+        _ReadLine.__init__(self, quit_func)
+
+        code.InteractiveInterpreter.__init__(self, locals)
+        self.locals["__console__"] = self
+
+        # The builtin raw_input function reads from stdin, we don't want
+        # this. Therefore, replace this function with our own modal raw
+        # input function.
+        exec "import __builtin__" in self.locals
+        self.locals['__builtin__'].__dict__['raw_input'] = lambda text='': self.modal_raw_input(text)
+        self.locals['__builtin__'].__dict__['input'] = lambda text='': self.modal_input(text)
+
+        self.start_script = start_script
+        self.completer = completer
+        self.banner = banner
+
+        if not self.completer and use_rlcompleter:
+            try:
+                import rlcompleter
+                self.completer = rlcompleter.Completer()
+            except ImportError:
+                pass
+
+        self.ps1 = ">>> "
+        self.ps2 = "... "
+        self.__start()
+        self.run_on_raw_input = start_script
+        self.raw_input(self.ps1)
+
+    def __start(self):
+        self.cmd_buffer = ""
+
+        self.freeze_undo()
+        self.thaw_undo()
+
+        self.do_delete = True
+        self.buffer.set_text("")
+        self.do_delete = False
+
+        if self.banner:
+            iter = self.buffer.get_start_iter()
+            self.buffer.insert_with_tags_by_name(iter, self.banner, "stdout")
+            if not iter.starts_line():
+                self.buffer.insert(iter, "\n")
+
+    def clear(self, start_script=None):
+        if start_script is None:
+            start_script = self.start_script
+        else:
+            self.start_script = start_script
+
+        self.__start()
+        self.run_on_raw_input = start_script
+        self.raw_input(self.ps1)
+
+    def do_raw_input(self, text):
+        if self.cmd_buffer:
+            cmd = self.cmd_buffer + "\n" + text
+        else:
+            cmd = text
+
+        saved_stdout, saved_stderr = sys.stdout, sys.stderr
+        sys.stdout, sys.stderr = self._stdout, self._stderr
+
+        if self.runsource(cmd):
+            self.cmd_buffer = cmd
+            ps = self.ps2
+        else:
+            self.cmd_buffer = ''
+            ps = self.ps1
+
+        sys.stdout, sys.stderr = saved_stdout, saved_stderr
+        self.raw_input(ps)
+
+    def do_command(self, code):
+        try:
+            eval(code, self.locals)
+        except SystemExit:
+            if self.quit_func:
+                self.quit_func()
+            else:
+                raise
+        except:
+            self.showtraceback()
+
+    def runcode(self, code):
+        if gtk.pygtk_version[1] < 8:
+            self.do_command(code)
+        else:
+            self.emit("command", code)
+
+    def complete_attr(self, start, end):
+        try:
+            obj = eval(start, self.locals)
+            strings = dir(obj)
+
+            if end:
+                completions = {}
+                for s in strings:
+                    if s.startswith(end):
+                        completions[s] = None
+                completions = completions.keys()
+            else:
+                completions = strings
+
+            completions.sort()
+            return [start + "." + s for s in completions]
+        except:
+            return None
+
+    def complete(self, text):
+        if self.completer:
+            completions = []
+            i = 0
+            try:
+                while 1:
+                    s = self.completer.complete(text, i)
+                    if s:
+                        completions.append(s)
+                        i = i + 1
+                    else:
+                        completions.sort()
+                        return completions
+            except NameError:
+                return None
+
+        dot = text.rfind(".")
+        if dot >= 0:
+            return self.complete_attr(text[:dot], text[dot+1:])
+
+        completions = {}
+        strings = keyword.kwlist
+
+        if self.locals:
+            strings.extend(self.locals.keys())
+
+        try: strings.extend(eval("globals()", self.locals).keys())
+        except: pass
+
+        try:
+            exec "import __builtin__" in self.locals
+            strings.extend(eval("dir(__builtin__)", self.locals))
+        except:
+            pass
+
+        for s in strings:
+            if s.startswith(text):
+                completions[s] = None
+        completions = completions.keys()
+        completions.sort()
+        return completions
+
+
+def ReadLineType(t=gtk.TextView):
+    class readline(t, _ReadLine):
+        def __init__(self, *args, **kwargs):
+            t.__init__(self)
+            _ReadLine.__init__(self, *args, **kwargs)
+        def do_key_press_event(self, event):
+            return _ReadLine.do_key_press_event(self, event, t)
+    gobject.type_register(readline)
+    return readline
+
+def ConsoleType(t=gtk.TextView):
+    class console_type(t, _Console):
+        __gsignals__ = {
+            'command' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object,)),
+            'key-press-event' : 'override'
+          }
+
+        def __init__(self, *args, **kwargs):
+            if gtk.pygtk_version[1] < 8:
+                gobject.GObject.__init__(self)
+            else:
+                t.__init__(self)
+            _Console.__init__(self, *args, **kwargs)
+
+        def do_command(self, code):
+            return _Console.do_command(self, code)
+
+        def do_key_press_event(self, event):
+            return _Console.do_key_press_event(self, event, t)
+
+        def get_default_size(self):
+            context = self.get_pango_context()
+            metrics = context.get_metrics(context.get_font_description(),
+                                          context.get_language())
+            width = metrics.get_approximate_char_width()
+            height = metrics.get_ascent() + metrics.get_descent()
+
+            # Default to a 80x40 console
+            width = pango.PIXELS(int(width * 80 * 1.05))
+            height = pango.PIXELS(height * 40)
+
+            return width, height
+
+    if gtk.pygtk_version[1] < 8:
+        gobject.type_register(console_type)
+
+    return console_type
+
+ReadLine = ReadLineType()
+Console = ConsoleType()
+
+def _make_window():
+    window = gtk.Window()
+    window.set_title("pyconsole.py")
+    swin = gtk.ScrolledWindow()
+    swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
+    window.add(swin)
+    console = Console(banner="Hello there!",
+                      use_rlcompleter=False,
+                      start_script="from gtk import *\n")
+    swin.add(console)
+
+    width, height = console.get_default_size()
+    sb_width, sb_height = swin.get_vscrollbar().size_request()
+
+    window.set_default_size(width + sb_width, height)
+    window.show_all()
+
+    if not gtk.main_level():
+        window.connect("destroy", gtk.main_quit)
+        gtk.main()
+
+    return console
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2 or sys.argv[1] != '-gimp':
+        _make_window()
diff --git a/plug-ins/pygimp/plug-ins/python-console.py b/plug-ins/pygimp/plug-ins/python-console.py
new file mode 100755
index 0000000..a8c7e4c
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/python-console.py
@@ -0,0 +1,245 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+
+t = gettext.translation('gimp20-python', gimp.locale_directory, fallback=True)
+_ = t.ugettext
+
+PROC_NAME = 'python-fu-console'
+
+RESPONSE_BROWSE, RESPONSE_CLEAR, RESPONSE_SAVE = range(3)
+
+def do_console():
+    import pygtk
+    pygtk.require('2.0')
+
+    import sys, gobject, gtk, gimpenums, gimpshelf, gimpui, pyconsole
+    gimpui.gimp_ui_init ()
+
+    namespace = {'__builtins__': __builtins__,
+                 '__name__': '__main__', '__doc__': None,
+                 'gimp': gimp, 'pdb': gimp.pdb,
+                 'shelf': gimpshelf.shelf}
+
+    for s in gimpenums.__dict__.keys():
+        if s[0] != '_':
+            namespace[s] = getattr(gimpenums, s)
+
+    class GimpConsole(pyconsole.Console):
+        def __init__(self, quit_func=None):
+            banner = ('GIMP %s Python Console\nPython %s\n' %
+                      (gimp.pdb.gimp_version(), sys.version))
+            pyconsole.Console.__init__(self,
+                                       locals=namespace, banner=banner,
+                                       quit_func=quit_func)
+        def _commit(self):
+            pyconsole.Console._commit(self)
+            gimp.displays_flush()
+
+    class ConsoleDialog(gimpui.Dialog):
+        def __init__(self):
+            gimpui.Dialog.__init__(self, title=_("Python Console"),
+                                   role=PROC_NAME, help_id=PROC_NAME,
+                                   buttons=(gtk.STOCK_SAVE,  RESPONSE_SAVE,
+                                            gtk.STOCK_CLEAR, RESPONSE_CLEAR,
+                                            _("_Browse..."), RESPONSE_BROWSE,
+                                            gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
+
+            self.set_name (PROC_NAME)
+            self.set_alternative_button_order((gtk.RESPONSE_CLOSE,
+                                               RESPONSE_BROWSE,
+                                               RESPONSE_CLEAR,
+                                               RESPONSE_SAVE))
+
+            self.cons = GimpConsole(quit_func=lambda: gtk.main_quit())
+
+            self.style_set (None, None)
+
+            self.connect('response', self.response)
+            self.connect('style-set', self.style_set)
+
+            self.browse_dlg = None
+            self.save_dlg = None
+
+            vbox = gtk.VBox(False, 12)
+            vbox.set_border_width(12)
+            self.vbox.pack_start(vbox)
+
+            scrl_win = gtk.ScrolledWindow()
+            scrl_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
+            vbox.pack_start(scrl_win)
+
+            scrl_win.add(self.cons)
+
+            width, height = self.cons.get_default_size()
+            sb_width, sb_height = scrl_win.get_vscrollbar().size_request()
+
+            # Account for scrollbar width and border width to ensure
+            # the text view gets a width of 80 characters. We don't care
+            # so much whether the height will be exactly 40 characters.
+            self.set_default_size(width + sb_width + 2 * 12, height)
+
+        def style_set(self, old_style, user_data):
+            style = self.get_style ()
+            self.cons.stdout_tag.set_property ("foreground", style.text[gtk.STATE_NORMAL])
+            self.cons.stderr_tag.set_property ("foreground", style.text[gtk.STATE_INSENSITIVE])
+
+        def response(self, dialog, response_id):
+            if response_id == RESPONSE_BROWSE:
+                self.browse()
+            elif response_id == RESPONSE_CLEAR:
+                self.cons.banner = None
+                self.cons.clear()
+            elif response_id == RESPONSE_SAVE:
+                self.save_dialog()
+            else:
+                gtk.main_quit()
+
+            self.cons.grab_focus()
+
+        def browse_response(self, dlg, response_id):
+            if response_id != gtk.RESPONSE_APPLY:
+                dlg.hide()
+                return
+
+            proc_name = dlg.get_selected()
+
+            if not proc_name:
+                return
+
+            proc = pdb[proc_name]
+
+            cmd = ''
+
+            if len(proc.return_vals) > 0:
+                cmd = ', '.join([x[1].replace('-', '_')
+                                for x in proc.return_vals]) + ' = '
+
+            cmd = cmd + 'pdb.%s' % proc.proc_name.replace('-', '_')
+
+            if len(proc.params) > 0 and proc.params[0][1] == 'run-mode':
+                params = proc.params[1:]
+            else:
+                params = proc.params
+
+            cmd = cmd + '(%s)' % ', '.join([x[1].replace('-', '_')
+                                           for x in params])
+
+            buffer = self.cons.buffer
+
+            lines = buffer.get_line_count()
+            iter = buffer.get_iter_at_line_offset(lines - 1, 4)
+            buffer.delete(iter, buffer.get_end_iter())
+            buffer.place_cursor(buffer.get_end_iter())
+            buffer.insert_at_cursor(cmd)
+
+        def browse(self):
+            if not self.browse_dlg:
+                dlg = gimpui.ProcBrowserDialog(_("Python Procedure Browser"),
+                                               role=PROC_NAME,
+                                               buttons=(gtk.STOCK_APPLY,
+                                                        gtk.RESPONSE_APPLY,
+                                                        gtk.STOCK_CLOSE,
+                                                        gtk.RESPONSE_CLOSE))
+
+                dlg.set_default_response(gtk.RESPONSE_APPLY)
+                dlg.set_alternative_button_order((gtk.RESPONSE_CLOSE,
+                                                  gtk.RESPONSE_APPLY))
+
+                dlg.connect('response', self.browse_response)
+                dlg.connect('row-activated',
+                            lambda dlg: dlg.response(gtk.RESPONSE_APPLY))
+
+                self.browse_dlg = dlg
+
+            self.browse_dlg.present()
+
+        def save_response(self, dlg, response_id):
+            if response_id == gtk.RESPONSE_DELETE_EVENT:
+                self.save_dlg = None
+                return
+            elif response_id == gtk.RESPONSE_OK:
+                filename = dlg.get_filename()
+
+                try:
+                    logfile = open(filename, 'w')
+                except IOError, e:
+                    gimp.message(_("Could not open '%s' for writing: %s") %
+                                 (filename, e.strerror))
+                    return
+
+                buffer = self.cons.buffer
+
+                start = buffer.get_start_iter()
+                end = buffer.get_end_iter()
+
+                log = buffer.get_text(start, end, False)
+
+                try:
+                    logfile.write(log)
+                    logfile.close()
+                except IOError, e:
+                    gimp.message(_("Could not write to '%s': %s") %
+                                 (filename, e.strerror))
+                    return
+
+            dlg.hide()
+
+        def save_dialog(self):
+            if not self.save_dlg:
+                dlg = gtk.FileChooserDialog(_("Save Python-Fu Console Output"),
+                                            parent=self,
+                                            action=gtk.FILE_CHOOSER_ACTION_SAVE,
+                                            buttons=(gtk.STOCK_CANCEL,
+                                                     gtk.RESPONSE_CANCEL,
+                                                     gtk.STOCK_SAVE,
+                                                     gtk.RESPONSE_OK))
+
+                dlg.set_default_response(gtk.RESPONSE_OK)
+                dlg.set_alternative_button_order((gtk.RESPONSE_OK,
+                                                  gtk.RESPONSE_CANCEL))
+
+                dlg.connect('response', self.save_response)
+
+                self.save_dlg = dlg
+
+            self.save_dlg.present()
+
+        def run(self):
+            self.show_all()
+            gtk.main()
+
+    ConsoleDialog().run()
+
+register(
+    PROC_NAME,
+    N_("Interactive GIMP Python interpreter"),
+    "Type in commands and see results",
+    "James Henstridge",
+    "James Henstridge",
+    "1997-1999",
+    N_("_Console"),
+    "",
+    [],
+    [],
+    do_console,
+    menu="<Image>/Filters/Languages/Python-Fu",
+    domain=("gimp20-python", gimp.locale_directory))
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/python-eval.py b/plug-ins/pygimp/plug-ins/python-eval.py
new file mode 100755
index 0000000..9c1663d
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/python-eval.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 2006  Manish Singh <yosh@gimp.org>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+
+def code_eval(code):
+    if code == '-':
+        import sys
+        code = sys.stdin
+    exec code in globals()
+
+register(
+        "python-fu-eval",
+        "Evaluate Python code",
+        "Evaluate python code under the python interpreter (primarily for batch mode)",
+        "Manish Singh",
+        "Manish Singh",
+        "2006",
+        None,
+        None,
+        [
+            (PF_STRING, "code", "The code to evaluate", "")
+        ],
+        [],
+        code_eval)
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/shadow_bevel.py b/plug-ins/pygimp/plug-ins/shadow_bevel.py
new file mode 100755
index 0000000..29a9246
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/shadow_bevel.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpfu import *
+
+gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
+
+def shadow_bevel(img, drawable, blur, bevel, do_shadow, drop_x, drop_y):
+    # disable undo for the image
+    img.undo_group_start()
+
+    # copy the layer
+    shadow = drawable.copy(True)
+    img.insert_layer(shadow, position=img.layers.index(drawable) + 1)
+    shadow.name = drawable.name + " shadow"
+    shadow.lock_alpha = False
+
+    # threshold the shadow layer to all white
+    pdb.gimp_threshold(shadow, 0, 255)
+
+    # blur the shadow layer
+    pdb.plug_in_gauss_iir(img, shadow, blur, True, True)
+
+    # do the bevel thing ...
+    if bevel:
+        pdb.plug_in_bump_map(img, drawable, shadow, 135, 45, 3,
+                             0, 0, 0, 0, True, False, 0)
+
+    # make the shadow layer black now ...
+    pdb.gimp_drawable_invert(shadow, False)
+
+    # translate the drop shadow
+    shadow.translate(drop_x, drop_y)
+
+    if not do_shadow:
+        # delete shadow ...
+        gimp.delete(shadow)
+
+    # enable undo again
+    img.undo_group_end()
+
+
+register(
+    "python-fu-shadow-bevel",
+    N_("Add a drop shadow to a layer, and optionally bevel it"),
+    "Add a drop shadow to a layer, and optionally bevel it",
+    "James Henstridge",
+    "James Henstridge",
+    "1999",
+    N_("_Drop Shadow and Bevel..."),
+    "RGBA, GRAYA",
+    [
+        (PF_IMAGE, "image", "Input image", None),
+        (PF_DRAWABLE, "drawable", "Input drawable", None),
+        (PF_SLIDER, "blur",   _("_Shadow blur"), 6, (1, 30, 1)),
+        (PF_BOOL,   "bevel",  _("_Bevel"),       True),
+        (PF_BOOL,   "shadow", _("_Drop shadow"), True),
+        (PF_INT,    "drop-x", _("Drop shadow _X displacement"), 3),
+        (PF_INT,    "drop-y", _("Drop shadow _Y displacement"), 6)
+    ],
+    [],
+    shadow_bevel,
+    menu="<Image>/Filters/Light and Shadow/Shadow",
+    domain=("gimp20-python", gimp.locale_directory)
+    )
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/sphere.py b/plug-ins/pygimp/plug-ins/sphere.py
new file mode 100755
index 0000000..889c3f7
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/sphere.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import math
+from gimpfu import *
+
+def sphere(radius, light, shadow, foo, bg_colour, sphere_colour):
+    if radius < 1:
+        radius = 1
+
+    width = int(radius * 3.75)
+    height = int(radius * 2.5)
+
+    gimp.context_push()
+
+    img = gimp.Image(width, height, RGB)
+
+    drawable = gimp.Layer(img, "Sphere Layer", width, height,
+                          RGB_IMAGE, 100, NORMAL_MODE)
+
+    radians = light * math.pi / 180
+
+    cx = width / 2
+    cy = height / 2
+
+    light_x = cx + radius * 0.6 * math.cos(radians)
+    light_y = cy - radius * 0.6 * math.sin(radians)
+
+    light_end_x = cx + radius * math.cos(math.pi + radians)
+    light_end_y = cy - radius * math.sin(math.pi + radians)
+
+    offset = radius * 0.1
+
+    img.disable_undo()
+    img.insert_layer(drawable)
+
+    gimp.set_foreground(sphere_colour)
+
+    gimp.set_background(bg_colour)
+    pdb.gimp_edit_fill(drawable, BACKGROUND_FILL)
+
+    gimp.set_background(20, 20, 20)
+
+    if (light >= 45 and light <= 75 or light <= 135 and
+        light >= 105) and shadow:
+        shadow_w = radius * 2.5 * math.cos(math.pi + radians)
+        shadow_h = radius * 0.5
+        shadow_x = cx
+        shadow_y = cy + radius * 0.65
+
+        if shadow_w < 0:
+            shadow_x = cx + shadow_w
+            shadow_w = -shadow_w
+
+        pdb.gimp_ellipse_select(img, shadow_x, shadow_y, shadow_w, shadow_h,
+                                CHANNEL_OP_REPLACE, True, True, 7.5)
+        pdb.gimp_edit_bucket_fill(drawable, BG_BUCKET_FILL,
+                                  MULTIPLY_MODE, 100, 0, False, 0, 0)
+
+    pdb.gimp_ellipse_select(img, cx - radius, cy - radius, 2 * radius,
+                            2 * radius, CHANNEL_OP_REPLACE, True, False, 0)
+    pdb.gimp_edit_blend(drawable, FG_BG_RGB_MODE, NORMAL_MODE, GRADIENT_RADIAL,
+                        100, offset, REPEAT_NONE, False, False, 0, 0, True,
+                        light_x, light_y, light_end_x, light_end_y)
+
+    pdb.gimp_selection_none(img)
+
+    img.enable_undo()
+
+    disp = gimp.Display(img)
+
+    gimp.context_pop()
+
+
+register(
+    "python-fu-sphere",
+    "Simple sphere with drop shadow",
+    "Simple sphere with drop shadow",
+    "James Henstridge",
+    "James Henstridge",
+    "1997-1999, 2007",
+    "_Sphere",
+    "",
+    [
+        (PF_INT, "radius", "Radius for sphere", 100),
+        (PF_SLIDER, "light", "Light angle", 45, (0,360,1)),
+        (PF_TOGGLE, "shadow", "Shadow?", 1),
+        (PF_RADIO, "foo", "Test", "foo", (("Foo", "foo"), ("Bar", "bar"))),
+        (PF_COLOR, "bg-color", "Background", (1.0, 1.0, 1.0)),
+        (PF_COLOR, "sphere-color", "Sphere", "orange")
+    ],
+    [],
+    sphere,
+    menu="<Image>/Filters/Languages/Python-Fu/Test")
+
+main()
diff --git a/plug-ins/pygimp/plug-ins/spyro_plus.py b/plug-ins/pygimp/plug-ins/spyro_plus.py
new file mode 100644
index 0000000..7d31c54
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/spyro_plus.py
@@ -0,0 +1,2212 @@
+#!/usr/bin/env python2
+
+# Draw Spyrographs, Epitrochoids, and Lissajous curves with interactive feedback.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from gimpshelf import shelf
+from gimpenums import *
+import gimp
+import gimpplugin
+import gimpui
+import gobject
+import gtk
+gdk = gtk.gdk
+
+from math import pi, sin, cos, atan, atan2, fmod, radians, sqrt
+import gettext
+import fractions
+import time
+
+
+# i18n
+t = gettext.translation("gimp20-python", gimp.locale_directory, fallback=True)
+_ = t.ugettext
+
+def N_(message):
+    return message
+
+
+pdb = gimp.pdb
+
+two_pi, half_pi = 2 * pi, pi / 2
+layer_name = _("Spyro Layer")
+path_name = _("Spyro Path")
+
+# "Enums"
+GEAR_NOTATION, TOY_KIT_NOTATION, VISUAL_NOTATION = range(3)       # Pattern notations
+
+# Mapping of pattern notation to the corresponding tab in the pattern notation notebook.
+pattern_notation_page = {}
+
+# Save options of the dialog
+SAVE_AS_NEW_LAYER, SAVE_BY_REDRAW, SAVE_AS_PATH = range(3)
+save_options = [
+    _("Save\nas New Layer"),
+    _("Redraw on\nActive layer"),
+    _("Save\nas Path")
+]
+
+ring_teeth = [96, 144, 105, 150]
+
+# Moving gear. Each gear is a pair of (#teeth, #holes)
+# Hole #1 is closest to the edge of the wheel.
+# The last hole is closest to the center.
+wheel = [
+    (24, 5), (30, 8), (32, 9), (36, 11), (40, 13), (42, 14), (45, 16),
+    (48, 17), (50, 18), (52, 19), (56, 21), (60, 23), (63, 25), (64, 25),
+    (72, 29), (75, 31), (80, 33), (84, 35)
+]
+wheel_teeth = [wh[0] for wh in wheel]
+
+
+def lcm(a, b):
+    """ Least common multiplier """
+    return a * b // fractions.gcd(a, b)
+
+
+### Shapes
+
+
+class CanRotateShape:
+    pass
+
+
+class Shape:
+    def configure(self, img, pp, cp):
+        self.image, self.pp, self.cp = img, pp, cp
+
+    def can_equal_w_h(self):
+        return True
+
+    def has_sides(self):
+        return isinstance(self, SidedShape)
+
+    def can_rotate(self):
+        return isinstance(self, CanRotateShape)
+
+    def can_morph(self):
+        return self.has_sides()
+
+
+class CircleShape(Shape):
+    name = _("Circle")
+
+    def get_center_of_moving_gear(self, oangle, dist=None):
+        """
+        :return: x,y - position where the center of the moving gear should be,
+                     after going over oangle/two_pi of a full cycle over the outer gear.
+        """
+        cp = self.cp
+        if dist is None:
+            dist = cp.moving_gear_radius
+
+        return (cp.x_center + (cp.x_half_size - dist) * cos(oangle),
+                cp.y_center + (cp.y_half_size - dist) * sin(oangle))
+
+
+class SidedShape(CanRotateShape, Shape):
+
+    def configure(self, img, pp, cp):
+        Shape.configure(self, img, pp, cp)
+        self.angle_of_each_side = two_pi / pp.sides
+        self.half_angle = self.angle_of_each_side / 2.0
+        self.cos_half_angle = cos(self.half_angle)
+
+    def get_center_of_moving_gear(self, oangle, dist=None):
+        if dist is None:
+            dist = self.cp.moving_gear_radius
+        shape_factor = self.get_shape_factor(oangle)
+        return (
+            self.cp.x_center +
+            (self.cp.x_half_size - dist) * shape_factor * cos(oangle),
+            self.cp.y_center +
+            (self.cp.y_half_size - dist) * shape_factor * sin(oangle)
+        )
+
+
+class PolygonShape(SidedShape):
+    name = _("Polygon-Star")
+
+    def get_shape_factor(self, oangle):
+        oangle_mod = fmod(oangle + self.cp.shape_rotation_radians, self.angle_of_each_side)
+        if oangle_mod > self.half_angle:
+            oangle_mod = self.angle_of_each_side - oangle_mod
+
+        # When oangle_mod = 0, the shape_factor will be cos(half_angle)) - which is the minimal shape_factor.
+        # When oangle_mod is near the half_angle, the shape_factor will near 1.
+        shape_factor = self.cos_half_angle / cos(oangle_mod)
+        shape_factor -= self.pp.morph * (1 - shape_factor) * (1 + (self.pp.sides - 3) * 2)
+        return shape_factor
+
+
+class SineShape(SidedShape):
+    # Sine wave on a circle ring.
+    name = _("Sine")
+
+    def get_shape_factor(self, oangle):
+        oangle_mod = fmod(oangle + self.cp.shape_rotation_radians, self.angle_of_each_side)
+        oangle_stretched = oangle_mod * self.pp.sides
+        return 1 - self.pp.morph * (cos(oangle_stretched) + 1)
+
+
+class BumpShape(SidedShape):
+    # Semi-circles, based on a polygon
+    name = _("Bumps")
+
+    def get_shape_factor(self, oangle):
+        oangle_mod = fmod(oangle + self.cp.shape_rotation_radians, self.angle_of_each_side)
+        # Stretch back to angle between 0 and pi
+        oangle_stretched = oangle_mod/2.0 * self.pp.sides
+
+        # Compute factor for polygon.
+        poly_angle = oangle_mod
+        if poly_angle > self.half_angle:
+            poly_angle = self.angle_of_each_side - poly_angle
+        # When poly_oangle = 0, the shape_factor will be cos(half_angle)) - the minimal shape_factor.
+        # When poly_angle is near the half_angle, the shape_factor will near 1.
+        polygon_factor = self.cos_half_angle / cos(poly_angle)
+
+        # Bump
+        return polygon_factor - self.pp.morph * (1 - abs(cos(oangle_stretched)))
+
+
+class ShapePart(object):
+    def set_bounds(self, start, end):
+        self.bound_start, self.bound_end = start, end
+        self.bound_diff = self.bound_end - self.bound_start
+
+
+class StraightPart(ShapePart):
+
+    def __init__(self, teeth, perp_direction, x1, y1, x2, y2):
+        self.teeth, self.perp_direction = max(teeth, 1),  perp_direction
+        self.x1, self.y1, self.x2, self.y2 = x1, y1, x2, y2
+        self.x_diff = self.x2 - self.x1
+        self.y_diff = self.y2 - self.y1
+
+        angle =  atan2(self.y_diff, self.x_diff) # - shape_rotation_radians
+        perp_angle = angle + perp_direction * half_pi
+        self.sin_angle = sin(perp_angle)
+        self.cos_angle = cos(perp_angle)
+
+    def perpendicular_at_oangle(self, oangle, perp_distance):
+        factor = (oangle - self.bound_start) / self.bound_diff
+        return (self.x1 + factor * self.x_diff + perp_distance * self.cos_angle,
+                self.y1 + factor * self.y_diff + perp_distance * self.sin_angle)
+
+
+class RoundPart(ShapePart):
+
+    def __init__(self, teeth, x, y, start_angle, end_angle):
+        self.teeth = max(teeth, 1)
+        self.start_angle, self.end_angle = start_angle, end_angle
+        self.x, self.y = x, y
+
+        self.diff_angle = self.end_angle - self.start_angle
+
+    def perpendicular_at_oangle(self, oangle, perp_distance):
+        angle = (
+            self.start_angle +
+            self.diff_angle * (oangle - self.bound_start) / self.bound_diff
+        )
+        return (self.x + perp_distance * cos(angle),
+                self.y + perp_distance * sin(angle))
+
+
+class ShapeParts(list):
+    """ A list of shape parts. """
+
+    def __init__(self):
+        list.__init__(self)
+        self.total_teeth = 0
+
+    def finish(self):
+        for part in self:
+            self.total_teeth += part.teeth
+        teeth = 0
+        bound_end = 0.0
+        for part in self:
+            bound_start = bound_end
+            teeth += part.teeth
+            bound_end = teeth/float(self.total_teeth) * two_pi
+            part.set_bounds(bound_start, bound_end)
+
+    def perpendicular_at_oangle(self, oangle, perp_distance):
+        for part in self:
+            if oangle <= part.bound_end:
+                return part.perpendicular_at_oangle(oangle, perp_distance)
+
+        # We shouldn't reach here
+        return 0.0, 0.0
+
+
+class AbstractShapeFromParts(Shape):
+    def __init__(self):
+        self.parts = None
+
+    def get_center_of_moving_gear(self, oangle, dist=None):
+        """
+        :param oangle: an angle in radians, between 0 and 2*pi
+        :return: x,y - position where the center of the moving gear should be,
+                     after going over oangle/two_pi of a full cycle over the outer gear.
+        """
+        if dist is None:
+            dist = self.cp.moving_gear_radius
+        return self.parts.perpendicular_at_oangle(oangle, dist)
+
+
+class RackShape(CanRotateShape, AbstractShapeFromParts):
+    name = _("Rack")
+
+    def configure(self, img, pp, cp):
+        Shape.configure(self, img, pp, cp)
+
+        round_teeth = 12
+        side_teeth = (cp.fixed_gear_teeth - 2 * round_teeth) / 2
+
+        # Determine start and end points of rack.
+
+        cos_rot = cos(cp.shape_rotation_radians)
+        sin_rot = sin(cp.shape_rotation_radians)
+
+        x_size = cp.x2 - cp.x1 - cp.moving_gear_radius * 4
+        y_size = cp.y2 - cp.y1 - cp.moving_gear_radius * 4
+
+        size = ((x_size * cos_rot)**2 + (y_size * sin_rot)**2) ** 0.5
+
+        x1 = cp.x_center - size/2.0 * cos_rot
+        y1 = cp.y_center - size/2.0 * sin_rot
+        x2 = cp.x_center + size/2.0 * cos_rot
+        y2 = cp.y_center + size/2.0 * sin_rot
+
+        # Build shape from shape parts.
+        self.parts = ShapeParts()
+        self.parts.append(StraightPart(side_teeth, -1, x2, y2, x1, y1))
+        self.parts.append(
+            RoundPart(
+                round_teeth, x1, y1,
+                half_pi + cp.shape_rotation_radians,
+                3 * half_pi + cp.shape_rotation_radians
+            )
+        )
+        self.parts.append(StraightPart(side_teeth, -1, x1, y1, x2, y2))
+        self.parts.append(
+            RoundPart(
+                round_teeth, x2, y2,
+                3 * half_pi + cp.shape_rotation_radians,
+                5 * half_pi + cp.shape_rotation_radians)
+        )
+        self.parts.finish()
+
+
+class FrameShape(AbstractShapeFromParts):
+    name = _("Frame")
+
+    def configure(self, img, pp, cp):
+        Shape.configure(self, img, pp, cp)
+
+        x1, x2 = cp.x1 + cp.moving_gear_radius, cp.x2 - cp.moving_gear_radius
+        y1, y2 = cp.y1 + cp.moving_gear_radius, cp.y2 - cp.moving_gear_radius
+        x_diff, y_diff = abs(x2 - x1), abs(y2 - y1)
+
+        # Build shape from shape parts.
+        self.parts = ShapeParts()
+        self.parts.append(StraightPart(x_diff, 1, x2, cp.y2, x1, cp.y2))
+        self.parts.append(StraightPart(y_diff, 1, cp.x1, y2, cp.x1, y1))
+        self.parts.append(StraightPart(x_diff, 1, x1, cp.y1, x2, cp.y1))
+        self.parts.append(StraightPart(y_diff, 1, cp.x2, y1, cp.x2, y2))
+        self.parts.finish()
+
+
+class SelectionToPath:
+    """ Converts a selection to a path """
+
+    def __init__(self, image):
+        self.image = image
+
+        # Compute hash of selection, so we can detect when it was modified.
+        self.last_selection_hash = self.compute_selection_hash()
+
+        self.convert_selection_to_path()
+
+    def convert_selection_to_path(self):
+
+        if pdb.gimp_selection_is_empty(self.image):
+            selection_was_empty = True
+            pdb.gimp_selection_all(self.image)
+        else:
+            selection_was_empty = False
+
+        pdb.plug_in_sel2path(self.image, self.image.active_layer)
+
+        self.path = self.image.vectors[0]
+
+        self.num_strokes, self.stroke_ids = pdb.gimp_vectors_get_strokes(self.path)
+        self.stroke_ids = list(self.stroke_ids)
+
+        # A path may contain several strokes. If so lets throw away a stroke that
+        # simply describes the borders of the image, if one exists.
+        if self.num_strokes > 1:
+            # Lets compute what a stroke of the image borders should look like.
+            w, h = float(self.image.width), float(self.image.height)
+            frame_strokes = [0.0] * 6 + [0.0, h] * 3 + [w, h] * 3 + [w, 0.0] * 3
+
+            for stroke in range(self.num_strokes):
+                strokes = self.path.strokes[stroke].points[0]
+                if strokes == frame_strokes:
+                    del self.stroke_ids[stroke]
+                    self.num_strokes -= 1
+                    break
+
+        self.set_current_stroke(0)
+
+        if selection_was_empty:
+            # Restore empty selection if it was empty.
+            pdb.gimp_selection_none(self.image)
+
+    def compute_selection_hash(self):
+        px = self.image.selection.get_pixel_rgn(0, 0, self.image.width, self.image.height)
+        return px[0:self.image.width, 0:self.image.height].__hash__()
+
+    def regenerate_path_if_selection_changed(self):
+        current_selection_hash = self.compute_selection_hash()
+        if self.last_selection_hash != current_selection_hash:
+            self.last_selection_hash = current_selection_hash
+            self.convert_selection_to_path()
+
+    def get_num_strokes(self):
+        return self.num_strokes
+
+    def set_current_stroke(self, stroke_id=0):
+        # Compute path length.
+        self.path_length = pdb.gimp_vectors_stroke_get_length(self.path, self.stroke_ids[stroke_id], 1.0)
+        self.current_stroke = stroke_id
+
+    def point_at_angle(self, oangle):
+        oangle_mod = fmod(oangle, two_pi)
+        dist = self.path_length * oangle_mod / two_pi
+        return pdb.gimp_vectors_stroke_get_point_at_dist(self.path, self.stroke_ids[self.current_stroke], dist, 1.0)
+
+
+class SelectionShape(Shape):
+    name = _("Selection")
+
+    def __init__(self):
+        self.path = None
+
+    def process_selection(self, img):
+        if self.path is None:
+            self.path = SelectionToPath(img)
+        else:
+            self.path.regenerate_path_if_selection_changed()
+
+    def configure(self, img, pp, cp):
+        """ Set bounds of pattern """
+        Shape.configure(self, img, pp, cp)
+        self.drawing_no = cp.current_drawing
+        self.path.set_current_stroke(self.drawing_no)
+
+    def get_num_drawings(self):
+        return self.path.get_num_strokes()
+
+    def can_equal_w_h(self):
+        return False
+
+    def get_center_of_moving_gear(self, oangle, dist=None):
+        """
+        :param oangle: an angle in radians, between 0 and 2*pi
+        :return: x,y - position where the center of the moving gear should be,
+                     after going over oangle/two_pi of a full cycle over the outer gear.
+        """
+        cp = self.cp
+        if dist is None:
+            dist = cp.moving_gear_radius
+        x, y, slope, valid = self.path.point_at_angle(oangle)
+        slope_angle = atan(slope)
+        # We want to find an angle perpendicular to the slope, but in which direction?
+        # Lets try both sides and see which of them is inside the selection.
+        perpendicular_p, perpendicular_m = slope_angle + half_pi, slope_angle - half_pi
+        step_size = 2   # The distance we are going to go in the direction of each angle.
+        xp, yp = x + step_size * cos(perpendicular_p), y + step_size * sin(perpendicular_p)
+        value_plus = pdb.gimp_selection_value(self.image, xp, yp)
+        xp, yp = x + step_size * cos(perpendicular_m), y + step_size * sin(perpendicular_m)
+        value_minus = pdb.gimp_selection_value(self.image, xp, yp)
+
+        perpendicular = perpendicular_p if value_plus > value_minus else perpendicular_m
+        return x + dist * cos(perpendicular), y + dist * sin(perpendicular)
+
+
+shapes = [
+    CircleShape(), RackShape(), FrameShape(), SelectionShape(),
+    PolygonShape(), SineShape(), BumpShape()
+]
+
+
+### Tools
+
+
+def get_gradient_samples(num_samples):
+    gradient_name = pdb.gimp_context_get_gradient()
+    reverse_mode = pdb.gimp_context_get_gradient_reverse()
+    repeat_mode = pdb.gimp_context_get_gradient_repeat_mode()
+
+    if repeat_mode == REPEAT_TRIANGULAR:
+        # Get two uniform samples, which are reversed from each other, and connect them.
+
+        samples = num_samples/2 + 1
+        num, color_samples = pdb.gimp_gradient_get_uniform_samples(gradient_name,
+             samples, reverse_mode)
+
+        color_samples = list(color_samples)
+        del color_samples[-4:]   # Delete last color because it will appear in the next sample
+
+        # If num_samples is odd, lets get an extra sample this time.
+        if num_samples % 2 == 1:
+            samples += 1
+
+        num, color_samples2 = pdb.gimp_gradient_get_uniform_samples(gradient_name,
+             samples, 1 - reverse_mode)
+
+        color_samples2 = list(color_samples2)
+        del color_samples2[-4:]  # Delete last color because it will appear in the very first sample
+
+        color_samples.extend(color_samples2)
+        color_samples = tuple(color_samples)
+    else:
+        num, color_samples = pdb.gimp_gradient_get_uniform_samples(gradient_name, num_samples, reverse_mode)
+
+    return color_samples
+
+
+class PencilTool():
+    name = _("Pencil")
+    can_color = True
+
+    def draw(self, layer, strokes, color=None):
+        if color:
+            pdb.gimp_context_push()
+            pdb.gimp_context_set_dynamics('Dynamics Off')
+            pdb.gimp_context_set_foreground(color)
+
+        pdb.gimp_pencil(layer, len(strokes), strokes)
+
+        if color:
+            pdb.gimp_context_pop()
+
+
+class AirBrushTool():
+    name = _("AirBrush")
+    can_color = True
+
+    def draw(self, layer, strokes, color=None):
+        if color:
+            pdb.gimp_context_push()
+            pdb.gimp_context_set_dynamics('Dynamics Off')
+            pdb.gimp_context_set_foreground(color)
+
+        pdb.gimp_airbrush_default(layer, len(strokes), strokes)
+
+        if color:
+            pdb.gimp_context_pop()
+
+
+class AbstractStrokeTool():
+
+    def draw(self, layer, strokes, color=None):
+        # We need to multiply every point by 3, because we are creating a path,
+        #  where each point has two additional control points.
+        control_points = []
+        for i, k in zip(strokes[0::2], strokes[1::2]):
+            control_points += [i, k] * 3
+
+        # Create path
+        path = pdb.gimp_vectors_new(layer.image, 'temp_path')
+        pdb.gimp_image_add_vectors(layer.image, path, 0)
+        sid = pdb.gimp_vectors_stroke_new_from_points(path, 0, len(control_points),
+                                                      control_points, False)
+
+        # Draw it.
+
+        pdb.gimp_context_push()
+
+        # Call template method to set the kind of stroke to draw.
+        self.prepare_stroke_context(color)
+
+        pdb.gimp_drawable_edit_stroke_item(layer, path)
+        pdb.gimp_context_pop()
+
+        # Get rid of the path.
+        pdb.gimp_image_remove_vectors(layer.image, path)
+
+
+# Drawing tool that should be quick, for purposes of previewing the pattern.
+class PreviewTool:
+
+    # Implementation using pencil.  (A previous implementation using stroke was slower, and thus removed).
+    def draw(self, layer, strokes, color=None):
+        foreground = pdb.gimp_context_get_foreground()
+        pdb.gimp_context_push()
+        pdb.gimp_context_set_defaults()
+        pdb.gimp_context_set_foreground(foreground)
+        pdb.gimp_context_set_dynamics('Dynamics Off')
+        pdb.gimp_context_set_brush('1. Pixel')
+        pdb.gimp_context_set_brush_size(1.0)
+        pdb.gimp_context_set_brush_spacing(3.0)
+        pdb.gimp_pencil(layer, len(strokes), strokes)
+        pdb.gimp_context_pop()
+
+    name = _("Preview")
+    can_color = False
+
+
+class StrokeTool(AbstractStrokeTool):
+    name = _("Stroke")
+    can_color = True
+
+    def prepare_stroke_context(self, color):
+        if color:
+            pdb.gimp_context_set_dynamics('Dynamics Off')
+            pdb.gimp_context_set_foreground(color)
+
+        pdb.gimp_context_set_stroke_method(STROKE_LINE)
+
+
+class StrokePaintTool(AbstractStrokeTool):
+    def __init__(self, name, paint_method, can_color=True):
+        self.name = name
+        self.paint_method = paint_method
+        self.can_color = can_color
+
+    def prepare_stroke_context(self, color):
+        if self.can_color and color is not None:
+            pdb.gimp_context_set_dynamics('Dynamics Off')
+            pdb.gimp_context_set_foreground(color)
+
+        pdb.gimp_context_set_stroke_method(STROKE_PAINT_METHOD)
+        pdb.gimp_context_set_paint_method(self.paint_method)
+
+
+class SaveToPathTool():
+    """ This tool cannot be chosen by the user from the tools menu.
+        We dont add this to the list of tools. """
+
+    def __init__(self, img):
+        self.path = pdb.gimp_vectors_new(img, path_name)
+        pdb.gimp_image_add_vectors(img, self.path, 0)
+
+    def draw(self, layer, strokes, color=None):
+        # We need to multiply every point by 3, because we are creating a path,
+        #  where each point has two additional control points.
+        control_points = []
+        for i, k in zip(strokes[0::2], strokes[1::2]):
+            control_points += [i, k] * 3
+
+        sid = pdb.gimp_vectors_stroke_new_from_points(self.path, 0, len(control_points),
+                                                      control_points, False)
+
+
+tools = [
+    PreviewTool(),
+    StrokePaintTool(_("PaintBrush"), "gimp-paintbrush"),
+    PencilTool(), AirBrushTool(), StrokeTool(),
+    StrokePaintTool(_("Ink"), 'gimp-ink'),
+    StrokePaintTool(_("MyPaintBrush"), 'gimp-mybrush')
+    # Clone does not work properly when an image is not set.  When that happens, drawing fails, and
+    # I am unable to catch the error. This causes the plugin to crash, and subsequent problems with undo.
+    # StrokePaintTool("Clone", 'gimp-clone', False)
+]
+
+
+class PatternParameters:
+    """
+    All the parameters that define a pattern live in objects of this class.
+    If you serialize and saved this class, you should reproduce
+    the pattern that the plugin would draw.
+    """
+    def __init__(self):
+        if not hasattr(self, 'curve_type'):
+            self.curve_type = 0
+
+        # Pattern
+        if not hasattr(self, 'pattern_notation'):
+            self.pattern_notation = 0
+        if not hasattr(self, 'outer_teeth'):
+            self.outer_teeth = 96
+        if not hasattr(self, 'inner_teeth'):
+            self.inner_teeth = 36
+        if not hasattr(self, 'pattern_rotation'):
+            self.pattern_rotation = 0
+        # Location of hole as a percent of the radius of the inner gear - runs between 0 and 100.
+        # A value of 0 means, the hole is at the center of the wheel, which would produce a boring circle.
+        # A value of 100 means the edge of the wheel.
+        if not hasattr(self, 'hole_percent'):
+            self.hole_percent = 100.0
+
+        # Toy Kit parameters
+        # Hole number in Toy Kit notation. Hole #1 is at the edge of the wheel, and the last hole is
+        # near the center of the wheel, but not exactly at the center.
+        if not hasattr(self, 'hole_number'):
+            self.hole_number = 1
+        if not hasattr(self, 'kit_fixed_gear_index'):
+            self.kit_fixed_gear_index = 1
+        if not hasattr(self, 'kit_moving_gear_index'):
+            self.kit_moving_gear_index = 1
+
+        # Visual notation parameters
+        if not hasattr(self, 'petals'):
+            self.petals = 5
+        if not hasattr(self, 'petal_skip'):
+            self.petal_skip = 2
+        if not hasattr(self, 'doughnut_hole'):
+            self.doughnut_hole = 50.0
+        if not hasattr(self, 'doughnut_width'):
+            self.doughnut_width = 50.0
+
+        # Shape
+        if not hasattr(self, 'shape_index'):
+            self.shape_index = 0  # Index in the shapes array
+        if not hasattr(self, 'sides'):
+            self.sides = 5
+        if not hasattr(self, 'morph'):
+            self.morph = 0.5
+        if not hasattr(self, 'shape_rotation'):
+            self.shape_rotation = 0
+
+        if not hasattr(self, 'equal_w_h'):
+            self.equal_w_h = False
+        if not hasattr(self, 'margin_pixels'):
+            self.margin_pixels = 0  # Distance between the drawn shape, and the selection borders.
+
+        # Drawing style
+        if not hasattr(self, 'tool_index'):
+            self.tool_index = 0   # Index in the tools array.
+        if not hasattr(self, 'long_gradient'):
+            self.long_gradient = False
+
+        if not hasattr(self, 'save_option'):
+            self.save_option = SAVE_AS_NEW_LAYER
+
+    def kit_max_hole_number(self):
+        return wheel[self.kit_moving_gear_index][1]
+
+
+# Handle shelving of plugin parameters
+
+def unshelf_parameters():
+    if shelf.has_key("p"):
+        parameters = shelf["p"]
+        parameters.__init__()  # Fill in missing values with defaults.
+        return parameters
+
+    return PatternParameters()
+
+
+def shelf_parameters(pp):
+    shelf["p"] = pp
+
+
+class ComputedParameters:
+    """
+    Stores computations performed on a PatternParameters object.
+    The results of these computations are used to perform the drawing.
+    Having all these computations in one place makes it convenient to pass
+    around as a parameter.
+
+    If the pattern parameters should result in multiple pattern to be drawn, the
+    compute parameters also stores which one is currently being drawn.
+    """
+
+    def __init__(self, pp, img):
+
+        def compute_gradients():
+            self.use_gradient = self.pp.long_gradient and tools[self.pp.tool_index].can_color
+
+            # If gradient is used, determine how the lines are two be split to different colors.
+            if self.use_gradient:
+                # We want to use enough samples to be beautiful, but not too many, that would
+                # force us to make many separate calls for drawing the pattern.
+                if self.rotations > 30:
+                    self.chunk_num = self.rotations
+                    self.chunk_size_lines = self.fixed_gear_teeth
+                else:
+                    # Lets try to find a chunk size, such that it divides num_lines, and we get at least 30 chunks.
+                    # In the worse case, we will just use "1"
+                    for chunk_size in range(self.fixed_gear_teeth - 1, 0, -1):
+                        if self.num_lines % chunk_size == 0:
+                            if self.num_lines / chunk_size > 30:
+                                break
+
+                    self.chunk_num = self.num_lines / chunk_size
+                    self.chunk_size_lines = chunk_size
+
+                self.gradients = get_gradient_samples(self.chunk_num)
+            else:
+                self.chunk_num, self.chunk_size_lines = None, None
+
+        def compute_sizes():
+            # Get rid of the margins.
+            self.x1 = x1 + pp.margin_pixels
+            self.y1 = y1 + pp.margin_pixels
+            self.x2 = x2 - pp.margin_pixels
+            self.y2 = y2 - pp.margin_pixels
+
+            # Compute size and position of the pattern
+            self.x_half_size, self.y_half_size = (self.x2 - self.x1) / 2, (self.y2 - self.y1) / 2
+            self.x_center, self.y_center = (self.x1 + self.x2) / 2.0, (self.y1 + self.y2) / 2.0
+
+            if pp.equal_w_h:
+                if self.x_half_size < self.y_half_size:
+                    self.y_half_size = self.x_half_size
+                    self.y1, self.y2 = self.y_center - self.y_half_size, self.y_center + self.y_half_size
+                elif self.x_half_size > self.y_half_size:
+                    self.x_half_size = self.y_half_size
+                    self.x1, self.x2 = self.x_center - self.x_half_size, self.x_center + self.x_half_size
+
+            # Find the distance between the hole and the center of the inner circle.
+            # To do this, we compute the size of the gears, by the number of teeth.
+            # The circumference of the outer ring is 2 * pi * outer_R = #fixed_gear_teeth * tooth size.
+            outer_R = min(self.x_half_size, self.y_half_size)
+            if self.pp.pattern_notation == VISUAL_NOTATION:
+                doughnut_width = self.pp.doughnut_width
+                if doughnut_width + self.pp.doughnut_hole > 100:
+                    doughnut_width = 100.0 - self.pp.doughnut_hole
+
+                # Let R, r be the radius of fixed and moving gear, and let hp be the hole percent.
+                # Let dwp, dhp be the doughnut width and hole in percents of R.
+                # The two sides of the following equation calculate how to reach the center of the moving
+                # gear from the center of the fixed gear:
+                #  I)     R * (dhp/100 + dwp/100/2) = R - r
+                # The following equation expresses which r and hp would generate a doughnut of width dw.
+                #  II)    R * dw/100 = 2 * r * hp/100
+                # We solve the two above equations to calculate hp and r:
+                self.hole_percent = doughnut_width / (2.0 * (1 - (self.pp.doughnut_hole + doughnut_width/2.0)/100.0))
+                self.moving_gear_radius = outer_R * doughnut_width / (2 * self.hole_percent)
+            else:
+                size_of_tooth_in_pixels = two_pi * outer_R / self.fixed_gear_teeth
+                self.moving_gear_radius = size_of_tooth_in_pixels * self.moving_gear_teeth / two_pi
+
+            self.hole_dist_from_center = self.hole_percent / 100.0 * self.moving_gear_radius
+
+        self.pp = pp
+
+        # Check if the shape is made of multiple shapes, as in using Selection as fixed gear.
+        if (isinstance(shapes[self.pp.shape_index], SelectionShape) and
+            curve_types[self.pp.curve_type].supports_shapes()):
+            shapes[self.pp.shape_index].process_selection(img)
+            pdb.gimp_displays_flush()
+            self.num_drawings = shapes[self.pp.shape_index].get_num_drawings()
+        else:
+            self.num_drawings = 1
+        self.current_drawing = 0
+
+        # Get bounds. We don't care weather a selection exists or not.
+        exists, x1, y1, x2, y2 = pdb.gimp_selection_bounds(img)
+
+        # Combine different ways to specify patterns, into a unified set of computed parameters.
+        self.num_notation_drawings = 1
+        self.current_notation_drawing = 0
+        if self.pp.pattern_notation == GEAR_NOTATION:
+            self.fixed_gear_teeth = int(round(pp.outer_teeth))
+            self.moving_gear_teeth = int(round(pp.inner_teeth))
+            self.petals = self.num_petals()
+            self.hole_percent = pp.hole_percent
+        elif self.pp.pattern_notation == TOY_KIT_NOTATION:
+            self.fixed_gear_teeth = ring_teeth[pp.kit_fixed_gear_index]
+            self.moving_gear_teeth = wheel[pp.kit_moving_gear_index][0]
+            self.petals = self.num_petals()
+            # We want to map hole #1 to 100% and hole of max_hole_number to 2.5%
+            # We don't want 0% because that would be the exact center of the moving gear,
+            # and that would create a boring pattern.
+            max_hole_number = wheel[pp.kit_moving_gear_index][1]
+            self.hole_percent = (max_hole_number - pp.hole_number) / float(max_hole_number - 1) * 97.5 + 2.5
+        elif self.pp.pattern_notation == VISUAL_NOTATION:
+            self.petals = pp.petals
+            self.fixed_gear_teeth = pp.petals
+            self.moving_gear_teeth = pp.petals - pp.petal_skip
+            if self.moving_gear_teeth < 20:
+                self.fixed_gear_teeth *= 10
+                self.moving_gear_teeth *= 10
+            self.hole_percent = 100.0
+            self.num_notation_drawings = fractions.gcd(pp.petals, pp.petal_skip)
+            self.notation_drawings_rotation = two_pi/pp.petals
+
+        # Rotations
+        self.shape_rotation_radians = self.radians_from_degrees(pp.shape_rotation)
+        self.pattern_rotation_start_radians = self.radians_from_degrees(pp.pattern_rotation)
+        self.pattern_rotation_radians = self.pattern_rotation_start_radians
+        # Additional fixed pattern rotation for lissajous.
+        self.lissajous_rotation = two_pi/self.petals/4.0
+
+        # Compute the total number of teeth we have to go over.
+        # Another way to view it is the total of lines we are going to draw.
+        # To find this we compute the Least Common Multiplier.
+        self.num_lines = lcm(self.fixed_gear_teeth, self.moving_gear_teeth)
+        # The number of points we are going to compute. This is the number of lines, plus 1, because to draw
+        # a line we need two points.
+        self.num_points = self.num_lines + 1
+
+        # Compute gradients.
+
+        # The number or rotations needed in order to complete the pattern.
+        # Each rotation has cp.fixed_gear_teeth points + 1 points.
+        self.rotations = self.num_lines / self.fixed_gear_teeth
+
+        compute_gradients()
+
+        # Computations needed for the actual drawing of the patterns - how much should we advance each angle
+        # in each step of the computation.
+
+        # How many radians is each tooth of outer gear.  This is also the amount that we
+        # will step in the iterations that generate the points of the pattern.
+        self.oangle_factor = two_pi / self.fixed_gear_teeth
+        # How many radians should the moving gear be moved, for each tooth of the fixed gear
+        angle_factor = curve_types[pp.curve_type].get_angle_factor(self)
+        self.iangle_factor = self.oangle_factor * angle_factor
+
+        compute_sizes()
+
+    def num_petals(self):
+        """ The number of 'petals' (or points) that will be produced by a spirograph drawing. """
+        return lcm(self.fixed_gear_teeth, self.moving_gear_teeth) / self.moving_gear_teeth
+
+    def radians_from_degrees(self, degrees):
+        positive_degrees = degrees if degrees >= 0 else degrees + 360
+        return radians(positive_degrees)
+
+    def get_color(self, n):
+        return self.gradients[4*n:4*(n+1)]
+
+    def next_drawing(self):
+        """ Multiple drawings can be drawn either when the selection is used as a fixed
+            gear, and/or the visual tab is used, which causes multiple drawings
+            to be drawn at different rotations. """
+        if self.current_notation_drawing < self.num_notation_drawings - 1:
+            self.current_notation_drawing += 1
+            self.pattern_rotation_radians = self.pattern_rotation_start_radians + (
+                    self.current_notation_drawing * self.notation_drawings_rotation)
+        else:
+            self.current_drawing += 1
+            self.current_notation_drawing = 0
+            self.pattern_rotation_radians = self.pattern_rotation_start_radians
+
+    def has_more_drawings(self):
+        return (self.current_notation_drawing < self.num_notation_drawings - 1 or
+                self.current_drawing < self.num_drawings - 1)
+
+
+### Curve types
+
+
+class CurveType:
+
+    def supports_shapes(self):
+        return True
+
+class RouletteCurveType(CurveType):
+
+    def get_strokes(self, p, cp):
+        strokes = []
+        for curr_tooth in range(cp.num_points):
+            iangle = fmod(curr_tooth * cp.iangle_factor + cp.pattern_rotation_radians, two_pi)
+            oangle = fmod(curr_tooth * cp.oangle_factor + cp.pattern_rotation_radians, two_pi)
+
+            x, y = shapes[p.shape_index].get_center_of_moving_gear(oangle)
+            strokes.append(x + cp.hole_dist_from_center * cos(iangle))
+            strokes.append(y + cp.hole_dist_from_center * sin(iangle))
+
+        return strokes
+
+
+class SpyroCurveType(RouletteCurveType):
+    name = _("Spyrograph")
+
+    def get_angle_factor(self, cp):
+        return - (cp.fixed_gear_teeth - cp.moving_gear_teeth) / float(cp.moving_gear_teeth)
+
+
+class EpitrochoidCurvetype(RouletteCurveType):
+    name = _("Epitrochoid")
+
+    def get_angle_factor(self, cp):
+        return (cp.fixed_gear_teeth + cp.moving_gear_teeth) / float(cp.moving_gear_teeth)
+
+
+class SineCurveType(CurveType):
+    name = _("Sine")
+
+    def get_angle_factor(self, cp):
+        return cp.fixed_gear_teeth / float(cp.moving_gear_teeth)
+
+    def get_strokes(self, p, cp):
+        strokes = []
+        for curr_tooth in range(cp.num_points):
+            iangle = curr_tooth * cp.iangle_factor
+            oangle = fmod(curr_tooth * cp.oangle_factor + cp.pattern_rotation_radians, two_pi)
+
+            dist = cp.moving_gear_radius + sin(iangle) * cp.hole_dist_from_center
+            x, y = shapes[p.shape_index].get_center_of_moving_gear(oangle, dist)
+            strokes.append(x)
+            strokes.append(y)
+
+        return strokes
+
+
+class LissaCurveType:
+    name = _("Lissajous")
+
+    def get_angle_factor(self, cp):
+        return cp.fixed_gear_teeth / float(cp.moving_gear_teeth)
+
+    def get_strokes(self, p, cp):
+        strokes = []
+        for curr_tooth in range(cp.num_points):
+            iangle = curr_tooth * cp.iangle_factor
+            # Adding the cp.lissajous_rotation rotation makes the pattern have the same number of curves
+            # as the other curve types. Without it, many lissajous patterns would redraw the same lines twice,
+            # and thus look less dense than the other curves.
+            oangle = fmod(curr_tooth * cp.oangle_factor + cp.pattern_rotation_radians + cp.lissajous_rotation, two_pi)
+
+            strokes.append(cp.x_center + cp.x_half_size * cos(oangle))
+            strokes.append(cp.y_center + cp.y_half_size * cos(iangle))
+
+        return strokes
+
+    def supports_shapes(self):
+        return False
+
+
+curve_types = [SpyroCurveType(), EpitrochoidCurvetype(), SineCurveType(), LissaCurveType()]
+
+# Drawing engine. Also implements drawing incrementally.
+# We don't draw the entire stroke, because it could take several seconds,
+# Instead, we break it into chunks.  Incremental drawing is also used for drawing gradients.
+class DrawingEngine:
+
+    def __init__(self, img, p):
+        self.img, self.p = img, p
+        self.cp = None
+
+        # For incremental drawing
+        self.strokes = []
+        self.start = 0
+        self.chunk_size_lines = 600
+        self.chunk_no = 0
+        # We are aiming for the drawing time of a chunk to be no longer than max_time.
+        self.max_time_sec = 0.1
+
+        self.dynamic_chunk_size = True
+
+    def pre_draw(self):
+        """ Needs to be called before starting to draw a pattern. """
+
+        self.cp = ComputedParameters(self.p, self.img)
+
+    def draw_full(self, layer):
+        """ Non incremental drawing. """
+
+        self.pre_draw()
+        self.img.undo_group_start()
+
+        while true:
+            self.set_strokes()
+
+            if self.cp.use_gradient:
+                while self.has_more_strokes():
+                    self.draw_next_chunk(layer, fetch_next_drawing=False)
+            else:
+                tools[self.p.tool_index].draw(layer, self.strokes)
+
+            if self.cp.has_more_drawings():
+                self.cp.next_drawing()
+            else:
+                break
+
+        self.img.undo_group_end()
+
+        pdb.gimp_displays_flush()
+
+    # Methods for incremental drawing.
+
+    def draw_next_chunk(self, layer, fetch_next_drawing=True, tool=None):
+        stroke_chunk, color = self.next_chunk(fetch_next_drawing)
+        if not tool:
+            tool = tools[self.p.tool_index]
+        tool.draw(layer, stroke_chunk, color)
+        return len(stroke_chunk)
+
+    def set_strokes(self):
+        """ Compute the strokes of the current pattern. The heart of the plugin. """
+
+        shapes[self.p.shape_index].configure(self.img, self.p, self.cp)
+
+        self.strokes = curve_types[self.p.curve_type].get_strokes(self.p, self.cp)
+
+        self.start = 0
+        self.chunk_no = 0
+
+        if self.cp.use_gradient:
+            self.chunk_size_lines = self.cp.chunk_size_lines
+            self.dynamic_chunk_size = False
+        else:
+            self.dynamic_chunk_size = True
+
+    def reset_incremental(self):
+        """ Setup incremental drawing to start drawing from scratch. """
+        self.pre_draw()
+        self.set_strokes()
+
+    def next_chunk(self, fetch_next_drawing):
+
+        # chunk_size_lines, is the number of lines we want to draw. We need 1 extra point to draw that.
+        end = self.start + (self.chunk_size_lines + 1) * 2
+        if end > len(self.strokes):
+            end = len(self.strokes)
+        result = self.strokes[self.start:end]
+        # Promote the start to the last point. This is the start of the first line to draw next time.
+        self.start = end - 2
+        color = self.cp.get_color(self.chunk_no) if self.cp.use_gradient else None
+
+        self.chunk_no += 1
+
+        # If self.strokes has ended, lets fetch strokes for the next drawing.
+        if fetch_next_drawing and not self.has_more_strokes():
+            if self.cp.has_more_drawings():
+                self.cp.next_drawing()
+                self.set_strokes()
+
+        return result, color
+
+    def has_more_strokes(self):
+        return self.start + 2 < len(self.strokes)
+
+    # Used for displaying progress.
+    def fraction_done(self):
+        return (self.start + 2.0) / len(self.strokes)
+
+    def report_time(self, time_sec):
+        """
+        Report the time it took, in seconds, to draw the last stroke chunk.
+        This helps to determine the size of chunks to return in future calls of 'next_chunk',
+        since we want the calls to be short, to not make the user interface feel stuck.
+        """
+        if time_sec != 0 and self.dynamic_chunk_size:
+            self.chunk_size_lines = int(self.chunk_size_lines * self.max_time_sec / time_sec)
+            # Don't let chunk size be too large or small.
+            self.chunk_size_lines = max(10, self.chunk_size_lines)
+            self.chunk_size_lines = min(1000, self.chunk_size_lines)
+
+
+# Constants for DoughnutWidget
+
+# Enum - When the mouse is pressed, which target value is being changed.
+TARGET_NONE, TARGET_HOLE, TARGET_WIDTH = range(3)
+
+CIRCLE_CENTER_X = 4
+RIGHT_MARGIN = 2
+TOTAL_MARGIN = CIRCLE_CENTER_X + RIGHT_MARGIN
+
+# A widget for displaying and setting the pattern of a spirograph, using a "doughnut" as
+# a visual metaphore.  This widget replaces two scale widgets.
+class DoughnutWidget(gtk.DrawingArea):
+    __gtype_name__ = 'DoughnutWidget'
+
+    def __init__(self, *args, **kwds):
+        super(DoughnutWidget, self).__init__(*args, **kwds)
+        self.set_size_request(80, 40)
+
+        self.add_events(
+            gdk.BUTTON1_MOTION_MASK |
+            gdk.BUTTON_PRESS_MASK |
+            gdk.BUTTON_RELEASE_MASK |
+            gdk.POINTER_MOTION_MASK
+        )
+
+        self.default_cursor = self.get_screen().get_root_window().get_cursor()
+        self.resize_cursor = gdk.Cursor(gdk.SB_H_DOUBLE_ARROW)
+
+        self.button_pressed = False
+        self.target = TARGET_NONE
+
+        self.hole_radius = 30
+        self.doughnut_width = 30
+        self.connect("expose-event", self.expose)
+
+    def set_hole_radius(self, hole_radius):
+        self.queue_draw()
+        self.hole_radius = hole_radius
+
+    def get_hole_radius(self):
+        return self.hole_radius
+
+    def set_width(self, width):
+        self.queue_draw()
+        self.doughnut_width = width
+
+    def get_width(self):
+        return self.doughnut_width
+
+    def compute_doughnut(self):
+        """ Compute the location of the doughnut circles.
+            Returns (circle center x, circle center y, radius of inner circle, radius of outer circle) """
+        allocation = self.get_allocation()
+        alloc_width = allocation.width - TOTAL_MARGIN
+        return (
+            CIRCLE_CENTER_X, allocation.height / 2,
+            alloc_width * self.hole_radius / 100.0,
+            alloc_width * min(self.hole_radius + self.doughnut_width, 100.0) / 100.0
+        )
+
+    def set_cursor_h_resize(self):
+        """Set the mouse to be a double arrow."""
+        gdk_window = self.get_window()
+        gdk_window.set_cursor(self.resize_cursor)
+
+    def set_default_cursor(self):
+        gdk_window = self.get_window()
+        gdk_window.set_cursor(self.default_cursor)
+
+    def get_target(self, x, y):
+        # Find out if x, y is over one of the circle edges.
+
+        center_x, center_y, hole_radius, outer_radius = self.compute_doughnut()
+
+        # Compute distance from circle center to point
+        dist = sqrt((center_x - x) ** 2 + (center_y - y) ** 2)
+
+        if abs(dist - hole_radius) <= 3:
+            return TARGET_HOLE
+        if abs(dist - outer_radius) <= 3:
+            return TARGET_WIDTH
+
+        return TARGET_NONE
+
+    def expose(self, widget, event):
+
+        cr = widget.window.cairo_create()
+        center_x, center_y, hole_radius, outer_radius = self.compute_doughnut()
+        fg_color = gtk.widget_get_default_style().fg[gtk.STATE_NORMAL]
+
+        # Draw doughnut interior
+        arc = pi * 3 / 2.0
+        cr.set_source_rgba(fg_color.red, fg_color.green, fg_color.blue, 0.5)
+        cr.arc(center_x, center_y, hole_radius, -arc, arc)
+        cr.arc_negative(center_x, center_y, outer_radius, arc, -arc)
+        cr.close_path()
+        cr.fill()
+
+        # Draw doughnut border.
+        cr.set_source_rgb(fg_color.red, fg_color.green, fg_color.blue)
+        cr.set_line_width(3)
+        cr.arc_negative(center_x, center_y, outer_radius, arc, -arc)
+        cr.stroke()
+        if hole_radius < 1.0:
+            # If the radius is too small, nothing will be drawn, so draw a small cross marker instead.
+            cr.set_line_width(2)
+            cr.move_to(center_x - 4, center_y)
+            cr.line_to(center_x + 4, center_y)
+            cr.move_to(center_x, center_y - 4)
+            cr.line_to(center_x, center_y + 4)
+        else:
+            cr.arc(center_x, center_y, hole_radius, -arc, arc)
+        cr.stroke()
+
+    def compute_new_radius(self, x):
+        """ This method is called during mouse dragging of the widget.
+            Compute the new radius based on the current x location of the mouse pointer. """
+        allocation = self.get_allocation()
+
+        # How much does a single pixel difference in x, change the radius?
+        # Note that: allocation.width - TOTAL_MARGIN = 100 radius units,
+        radius_per_pixel = 100.0 / (allocation.width - TOTAL_MARGIN)
+        new_radius = self.start_radius + (x - self.start_x) * radius_per_pixel
+
+        if self.target == TARGET_HOLE:
+            self.hole_radius = max(min(new_radius, 99.0), 0.0)
+        else:
+            self.doughnut_width = max(min(new_radius, 100.0), 1.0)
+
+        self.queue_draw()
+
+    def do_button_press_event(self, event):
+        self.button_pressed = True
+
+        # If we clicked on one of the doughnut borders, remember which
+        # border we clicked on, and setup variable to start dragging it.
+        target = self.get_target(event.x, event.y)
+        if target == TARGET_HOLE or target == TARGET_WIDTH:
+            self.target = target
+            self.start_x = event.x
+            self.start_radius = (
+                self.hole_radius if target == TARGET_HOLE else
+                self.doughnut_width
+            )
+
+    def do_button_release_event(self, event):
+        # If one the doughnut borders was being dragged, recompute the doughnut size.
+        if self.target != TARGET_NONE:
+            self.compute_new_radius(event.x)
+            # Clip the width, if it is too large to fit.
+            if self.hole_radius + self.doughnut_width > 100:
+                self.doughnut_width = 100 - self.hole_radius
+            self.emit("values_changed", self.hole_radius, self.doughnut_width)
+
+        self.button_pressed = False
+        self.target = TARGET_NONE
+
+    def do_motion_notify_event(self, event):
+        if self.button_pressed:
+            # We are dragging one of the doughnut borders; recompute its size.
+            if self.target != TARGET_NONE:
+                self.compute_new_radius(event.x)
+        else:
+            # Set cursor according to whether we are over one of the
+            # doughnut borders.
+            target = self.get_target(event.x, event.y)
+            if target == TARGET_NONE:
+                self.set_default_cursor()
+            else:
+                self.set_cursor_h_resize()
+
+
+# Create signal that returns change parameters.
+gobject.type_register(DoughnutWidget)
+gobject.signal_new("values_changed", DoughnutWidget, gobject.SIGNAL_RUN_LAST,
+                   gobject.TYPE_NONE, (gobject.TYPE_INT, gobject.TYPE_INT))
+
+
+class SpyroWindow(gtk.Window):
+
+    # Define signal to catch escape key.
+    __gsignals__ = dict(
+        myescape=(gobject.SIGNAL_RUN_LAST | gobject.SIGNAL_ACTION,
+                  None,  # return type
+                  (str,))  # arguments
+    )
+
+    class MyScale():
+        """ Combintation of scale and spin that control the same adjuster. """
+        def __init__(self, scale, spin):
+            self.scale, self.spin = scale, spin
+
+        def set_sensitive(self, val):
+            self.scale.set_sensitive(val)
+            self.spin.set_sensitive(val)
+
+    def __init__(self, img, layer):
+
+        def add_horizontal_separator(vbox):
+            hsep = gtk.HSeparator()
+            vbox.add(hsep)
+            hsep.show()
+
+        def add_vertical_space(vbox, height):
+            hbox = gtk.HBox()
+            hbox.set_border_width(height/2)
+            vbox.add(hbox)
+            hbox.show()
+
+        def add_to_box(box, w):
+            box.add(w)
+            w.show()
+
+        def create_table(rows, columns, border_width):
+            table = gtk.Table(rows=rows, columns=columns, homogeneous=False)
+            table.set_border_width(border_width)
+            table.set_col_spacings(10)
+            table.set_row_spacings(10)
+            return table
+
+        def label_in_table(label_text, table, row, tooltip_text=None, col=0, col_add=1):
+            """ Create a label and set it in first col of table. """
+            label = gtk.Label(label_text)
+            label.set_alignment(xalign=0.0, yalign=1.0)
+            if tooltip_text:
+                label.set_tooltip_text(tooltip_text)
+            table.attach(label, col, col + col_add, row, row + 1, xoptions=gtk.FILL, yoptions=0)
+            label.show()
+
+        def spin_in_table(adj, table, row, callback, digits=0, col=0):
+            spin = gtk.SpinButton(adj, climb_rate=0.5, digits=digits)
+            spin.set_numeric(True)
+            spin.set_snap_to_ticks(True)
+            spin.set_max_length(5)
+            spin.set_width_chars(5)
+            table.attach(spin, col, col + 1, row, row + 1, xoptions=0, yoptions=0)
+            spin.show()
+            adj.connect("value_changed", callback)
+            return spin
+
+        def hscale_in_table(adj, table, row, callback, digits=0, col=1, cols=1):
+            """ Create an hscale and a spinner using the same Adjustment, and set it in table. """
+            scale = gtk.HScale(adj)
+            scale.set_size_request(150, -1)
+            scale.set_digits(digits)
+            scale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
+            table.attach(scale, col, col + cols, row, row + 1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0)
+            scale.show()
+
+            spin = gtk.SpinButton(adj, climb_rate=0.5, digits=digits)
+            spin.set_numeric(True)
+            spin.set_snap_to_ticks(True)
+            spin.set_max_length(5)
+            spin.set_width_chars(5)
+            table.attach(spin, col + cols , col + cols + 1, row, row + 1, xoptions=0, yoptions=0)
+            spin.show()
+
+            adj.connect("value_changed", callback)
+
+            return self.MyScale(scale, spin)
+
+        def rotation_in_table(val, table, row, callback):
+            adj = gtk.Adjustment(val, -180.0, 180.0, 1.0)
+            myscale = hscale_in_table(adj, table, row, callback, digits=1)
+            myscale.scale.add_mark(0.0, gtk.POS_BOTTOM, None)
+            myscale.spin.set_max_length(6)
+            myscale.spin.set_width_chars(6)
+            return adj, myscale
+
+        def set_combo_in_table(txt_list, table, row, callback):
+            combo = gtk.combo_box_new_text()
+            for txt in txt_list:
+                combo.append_text(txt)
+            table.attach(combo, 1, 2, row, row + 1, xoptions=gtk.FILL, yoptions=0)
+            combo.show()
+            combo.connect("changed", callback)
+            return combo
+
+        # Return table which is at the top of the dialog, and has several major input widgets.
+        def top_table():
+
+            # Add table for displaying attributes, each having a label and an input widget.
+            table = create_table(2, 3, 10)
+
+            # Curve type
+            row = 0
+            label_in_table(_("Curve Type"), table, row,
+                           _("An Epitrochoid pattern is when the moving gear is on the outside of the fixed gear."))
+            self.curve_type_combo = set_combo_in_table([ct.name for ct in curve_types], table, row,
+                                                       self.curve_type_changed)
+
+            row += 1
+            label_in_table(_("Tool"), table, row,
+                           _("The tool with which to draw the pattern. "
+                             "The Preview tool just draws quickly."))
+            self.tool_combo = set_combo_in_table([tool.name for tool in tools], table, row,
+                                                 self.tool_combo_changed)
+
+            self.long_gradient_checkbox = gtk.CheckButton(_("Long Gradient"))
+            self.long_gradient_checkbox.set_tooltip_text(
+                _("When unchecked, the current tool settings will be used. "
+                  "When checked, will use a long gradient to match the length of the pattern, "
+                  "based on current gradient and repeat mode from the gradient tool settings.")
+            )
+            self.long_gradient_checkbox.set_border_width(0)
+            table.attach(self.long_gradient_checkbox, 2, 3, row, row + 1, xoptions=0, yoptions=0)
+            self.long_gradient_checkbox.show()
+            self.long_gradient_checkbox.connect("toggled", self.long_gradient_changed)
+
+            return table
+
+        def pattern_notation_frame():
+
+            vbox = gtk.VBox(spacing=0, homogeneous=False)
+
+            add_vertical_space(vbox, 14)
+
+            hbox = gtk.HBox(spacing=5)
+            hbox.set_border_width(5)
+
+            label = gtk.Label(_("Specify pattern using one of the following tabs:"))
+            label.set_tooltip_text(_(
+                "The pattern is specified only by the active tab. Toy Kit is similar to Gears, "
+                "but it uses gears and hole numbers which are found in toy kits. "
+                "If you follow the instructions from the toy kit manuals, results should be similar."))
+            hbox.pack_start(label)
+            label.show()
+
+            alignment = gtk.Alignment(xalign=0.0, yalign=0.0, xscale=0.0, yscale=0.0)
+            alignment.add(hbox)
+            hbox.show()
+            vbox.add(alignment)
+            alignment.show()
+
+            self.pattern_notebook = gtk.Notebook()
+            self.pattern_notebook.set_border_width(0)
+            self.pattern_notebook.connect('switch-page', self.pattern_notation_tab_changed)
+
+            # "Gear" pattern notation.
+
+            # Add table for displaying attributes, each having a label and an input widget.
+            gear_table = create_table(3, 3, 5)
+
+            # Teeth
+            row = 0
+            fixed_gear_tooltip = _(
+                "Number of teeth of fixed gear. The size of the fixed gear is "
+                "proportional to the number of teeth."
+            )
+            label_in_table(_("Fixed Gear Teeth"), gear_table, row, fixed_gear_tooltip)
+            self.outer_teeth_adj = gtk.Adjustment(self.p.outer_teeth, 10, 180, 1)
+            hscale_in_table(self.outer_teeth_adj, gear_table, row, self.outer_teeth_changed)
+
+            row += 1
+            moving_gear_tooltip = _(
+                "Number of teeth of moving gear. The size of the moving gear is "
+                "proportional to the number of teeth."
+            )
+            label_in_table(_("Moving Gear Teeth"), gear_table, row, moving_gear_tooltip)
+            self.inner_teeth_adj = gtk.Adjustment(self.p.inner_teeth, 2, 100, 1)
+            hscale_in_table(self.inner_teeth_adj, gear_table, row, self.inner_teeth_changed)
+
+            row += 1
+            label_in_table(_("Hole percent"), gear_table, row,
+                           _("How far is the hole from the center of the moving gear. "
+                             "100% means that the hole is at the gear's edge."))
+            self.hole_percent_adj = gtk.Adjustment(self.p.hole_percent, 2.5, 100.0, 0.5)
+            self.hole_percent_myscale = hscale_in_table(self.hole_percent_adj, gear_table,
+                                                        row, self.hole_percent_changed, digits=1)
+
+            # "Kit" pattern notation.
+
+            kit_table = create_table(3, 3, 5)
+
+            row = 0
+            label_in_table(_("Fixed Gear Teeth"), kit_table, row, fixed_gear_tooltip)
+            self.kit_outer_teeth_combo = set_combo_in_table([str(t) for t in ring_teeth], kit_table, row,
+                                                            self.kit_outer_teeth_combo_changed)
+
+            row += 1
+            label_in_table(_("Moving Gear Teeth"), kit_table, row, moving_gear_tooltip)
+            self.kit_inner_teeth_combo = set_combo_in_table([str(t) for t in wheel_teeth], kit_table, row,
+                                                            self.kit_inner_teeth_combo_changed)
+
+            row += 1
+            label_in_table(_("Hole Number"), kit_table, row,
+                           _("Hole #1 is at the edge of the gear. "
+                             "The maximum hole number is near the center. "
+                             "The maximum hole number is different for each gear."))
+            self.kit_hole_adj = gtk.Adjustment(self.p.hole_number, 1, self.p.kit_max_hole_number(), 1)
+            self.kit_hole_myscale = hscale_in_table(self.kit_hole_adj, kit_table, row, self.kit_hole_changed)
+
+            # "Visual" pattern notation.
+
+            visual_table = create_table(3, 5, 5)
+
+            row = 0
+            label_in_table(_("Flower Petals"), visual_table, row, _("The number of petals in the pattern."))
+            self.petals_adj = gtk.Adjustment(self.p.petals, 2, 100, 1)
+            hscale_in_table(self.petals_adj, visual_table, row, self.petals_changed, cols=3)
+
+            row += 1
+            label_in_table(_("Petal Skip"), visual_table, row,
+                           _("The number of petals to advance for drawing the next petal."))
+            self.petal_skip_adj = gtk.Adjustment(self.p.petal_skip, 1, 50, 1)
+            hscale_in_table(self.petal_skip_adj, visual_table, row, self.petal_skip_changed, cols=3)
+
+            row += 1
+            label_in_table(_("Hole Radius(%)"), visual_table, row,
+                           _("The radius of the hole in the center of the pattern "
+                             "where nothing will be drawn. Given as a percentage of the "
+                             "size of the pattern. A value of 0 will produce no hole. "
+                             "A Value of 99 will produce a thin line on the edge."))
+            self.doughnut_hole_adj = gtk.Adjustment(self.p.doughnut_hole, 0.0, 99.0, 0.1)
+            self.doughnut_hole_myscale = spin_in_table(self.doughnut_hole_adj,
+                                                       visual_table, row, self.doughnut_hole_changed, 1, 1)
+
+            self.doughnut = DoughnutWidget()
+            visual_table.attach(self.doughnut, 2, 3, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0)
+            self.doughnut.connect('values_changed', self.doughnut_changed)
+            self.doughnut.show()
+
+            label_in_table(_("Width(%)"), visual_table, row,
+                           _("The width of the pattern as a percentage of the "
+                             "size of the pattern. A Value of 1 will just draw a thin pattern. "
+                             "A Value of 100 will fill the entire fixed gear."), 3)
+            self.doughnut_width_adj = gtk.Adjustment(self.p.doughnut_width, 1.0, 100.0, 0.1)
+            self.doughnut_width_myscale = spin_in_table(self.doughnut_width_adj,
+                                                        visual_table, row, self.doughnut_width_changed, 1, 4)
+
+            # Add tables as children of the pattern notebook
+
+            pattern_notation_page[VISUAL_NOTATION] = self.pattern_notebook.append_page(visual_table)
+            self.pattern_notebook.set_tab_label_text(visual_table, _("Visual"))
+            self.pattern_notebook.set_tab_label_packing(visual_table, 0, 0, gtk.PACK_END)
+            visual_table.show()
+
+            pattern_notation_page[TOY_KIT_NOTATION] = self.pattern_notebook.append_page(kit_table)
+            self.pattern_notebook.set_tab_label_text(kit_table, _("Toy Kit"))
+            self.pattern_notebook.set_tab_label_packing(kit_table, 0, 0, gtk.PACK_END)
+            kit_table.show()
+
+            pattern_notation_page[GEAR_NOTATION] = self.pattern_notebook.append_page(gear_table)
+            self.pattern_notebook.set_tab_label_text(gear_table, _("Gears"))
+            self.pattern_notebook.set_tab_label_packing(gear_table, 0, 0, gtk.PACK_END)
+            gear_table.show()
+
+            add_to_box(vbox, self.pattern_notebook)
+
+            add_vertical_space(vbox, 14)
+
+            hbox = gtk.HBox(spacing=5)
+            pattern_table = create_table(1, 3, 5)
+
+            row = 0
+            label_in_table(_("Rotation"), pattern_table, row,
+                           _("Rotation of the pattern, in degrees. "
+                             "The starting position of the moving gear in the fixed gear."))
+            self.pattern_rotation_adj, myscale = rotation_in_table(
+                self.p.pattern_rotation, pattern_table, row, self.pattern_rotation_changed
+            )
+
+            hbox.pack_end(pattern_table, expand=True, fill=True, padding=0)
+            pattern_table.show()
+
+            vbox.add(hbox)
+            hbox.show()
+
+            return vbox
+
+        def fixed_gear_page():
+
+            vbox = gtk.VBox(spacing=0, homogeneous=False)
+
+            add_vertical_space(vbox, 14)
+
+            table = create_table(4, 2, 10)
+
+            row = 0
+            label_in_table(_("Shape"), table, row,
+                           _("The shape of the fixed gear to be used inside current selection. "
+                             "Rack is a long round-edged shape provided in the toy kits. "
+                             "Frame hugs the boundaries of the rectangular selection, "
+                             "use hole=100 in Gear notation to touch boundary. "
+                             "Selection will hug boundaries of current selection - try something non-rectangular."))
+            self.shape_combo = set_combo_in_table([shape.name for shape in shapes], table, row,
+                                                  self.shape_combo_changed)
+
+            row += 1
+            label_in_table(_("Sides"), table, row, _("Number of sides of the shape."))
+            self.sides_adj = gtk.Adjustment(self.p.sides, 3, 16, 1)
+            self.sides_myscale = hscale_in_table(self.sides_adj, table, row, self.sides_changed)
+
+            row += 1
+            label_in_table(_("Morph"), table, row, _("Morph fixed gear shape. Only affects some of the shapes."))
+            self.morph_adj = gtk.Adjustment(self.p.morph, 0.0, 1.0, 0.01)
+            self.morph_myscale = hscale_in_table(self.morph_adj, table, row, self.morph_changed, digits=2)
+
+            row += 1
+            label_in_table(_("Rotation"), table, row, _("Rotation of the fixed gear, in degrees"))
+            self.shape_rotation_adj, self.shape_rotation_myscale = rotation_in_table(
+                self.p.shape_rotation, table, row, self.shape_rotation_changed
+            )
+
+            add_to_box(vbox, table)
+            return vbox
+
+        def size_page():
+
+            vbox = gtk.VBox(spacing=0, homogeneous=False)
+            add_vertical_space(vbox, 14)
+            table = create_table(2, 2, 10)
+
+            row = 0
+            label_in_table(_("Margin (px)"), table, row, _("Margin from edge of selection."))
+            self.margin_adj = gtk.Adjustment(self.p.margin_pixels, 0, max(img.height, img.width), 1)
+            hscale_in_table(self.margin_adj, table, row, self.margin_changed)
+
+            row += 1
+            self.equal_w_h_checkbox = gtk.CheckButton(_("Make width and height equal"))
+            self.equal_w_h_checkbox.set_tooltip_text(
+                _("When unchecked, the pattern will fill the current image or selection. "
+                  "When checked, the pattern will have same width and height, and will be centered.")
+            )
+            self.equal_w_h_checkbox.set_border_width(15)
+            table.attach(self.equal_w_h_checkbox, 0, 2, row, row + 1)
+            self.equal_w_h_checkbox.show()
+            self.equal_w_h_checkbox.connect("toggled", self.equal_w_h_checkbox_changed)
+
+
+            add_to_box(vbox, table)
+            return vbox
+
+        def add_button_to_box(box, text, callback, tooltip_text=None):
+            btn = gtk.Button(text)
+            if tooltip_text:
+                btn.set_tooltip_text(tooltip_text)
+            box.add(btn)
+            btn.show()
+            btn.connect("clicked", callback)
+            return btn
+
+        def dialog_button_box():
+            hbox = gtk.HBox(homogeneous=True, spacing=20)
+
+            add_button_to_box(hbox, _("Re_draw"), self.redraw,
+                              _("If you change the settings of a tool, change color, or change the selection, "
+                                "press this to preview how the pattern looks."))
+            add_button_to_box(hbox, _("_Reset"), self.reset_params)
+            add_button_to_box(hbox, _("_Cancel"), self.cancel_window)
+            self.ok_btn = add_button_to_box(hbox, _("_OK"), self.ok_window)
+
+            self.save_option_combo = gtk.combo_box_new_text()
+            for txt in save_options:
+                self.save_option_combo.append_text(txt)
+            self.save_option_combo.set_tooltip_text(
+                _("Choose whether to save as new layer, redraw on last active layer, or save to path")
+            )
+            hbox.add(self.save_option_combo)
+            self.save_option_combo.show()
+            self.save_option_combo.connect("changed", self.save_option_changed)
+
+            return hbox
+
+        def create_ui():
+
+            # Create the dialog
+            gtk.Window.__init__(self)
+            self.set_title(_("Spyrogimp"))
+            self.set_default_size(350, -1)
+            self.set_border_width(10)
+            # self.set_keep_above(True) # keep the window on top
+
+            # Vertical box in which we will add all the UI elements.
+            vbox = gtk.VBox(spacing=10, homogeneous=False)
+            self.add(vbox)
+
+            box = gimpui.HintBox(_("Draw spyrographs using current tool settings and selection."))
+            vbox.pack_start(box, expand=False)
+            box.show()
+
+            add_horizontal_separator(vbox)
+
+            add_to_box(vbox, top_table())
+
+            self.main_notebook = gtk.Notebook()
+            self.main_notebook.set_show_tabs(True)
+            self.main_notebook.set_border_width(5)
+
+            pattern_frame = pattern_notation_frame()
+            self.main_notebook.append_page(pattern_frame, gtk.Label(_("Curve Pattern")))
+            pattern_frame.show()
+            fixed_g_page = fixed_gear_page()
+            self.main_notebook.append_page(fixed_g_page, gtk.Label(_("Fixed Gear")))
+            fixed_g_page.show()
+            size_p = size_page()
+            self.main_notebook.append_page(size_p, gtk.Label(_("Size")))
+            size_p.show()
+
+            vbox.add(self.main_notebook)
+            self.main_notebook.show()
+
+            add_horizontal_separator(vbox)
+
+            self.progress_bar = gtk.ProgressBar()   # gimpui.ProgressBar() - causes gimppdbprogress error message.
+            self.progress_bar.set_size_request(-1, 30)
+            vbox.add(self.progress_bar)
+            self.progress_bar.show()
+
+            add_to_box(vbox, dialog_button_box())
+
+            vbox.show()
+            self.show()
+
+        self.enable_incremental_drawing = False
+
+        self.img = img
+        # Remember active layer, so we can restore it when the plugin is done.
+        self.active_layer = layer
+
+        self.p = unshelf_parameters()  # Model
+
+        self.engine = DrawingEngine(img, self.p)
+
+        # Make a new GIMP layer to draw on
+        self.spyro_layer = gimp.Layer(img, layer_name, img.width, img.height,
+                                      layer.type_with_alpha, 100, NORMAL_MODE)
+        img.add_layer(self.spyro_layer, 0)
+
+        self.drawing_layer = self.spyro_layer
+
+        gimpui.gimp_ui_init()
+        create_ui()
+        self.update_view()
+
+        # Obey the window manager quit signal
+        self.connect("destroy", self.cancel_window)
+        # Connect Escape key to quit the window as well.
+        self.connect('myescape', self.cancel_window)
+
+        # Setup for Handling incremental/interactive drawing of pattern
+        self.idle_task = None
+        self.enable_incremental_drawing = True
+
+        # Draw pattern of the current settings.
+        self.start_new_incremental_drawing()
+
+    # Callbacks for closing the plugin
+
+    def clear_idle_task(self):
+        if self.idle_task:
+            gobject.source_remove(self.idle_task)
+            # Close the undo group in the likely case the idle task left it open.
+            self.img.undo_group_end()
+            self.idle_task = None
+
+    def ok_window(self, widget):
+        """ Called when clicking on the 'close' button. """
+
+        self.ok_btn.set_sensitive(False)
+
+        shelf_parameters(self.p)
+
+        if self.p.save_option == SAVE_AS_NEW_LAYER:
+            if self.spyro_layer in self.img.layers:
+                self.img.active_layer = self.spyro_layer
+
+            # If we are in the middle of incremental draw, we want to complete it, and only then to exit.
+            # However, in order to complete it, we need to create another idle task.
+            if self.idle_task:
+                def quit_dialog_on_completion():
+                    while self.idle_task:
+                        yield True
+
+                    gtk.main_quit()  # This will quit the dialog.
+                    yield False
+
+                task = quit_dialog_on_completion()
+                gobject.idle_add(task.next)
+            else:
+                gtk.main_quit()
+        else:
+            # If there is an incremental drawing taking place, lets stop it.
+            self.clear_idle_task()
+
+            if self.spyro_layer in self.img.layers:
+                self.img.remove_layer(self.spyro_layer)
+                self.img.active_layer = self.active_layer
+
+            self.drawing_layer = self.active_layer
+
+            def draw_full(tool):
+                self.progress_start()
+                yield True
+
+                self.engine.reset_incremental()
+
+                self.img.undo_group_start()
+
+                while self.engine.has_more_strokes():
+                    yield True
+                    self.draw_next_chunk(tool=tool)
+
+                self.img.undo_group_end()
+
+                pdb.gimp_displays_flush()
+
+                gtk.main_quit()
+                yield False
+
+            tool = SaveToPathTool(self.img) if self.p.save_option == SAVE_AS_PATH else None
+            task = draw_full(tool)
+            gobject.idle_add(task.next)
+
+    def cancel_window(self, widget, what=None):
+        self.clear_idle_task()
+
+        # We want to delete the temporary layer, but as a precaution, lets ask first,
+        # maybe it was already deleted by the user.
+        if self.spyro_layer in self.img.layers:
+            self.img.remove_layer(self.spyro_layer)
+            pdb.gimp_displays_flush()
+        gtk.main_quit()
+
+    def update_view(self):
+        """ Update the UI to reflect the values in the Pattern Parameters. """
+        self.curve_type_combo.set_active(self.p.curve_type)
+        self.curve_type_side_effects()
+
+        self.pattern_notebook.set_current_page(pattern_notation_page[self.p.pattern_notation])
+
+        self.outer_teeth_adj.set_value(self.p.outer_teeth)
+        self.inner_teeth_adj.set_value(self.p.inner_teeth)
+        self.hole_percent_adj.set_value(self.p.hole_percent)
+        self.pattern_rotation_adj.set_value(self.p.pattern_rotation)
+
+        self.kit_outer_teeth_combo.set_active(self.p.kit_fixed_gear_index)
+        self.kit_inner_teeth_combo.set_active(self.p.kit_moving_gear_index)
+        self.kit_hole_adj.set_value(self.p.hole_number)
+        self.kit_inner_teeth_combo_side_effects()
+
+        self.petals_adj.set_value(self.p.petals)
+        self.petal_skip_adj.set_value(self.p.petal_skip)
+        self.doughnut_hole_adj.set_value(self.p.doughnut_hole)
+        self.doughnut.set_hole_radius(self.p.doughnut_hole)
+        self.doughnut_width_adj.set_value(self.p.doughnut_width)
+        self.doughnut.set_width(self.p.doughnut_width)
+        self.petals_changed_side_effects()
+
+        self.shape_combo.set_active(self.p.shape_index)
+        self.shape_combo_side_effects()
+        self.sides_adj.set_value(self.p.sides)
+        self.morph_adj.set_value(self.p.morph)
+        self.equal_w_h_checkbox.set_active(self.p.equal_w_h)
+        self.shape_rotation_adj.set_value(self.p.shape_rotation)
+
+        self.margin_adj.set_value(self.p.margin_pixels)
+        self.tool_combo.set_active(self.p.tool_index)
+        self.long_gradient_checkbox.set_active(self.p.long_gradient)
+        self.save_option_combo.set_active(self.p.save_option)
+
+    def reset_params(self, widget):
+        self.engine.p = self.p = PatternParameters()
+        self.update_view()
+
+    # Callbacks to handle changes in dialog parameters.
+
+    def curve_type_side_effects(self):
+        if curve_types[self.p.curve_type].supports_shapes():
+            self.shape_combo.set_sensitive(True)
+
+            self.sides_myscale.set_sensitive(shapes[self.p.shape_index].has_sides())
+            self.morph_myscale.set_sensitive(shapes[self.p.shape_index].can_morph())
+            self.shape_rotation_myscale.set_sensitive(shapes[self.p.shape_index].can_rotate())
+
+            self.hole_percent_myscale.set_sensitive(True)
+            self.kit_hole_myscale.set_sensitive(True)
+
+            self.doughnut_hole_myscale.set_sensitive(True)
+            self.doughnut_width_myscale.set_sensitive(True)
+        else:
+            # Lissajous curves do not have shapes, or holes for moving gear
+            self.shape_combo.set_sensitive(False)
+
+            self.sides_myscale.set_sensitive(False)
+            self.morph_myscale.set_sensitive(False)
+            self.shape_rotation_myscale.set_sensitive(False)
+
+            self.hole_percent_myscale.set_sensitive(False)
+            self.kit_hole_myscale.set_sensitive(False)
+
+            self.doughnut_hole_myscale.set_sensitive(False)
+            self.doughnut_width_myscale.set_sensitive(False)
+
+    def curve_type_changed(self, val):
+        self.p.curve_type = val.get_active()
+        self.curve_type_side_effects()
+        self.redraw()
+
+    def pattern_notation_tab_changed(self, notebook, page, page_num, user_param1=None):
+        if self.enable_incremental_drawing:
+            for notation in pattern_notation_page:
+                if pattern_notation_page[notation] == page_num:
+                    self.p.pattern_notation = notation
+
+            self.redraw()
+
+    # Callbacks: pattern changes using the Toy Kit notation.
+
+    def kit_outer_teeth_combo_changed(self, val):
+        self.p.kit_fixed_gear_index = val.get_active()
+        self.redraw()
+
+    def kit_inner_teeth_combo_side_effects(self):
+        # Change the max hole number according to the newly activated wheel.
+        # We might also need to update the hole value, if it is larger than the new max.
+        max_hole_number = self.p.kit_max_hole_number()
+        if self.p.hole_number > max_hole_number:
+            self.p.hole_number = max_hole_number
+            self.kit_hole_adj.set_value(max_hole_number)
+        self.kit_hole_adj.set_upper(max_hole_number)
+
+    def kit_inner_teeth_combo_changed(self, val):
+        self.p.kit_moving_gear_index = val.get_active()
+        self.kit_inner_teeth_combo_side_effects()
+        self.redraw()
+
+    def kit_hole_changed(self, val):
+        self.p.hole_number = val.value
+        self.redraw()
+
+    # Callbacks: pattern changes using the Gears notation.
+
+    def outer_teeth_changed(self, val):
+        self.p.outer_teeth = val.value
+        self.redraw()
+
+    def inner_teeth_changed(self, val):
+        self.p.inner_teeth = val.value
+        self.redraw()
+
+    def hole_percent_changed(self, val):
+        self.p.hole_percent = val.value
+        self.redraw()
+
+    def pattern_rotation_changed(self, val):
+        self.p.pattern_rotation = val.value
+        self.redraw()
+
+    # Callbacks: pattern changes using the Visual notation.
+
+    def petals_changed_side_effects(self):
+        max_petal_skip = int(self.p.petals/2)
+        if self.p.petal_skip > max_petal_skip:
+            self.p.petal_skip = max_petal_skip
+            self.petal_skip_adj.set_value(max_petal_skip)
+        self.petal_skip_adj.set_upper(max_petal_skip)
+
+    def petals_changed(self, val):
+        self.p.petals = int(val.value)
+        self.petals_changed_side_effects()
+        self.redraw()
+
+    def petal_skip_changed(self, val):
+        self.p.petal_skip = int(val.value)
+        self.redraw()
+
+    def doughnut_hole_changed(self, val):
+        self.p.doughnut_hole = val.value
+        self.doughnut.set_hole_radius(val.value)
+        self.redraw()
+
+    def doughnut_width_changed(self, val):
+        self.p.doughnut_width = val.value
+        self.doughnut.set_width(val.value)
+        self.redraw()
+
+    def doughnut_changed(self, widget, hole, width):
+        self.doughnut_hole_adj.set_value(hole)
+        self.doughnut_width_adj.set_value(width)
+        # We don't need to redraw, because the callbacks of the doughnut hole and
+        # width spinners will be triggered by the above lines.
+
+    # Callbacks: Fixed gear
+
+    def shape_combo_side_effects(self):
+        self.sides_myscale.set_sensitive(shapes[self.p.shape_index].has_sides())
+        self.morph_myscale.set_sensitive(shapes[self.p.shape_index].can_morph())
+        self.shape_rotation_myscale.set_sensitive(shapes[self.p.shape_index].can_rotate())
+        self.equal_w_h_checkbox.set_sensitive(shapes[self.p.shape_index].can_equal_w_h())
+
+    def shape_combo_changed(self, val):
+        self.p.shape_index = val.get_active()
+        self.shape_combo_side_effects()
+        self.redraw()
+
+    def sides_changed(self, val):
+        self.p.sides = val.value
+        self.redraw()
+
+    def morph_changed(self, val):
+        self.p.morph = val.value
+        self.redraw()
+
+    def equal_w_h_checkbox_changed(self, val):
+        self.p.equal_w_h = val.get_active()
+        self.redraw()
+
+    def shape_rotation_changed(self, val):
+        self.p.shape_rotation = val.value
+        self.redraw()
+
+    def margin_changed(self, val) :
+        self.p.margin_pixels = val.value
+        self.redraw()
+
+    # Style callbacks
+
+    def tool_changed_side_effects(self):
+        self.long_gradient_checkbox.set_sensitive(tools[self.p.tool_index].can_color)
+
+    def tool_combo_changed(self, val):
+        self.p.tool_index = val.get_active()
+        self.tool_changed_side_effects()
+        self.redraw()
+
+    def long_gradient_changed(self, val):
+        self.p.long_gradient = val.get_active()
+        self.redraw()
+
+    def save_option_changed(self, val):
+        self.p.save_option = self.save_option_combo.get_active()
+
+    # Progress bar of plugin window.
+
+    def progress_start(self):
+        self.progress_bar.set_text(_("Rendering Pattern"))
+        self.progress_bar.set_fraction(0.0)
+        pdb.gimp_displays_flush()
+
+    def progress_end(self):
+        self.progress_bar.set_text("")
+        self.progress_bar.set_fraction(0.0)
+
+    def progress_update(self):
+        self.progress_bar.set_fraction(self.engine.fraction_done())
+
+    def progress_unknown(self):
+        self.progress_bar.set_text(_("Please wait : Rendering Pattern"))
+        self.progress_bar.pulse()
+        pdb.gimp_displays_flush()
+
+    # Incremental drawing.
+
+    def draw_next_chunk(self, tool=None):
+        """ Incremental drawing """
+
+        t = time.time()
+
+        chunk_size = self.engine.draw_next_chunk(self.drawing_layer, tool=tool)
+
+        draw_time = time.time() - t
+        self.engine.report_time(draw_time)
+        print("Chunk size " + str(chunk_size) + " time " + str(draw_time))
+
+        if self.engine.has_more_strokes():
+            self.progress_update()
+        else:
+            self.progress_end()
+
+        pdb.gimp_displays_flush()
+
+    def start_new_incremental_drawing(self):
+        """
+        Compute strokes for the current pattern, and store then in the IncrementalDraw object,
+        so they can be drawn in pieces without blocking the user.
+        Finally, draw the first chunk of strokes.
+        """
+
+        def incremental_drawing():
+            self.progress_start()
+            yield True
+            self.engine.reset_incremental()
+
+            self.img.undo_group_start()
+            while self.engine.has_more_strokes():
+                yield True
+                self.draw_next_chunk()
+            self.img.undo_group_end()
+
+            self.idle_task = None
+            yield False
+
+        # Start new idle task to perform incremental drawing in the background.
+        self.clear_idle_task()
+        task = incremental_drawing()
+        self.idle_task = gobject.idle_add(task.next)
+
+    def clear(self):
+        """ Clear current drawing. """
+        # pdb.gimp_edit_clear(self.spyro_layer)
+        self.spyro_layer.fill(FILL_TRANSPARENT)
+
+    def redraw(self, data=None):
+        if self.enable_incremental_drawing:
+            self.clear()
+            self.start_new_incremental_drawing()
+
+
+# Bind escape to the new signal we created, named "myescape".
+gobject.type_register(SpyroWindow)
+gtk.binding_entry_add_signal(SpyroWindow, gtk.keysyms.Escape, 0, 'myescape', str, 'escape')
+
+
+class SpyrogimpPlusPlugin(gimpplugin.plugin):
+
+    # Implementation of plugin.
+    def plug_in_spyrogimp(self, run_mode, image, layer,
+                          curve_type=0, shape=0, sides=3, morph=0.0,
+                          fixed_teeth=96, moving_teeth=36, hole_percent=100.0,
+                          margin=0, equal_w_h=0,
+                          pattern_rotation=0.0, shape_rotation=0.0,
+                          tool=1, long_gradient=False):
+        if run_mode == RUN_NONINTERACTIVE:
+            pp = PatternParameters()
+            pp.curve_type = curve_type
+            pp.shape_index = shape
+            pp.sides = sides
+            pp.morph = morph
+            pp.outer_teeth = fixed_teeth
+            pp.inner_teeth = moving_teeth
+            pp.hole_percent = hole_percent
+            pp.margin_pixels = margin
+            pp.equal_w_h = equal_w_h
+            pp.pattern_rotation = pattern_rotation
+            pp.shape_rotation = shape_rotation
+            pp.tool_index = tool
+            pp.long_gradient = long_gradient
+
+            engine = DrawingEngine(image, pp)
+            engine.draw_full(layer)
+
+        elif run_mode == RUN_INTERACTIVE:
+            window = SpyroWindow(image, layer)
+            gtk.main()
+
+        elif run_mode == RUN_WITH_LAST_VALS:
+            pp = unshelf_parameters()
+            engine = DrawingEngine(image, pp)
+            engine.draw_full(layer)
+
+    def query(self):
+        plugin_name = "plug_in_spyrogimp"
+        label = N_("Spyrogimp...")
+        menu = "<Image>/Filters/Render/"
+
+        params = [
+            # (type, name, description
+            (PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }"),
+            (PDB_IMAGE, "image", "Input image"),
+            (PDB_DRAWABLE, "drawable", "Input drawable"),
+            (PDB_INT32, "curve_type",
+             "The curve type { Spyrograph (0), Epitrochoid (1), Sine (2), Lissajous(3) }"),
+            (PDB_INT32, "shape", "Shape of fixed gear"),
+            (PDB_INT32, "sides", "Number of sides of fixed gear (3 or greater). Only used by some shapes."),
+            (PDB_FLOAT, "morph", "Morph shape of fixed gear, between 0 and 1. Only used by some shapes."),
+            (PDB_INT32, "fixed_teeth", "Number of teeth for fixed gear"),
+            (PDB_INT32, "moving_teeth", "Number of teeth for moving gear"),
+            (PDB_FLOAT, "hole_percent", "Location of hole in moving gear in percent, where 100 means that "
+             "the hole is at the edge of the gear, and 0 means the hole is at the center"),
+            (PDB_INT32, "margin", "Margin from selection, in pixels"),
+            (PDB_INT32, "equal_w_h", "Make height and width equal (TRUE or FALSE)"),
+            (PDB_FLOAT, "pattern_rotation", "Pattern rotation, in degrees"),
+            (PDB_FLOAT, "shape_rotation", "Shape rotation of fixed gear, in degrees"),
+            (PDB_INT32, "tool", "Tool to use for drawing the pattern."),
+            (PDB_INT32, "long_gradient",
+             "Whether to apply a long gradient to match the length of the pattern (TRUE or FALSE). "
+             "Only applicable to some of the tools.")
+        ]
+
+        gimp.domain_register("gimp20-python", gimp.locale_directory)
+
+        gimp.install_procedure(
+            plugin_name,
+            N_("Draw spyrographs using current tool settings and selection."),
+            "Uses current tool settings to draw Spyrograph patterns. "
+            "The size and location of the pattern is based on the current selection.",
+            "Elad Shahar",
+            "Elad Shahar",
+            "2018",
+            label,
+            "*",
+            PLUGIN,
+            params,
+            []
+        )
+
+        gimp.menu_register(plugin_name, menu)
+
+
+if __name__ == '__main__':
+    SpyrogimpPlusPlugin().start()
diff --git a/plug-ins/pygimp/plug-ins/whirlpinch.py b/plug-ins/pygimp/plug-ins/whirlpinch.py
new file mode 100755
index 0000000..6c50e89
--- /dev/null
+++ b/plug-ins/pygimp/plug-ins/whirlpinch.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python2
+
+#   Gimp-Python - allows the writing of Gimp plugins in Python.
+#   Copyright (C) 1997  James Henstridge <james@daa.com.au>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# Algorithms stolen from the whirl and pinch plugin distributed with Gimp,
+# by Federico Mena Quintero and Scott Goehring
+#
+# This version does the same thing, except there is no preview, and it is
+# written in python and is slower.
+
+import math, struct
+from gimpfu import *
+
+class pixel_fetcher:
+        def __init__(self, drawable):
+                self.col = -1
+                self.row = -1
+                self.img_width = drawable.width
+                self.img_height = drawable.height
+                self.img_bpp = drawable.bpp
+                self.img_has_alpha = drawable.has_alpha
+                self.tile_width = gimp.tile_width()
+                self.tile_height = gimp.tile_height()
+                self.bg_colour = '\0\0\0\0'
+                self.bounds = drawable.mask_bounds
+                self.drawable = drawable
+                self.tile = None
+        def set_bg_colour(self, r, g, b, a):
+                self.bg_colour = struct.pack('BBB', r,g,b)
+                if self.img_has_alpha:
+                        self.bg_colour = self.bg_colour + chr(a)
+        def get_pixel(self, x, y):
+                sel_x1, sel_y1, sel_x2, sel_y2 = self.bounds
+                if x < sel_x1 or x >= sel_x2 or y < sel_y1 or y >= sel_y2:
+                        return self.bg_colour
+                col = x / self.tile_width
+                coloff = x % self.tile_width
+                row = y / self.tile_height
+                rowoff = y % self.tile_height
+
+                if col != self.col or row != self.row or self.tile == None:
+                        self.tile = self.drawable.get_tile(False, row, col)
+                        self.col = col
+                        self.row = row
+                return self.tile[coloff, rowoff]
+
+class Dummy:
+        pass
+
+def whirl_pinch(image, drawable, whirl, pinch, radius):
+        self = Dummy()
+        self.width = drawable.width
+        self.height = drawable.height
+        self.bpp = drawable.bpp
+        self.has_alpha = drawable.has_alpha
+        self.bounds = drawable.mask_bounds
+        self.sel_x1, self.sel_y1, self.sel_x2, self.sel_y2 = \
+                     drawable.mask_bounds
+        self.sel_w = self.sel_x2 - self.sel_x1
+        self.sel_h = self.sel_y2 - self.sel_y1
+        self.cen_x = (self.sel_x1 + self.sel_x2 - 1) / 2.0
+        self.cen_y = (self.sel_y1 + self.sel_y2 - 1) / 2.0
+        xhsiz = (self.sel_w - 1) / 2.0
+        yhsiz = (self.sel_h - 1) / 2.0
+
+        if xhsiz < yhsiz:
+                self.scale_x = yhsiz / xhsiz
+                self.scale_y = 1.0
+        elif xhsiz > yhsiz:
+                self.scale_x = 1.0
+                self.scale_y = xhsiz / yhsiz
+        else:
+                self.scale_x = 1.0
+                self.scale_y = 1.0
+
+        self.radius = max(xhsiz, yhsiz);
+
+        if not drawable.is_rgb and not drawable.is_grey:
+                return
+
+        gimp.tile_cache_ntiles(2 * (1 + self.width / gimp.tile_width()))
+
+        whirl = whirl * math.pi / 180
+        dest_rgn = drawable.get_pixel_rgn(self.sel_x1, self.sel_y1,
+                                          self.sel_w, self.sel_h, True, True)
+        pft = pixel_fetcher(drawable)
+        pfb = pixel_fetcher(drawable)
+
+        bg_colour = gimp.get_background()
+
+        pft.set_bg_colour(bg_colour[0], bg_colour[1], bg_colour[2], 0)
+        pfb.set_bg_colour(bg_colour[0], bg_colour[1], bg_colour[2], 0)
+
+        progress = 0
+        max_progress = self.sel_w * self.sel_h
+
+        gimp.progress_init("Whirling and pinching")
+
+        self.radius2 = self.radius * self.radius * radius
+        pixel = ['', '', '', '']
+        values = [0,0,0,0]
+
+        for row in range(self.sel_y1, (self.sel_y1+self.sel_y2)/2+1):
+                top_p = ''
+                bot_p = ''
+                for col in range(self.sel_x1, self.sel_x2):
+                        q, cx, cy = calc_undistorted_coords(self, col,
+                                                            row, whirl, pinch,
+                                                            radius)
+                        if q:
+                                if cx >= 0: ix = int(cx)
+                                else:       ix = -(int(-cx) + 1)
+                                if cy >= 0: iy = int(cy)
+                                else:       iy = -(int(-cy) + 1)
+                                pixel[0] = pft.get_pixel(ix, iy)
+                                pixel[1] = pft.get_pixel(ix+1, iy)
+                                pixel[2] = pft.get_pixel(ix, iy+1)
+                                pixel[3] = pft.get_pixel(ix+1, iy+1)
+                                for i in range(self.bpp):
+                                        values[0] = ord(pixel[0][i])
+                                        values[1] = ord(pixel[1][i])
+                                        values[2] = ord(pixel[2][i])
+                                        values[3] = ord(pixel[3][i])
+                                        top_p = top_p + bilinear(cx,cy, values)
+                                cx = self.cen_x + (self.cen_x - cx)
+                                cy = self.cen_y + (self.cen_y - cy)
+                                if cx >= 0: ix = int(cx)
+                                else:       ix = -(int(-cx) + 1)
+                                if cy >= 0: iy = int(cy)
+                                else:       iy = -(int(-cy) + 1)
+                                pixel[0] = pfb.get_pixel(ix, iy)
+                                pixel[1] = pfb.get_pixel(ix+1, iy)
+                                pixel[2] = pfb.get_pixel(ix, iy+1)
+                                pixel[3] = pfb.get_pixel(ix+1, iy+1)
+                                tmp = ''
+                                for i in range(self.bpp):
+                                        values[0] = ord(pixel[0][i])
+                                        values[1] = ord(pixel[1][i])
+                                        values[2] = ord(pixel[2][i])
+                                        values[3] = ord(pixel[3][i])
+                                        tmp = tmp + bilinear(cx,cy, values)
+                                bot_p = tmp + bot_p
+                        else:
+                                top_p = top_p + pft.get_pixel(col, row)
+                                bot_p = pfb.get_pixel((self.sel_x2 - 1) -
+                                        (col - self.sel_x1), (self.sel_y2-1) -
+                                        (row - self.sel_y1)) + bot_p
+
+                dest_rgn[self.sel_x1:self.sel_x2, row] = top_p
+                dest_rgn[self.sel_x1:self.sel_x2, (self.sel_y2 - 1)
+                         - (row - self.sel_y1)] = bot_p
+
+                progress = progress + self.sel_w * 2
+                gimp.progress_update(float(progress) / max_progress)
+
+        drawable.flush()
+        drawable.merge_shadow(True)
+        drawable.update(self.sel_x1,self.sel_y1,self.sel_w,self.sel_h)
+
+def calc_undistorted_coords(self, wx, wy, whirl, pinch, radius):
+        dx = (wx - self.cen_x) * self.scale_x
+        dy = (wy - self.cen_y) * self.scale_y
+        d = dx * dx + dy * dy
+        inside = d < self.radius2
+
+        if inside:
+                dist = math.sqrt(d / radius) / self.radius
+                if (d == 0.0):
+                        factor = 1.0
+                else:
+                        factor = math.pow(math.sin(math.pi / 2 * dist),
+                                          -pinch)
+                dx = dx * factor
+                dy = dy * factor
+                factor = 1 - dist
+                ang = whirl * factor * factor
+                sina = math.sin(ang)
+                cosa = math.cos(ang)
+                x = (cosa * dx - sina * dy) / self.scale_x + self.cen_x
+                y = (sina * dx + cosa * dy) / self.scale_y + self.cen_y
+        else:
+                x = wx
+                y = wy
+        return inside, float(x), float(y)
+
+def bilinear(x, y, values):
+        x = x % 1.0
+        y = y % 1.0
+        m0 = values[0] + x * (values[1] - values[0])
+        m1 = values[2] + x * (values[3] - values[2])
+        return chr(int(m0 + y * (m1 - m0)))
+
+
+register(
+        "python-fu-whirl-pinch",
+        "Distorts an image by whirling and pinching",
+        "Distorts an image by whirling and pinching",
+        "James Henstridge (translated from C plugin)",
+        "James Henstridge",
+        "1997-1999",
+        "_Whirl and Pinch...",
+        "RGB*, GRAY*",
+        [
+            (PF_IMAGE, "image", "Input image", None),
+            (PF_DRAWABLE, "drawable", "Input drawable", None),
+            (PF_SLIDER, "whirl", "Whirl angle", 90, (-360, 360, 1)),
+            (PF_FLOAT, "pinch", "Pinch amount", 0),
+            (PF_FLOAT, "radius", "radius", 1)
+        ],
+        [],
+        whirl_pinch, menu="<Image>/Filters/Distorts")
+
+main()
diff --git a/plug-ins/pygimp/py-compile b/plug-ins/pygimp/py-compile
new file mode 100755
index 0000000..3448c71
--- /dev/null
+++ b/plug-ins/pygimp/py-compile
@@ -0,0 +1,72 @@
+#!/bin/sh
+# called as "py-compile [--basedir DIR] PY_FILES ...
+
+if [ -z "$PYTHON" ]; then
+    if [[ -x "$(command -v python2)" ]]; then
+        PYTHON=python2
+    else
+        # Let's hope it's Python2
+        PYTHON=python
+    fi
+fi
+
+basedir=
+
+case "$1" in
+    --basedir)
+	basedir=$2
+	shift 2
+	;;
+    --help)
+	echo "Usage: py-compile [--basedir DIR] PY_FILES ..."
+	echo "Byte compile some python scripts.  This should be performed"
+	echo "after they have been moved to the final installation location"
+	exit 0
+	;;
+    --version)
+	echo "py-compile version 0.0"
+	exit 0
+	;;
+esac
+
+if [ $# = 0 ]; then
+    echo "No files given to $0" 1>&2
+    exit 1
+fi
+
+# if basedir was given, then it should be prepended to filenames before
+# byte compilation.
+if [ -z "$basedir" ]; then
+    trans="path = file"
+else
+    trans="path = os.path.join('$basedir', file)"
+fi
+
+$PYTHON -c "
+import sys, os, string, py_compile
+
+files = '''$*'''
+print 'Byte-compiling python modules...'
+for file in string.split(files):
+    $trans
+    if not os.path.exists(path) or not (len(path) >= 3 and path[-3:] == '.py'):
+	continue
+    print file,
+    sys.stdout.flush()
+    py_compile.compile(path)
+print" || exit $?
+
+# this will fail for python < 1.5, but that doesn't matter ...
+$PYTHON -O -c "
+import sys, os, string, py_compile
+
+files = '''$*'''
+print 'Byte-compiling python modules (optimised versions) ...'
+for file in string.split(files):
+    $trans
+    if not os.path.exists(path) or not (len(path) >= 3 and path[-3:] == '.py'):
+	continue
+    print file,
+    sys.stdout.flush()
+    py_compile.compile(path)
+print" 2>/dev/null || :
diff --git a/plug-ins/pygimp/pygimp-api.h b/plug-ins/pygimp/pygimp-api.h
new file mode 100644
index 0000000..2b83222
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-api.h
@@ -0,0 +1,122 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _PYGIMP_API_H_
+#define _PYGIMP_API_H_
+
+#include <Python.h>
+
+#include <libgimp/gimp.h>
+
+typedef struct {
+    PyObject_HEAD
+    gint32 ID;
+} PyGimpImage, PyGimpItem;
+
+typedef struct {
+    PyObject_HEAD
+    gint32 ID;
+} PyGimpDisplay;
+
+typedef struct {
+    PyObject_HEAD
+    gint32 ID;
+    GimpDrawable *drawable;
+} PyGimpDrawable, PyGimpLayer, PyGimpGroupLayer, PyGimpChannel;
+
+typedef struct {
+    PyObject_HEAD
+    gint32 ID;
+} PyGimpVectors;
+
+struct _PyGimp_Functions {
+    PyTypeObject *Image_Type;
+    PyObject *(* image_new)(gint32 ID);
+
+    PyTypeObject *Display_Type;
+    PyObject *(* display_new)(gint32 ID);
+
+    PyTypeObject *Item_Type;
+    PyObject *(* item_new)(gint32 ID);
+
+    PyTypeObject *Drawable_Type;
+    PyObject *(* drawable_new)(GimpDrawable *drawable, gint32 ID);
+
+    PyTypeObject *Layer_Type;
+    PyObject *(* layer_new)(gint32 ID);
+
+    PyTypeObject *GroupLayer_Type;
+    PyObject *(* group_layer_new)(gint32 ID);
+
+    PyTypeObject *Channel_Type;
+    PyObject *(* channel_new)(gint32 ID);
+
+    PyTypeObject *Vectors_Type;
+    PyObject *(* vectors_new)(gint32 ID);
+
+    PyObject *pygimp_error;
+};
+
+#ifndef _INSIDE_PYGIMP_
+
+#if defined(NO_IMPORT) || defined(NO_IMPORT_PYGIMP)
+extern struct _PyGimp_Functions *_PyGimp_API;
+#else
+struct _PyGimp_Functions *_PyGimp_API;
+#endif
+
+#define PyGimpImage_Type        (_PyGimp_API->Image_Type)
+#define pygimp_image_new        (_PyGimp_API->image_new)
+#define PyGimpDisplay_Type      (_PyGimp_API->Display_Type)
+#define pygimp_display_new      (_PyGimp_API->display_new)
+#define PyGimpItem_Type         (_PyGimp_API->Item_Type)
+#define pygimp_item_new         (_PyGimp_API->item_new)
+#define PyGimpDrawable_Type     (_PyGimp_API->Drawable_Type)
+#define pygimp_drawable_new     (_PyGimp_API->drawable_new)
+#define PyGimpLayer_Type        (_PyGimp_API->Layer_Type)
+#define pygimp_layer_new        (_PyGimp_API->layer_new)
+#define PyGimpGroupLayer_Type   (_PyGimp_API->GroupLayer_Type)
+#define pygimp_group_layer_new  (_PyGimp_API->group_layer_new)
+#define PyGimpChannel_Type      (_PyGimp_API->Channel_Type)
+#define pygimp_channel_new      (_PyGimp_API->channel_new)
+#define PyGimpVectors_Type      (_PyGimp_API->Vectors_Type)
+#define pygimp_vectors_new      (_PyGimp_API->vectors_new)
+#define pygimp_error            (_PyGimp_API->pygimp_error)
+
+#define init_pygimp() G_STMT_START { \
+    PyObject *gimpmodule = PyImport_ImportModule("gimp"); \
+    if (gimpmodule != NULL) { \
+        PyObject *mdict = PyModule_GetDict(gimpmodule); \
+        PyObject *cobject = PyDict_GetItemString(mdict, "_PyGimp_API"); \
+        if (PyCObject_Check(cobject)) \
+            _PyGimp_API = PyCObject_AsVoidPtr(cobject); \
+        else { \
+            PyErr_SetString(PyExc_RuntimeError, \
+                            "could not find _PyGimp_API object"); \
+            return; \
+        } \
+    } else { \
+        PyErr_SetString(PyExc_ImportError, \
+                        "could not import gimp"); \
+        return; \
+    } \
+} G_STMT_END
+
+#endif /* ! _INSIDE_PYGIMP_ */
+
+#endif /* _PYGIMP_API_H_ */
diff --git a/plug-ins/pygimp/pygimp-colors.c b/plug-ins/pygimp/pygimp-colors.c
new file mode 100644
index 0000000..fe37b5d
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-colors.c
@@ -0,0 +1,2407 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005-2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define NO_IMPORT_PYGOBJECT
+
+#include "pygimp.h"
+#include "pygimpcolor.h"
+
+#include <libgimpmath/gimpmath.h>
+
+static PyObject *
+rgb_set(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *r = NULL, *g = NULL, *b = NULL, *a = NULL;
+    GimpRGB tmprgb, *rgb;
+    static char *kwlist[] = { "r", "g", "b", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:set", kwlist,
+				     &r, &g, &b, &a))
+        return NULL;
+
+    if (!r && !g && !b && !a) {
+	PyErr_SetString(PyExc_TypeError, "must provide r,g,b or a arguments");
+	return NULL;
+    }
+
+    if ((r && (!g || !b)) ||
+        (g && (!r || !b)) ||
+        (b && (!r || !g))) {
+	PyErr_SetString(PyExc_TypeError, "must provide all 3 r,g,b arguments");
+	return NULL;
+    }
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+    tmprgb = *rgb;
+
+#define SET_MEMBER(m)	G_STMT_START {				\
+    if (PyInt_Check(m))						\
+	tmprgb.m = (double) PyInt_AS_LONG(m) / 255.0;		\
+    else if (PyFloat_Check(m))					\
+        tmprgb.m = PyFloat_AS_DOUBLE(m);			\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return NULL;						\
+    }								\
+} G_STMT_END
+
+    if (r) {
+	SET_MEMBER(r);
+	SET_MEMBER(g);
+	SET_MEMBER(b);
+    }
+
+    if (a)
+	SET_MEMBER(a);
+
+#undef SET_MEMBER
+
+    *rgb = tmprgb;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_set_alpha(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_a;
+    GimpRGB *rgb;
+    static char *kwlist[] = { "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "O:set_alpha", kwlist,
+				     &py_a))
+        return NULL;
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    if (PyInt_Check(py_a))
+	rgb->a = (double) PyInt_AS_LONG(py_a) / 255.0;
+    else if (PyFloat_Check(py_a))
+        rgb->a = PyFloat_AS_DOUBLE(py_a);
+    else {
+	PyErr_SetString(PyExc_TypeError, "a must be an int or a float");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_add(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *color;
+    gboolean with_alpha = FALSE;
+    static char *kwlist[] = { "color", "with_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|i:add", kwlist,
+				     &PyGimpRGB_Type, &color, &with_alpha))
+        return NULL;
+
+    if (with_alpha)
+	gimp_rgba_add(pyg_boxed_get(self, GimpRGB),
+		      pyg_boxed_get(color, GimpRGB));
+    else
+	gimp_rgb_add(pyg_boxed_get(self, GimpRGB),
+		     pyg_boxed_get(color, GimpRGB));
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_subtract(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *color;
+    gboolean with_alpha = FALSE;
+    static char *kwlist[] = { "color", "with_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|i:subtract", kwlist,
+				     &PyGimpRGB_Type, &color, &with_alpha))
+        return NULL;
+
+    if (with_alpha)
+	gimp_rgba_subtract(pyg_boxed_get(self, GimpRGB),
+			   pyg_boxed_get(color, GimpRGB));
+    else
+	gimp_rgb_subtract(pyg_boxed_get(self, GimpRGB),
+			  pyg_boxed_get(color, GimpRGB));
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_multiply(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    double factor;
+    gboolean with_alpha = FALSE;
+    static char *kwlist[] = { "factor", "with_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d|i:multiply", kwlist,
+				     &factor, &with_alpha))
+        return NULL;
+
+    if (with_alpha)
+	gimp_rgba_multiply(pyg_boxed_get(self, GimpRGB), factor);
+    else
+	gimp_rgb_multiply(pyg_boxed_get(self, GimpRGB), factor);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_distance(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *color;
+    gboolean alpha = FALSE;
+    double ret;
+    static char *kwlist[] = { "color", "alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|i:distance", kwlist,
+				     &PyGimpRGB_Type, &color, &alpha))
+        return NULL;
+
+    ret = gimp_rgb_distance(pyg_boxed_get(self, GimpRGB),
+			    pyg_boxed_get(color, GimpRGB));
+
+
+    return PyFloat_FromDouble(ret);
+}
+
+static PyObject *
+rgb_max(PyObject *self)
+{
+    return PyFloat_FromDouble(gimp_rgb_max(pyg_boxed_get(self, GimpRGB)));
+}
+
+static PyObject *
+rgb_min(PyObject *self)
+{
+    return PyFloat_FromDouble(gimp_rgb_min(pyg_boxed_get(self, GimpRGB)));
+}
+
+static PyObject *
+rgb_clamp(PyObject *self)
+{
+    gimp_rgb_clamp(pyg_boxed_get(self, GimpRGB));
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_gamma(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    double gamma;
+    static char *kwlist[] = { "gamma", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:gamma", kwlist, &gamma))
+        return NULL;
+
+    gimp_rgb_gamma(pyg_boxed_get(self, GimpRGB), gamma);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_luminance(PyObject *self)
+{
+    return PyFloat_FromDouble(gimp_rgb_luminance(pyg_boxed_get(self, GimpRGB)));
+}
+
+static PyObject *
+rgb_composite(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *color;
+    int mode = GIMP_RGB_COMPOSITE_NORMAL;
+    static char *kwlist[] = { "color", "mode", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "O!|i:composite", kwlist,
+				     &PyGimpRGB_Type, &color, &mode))
+        return NULL;
+
+    if (mode < GIMP_RGB_COMPOSITE_NONE || mode > GIMP_RGB_COMPOSITE_BEHIND) {
+	PyErr_SetString(PyExc_TypeError, "composite type is not valid");
+	return NULL;
+    }
+
+    gimp_rgb_composite(pyg_boxed_get(self, GimpRGB),
+		       pyg_boxed_get(color, GimpRGB),
+		       mode);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_parse_name(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *name;
+    int len;
+    gboolean success;
+    static char *kwlist[] = { "name", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:parse_name", kwlist,
+				     &name, &len))
+        return NULL;
+
+    success = gimp_rgb_parse_name(pyg_boxed_get(self, GimpRGB), name, len);
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse color name");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_parse_hex(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *hex;
+    int len;
+    gboolean success;
+    static char *kwlist[] = { "hex", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:parse_hex", kwlist,
+				     &hex, &len))
+        return NULL;
+
+    success = gimp_rgb_parse_hex(pyg_boxed_get(self, GimpRGB), hex, len);
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse hex value");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_parse_css(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    char *css;
+    int len;
+    gboolean success, with_alpha = FALSE;
+    static char *kwlist[] = { "css", "with_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "s#|i:parse_css", kwlist,
+				     &css, &len, &with_alpha))
+        return NULL;
+
+    if (with_alpha)
+	success = gimp_rgba_parse_css(pyg_boxed_get(self, GimpRGB), css, len);
+    else
+	success = gimp_rgb_parse_css(pyg_boxed_get(self, GimpRGB), css, len);
+
+    if (!success) {
+	PyErr_SetString(PyExc_ValueError, "unable to parse CSS color");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+rgb_to_hsv(PyObject *self)
+{
+    GimpRGB *rgb;
+    GimpHSV hsv;
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    gimp_rgb_to_hsv(rgb, &hsv);
+
+    return pygimp_hsv_new(&hsv);
+}
+
+static PyObject *
+rgb_to_hsl(PyObject *self)
+{
+    GimpRGB *rgb;
+    GimpHSL hsl;
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    gimp_rgb_to_hsl(rgb, &hsl);
+
+    return pygimp_hsl_new(&hsl);
+}
+
+static PyObject *
+rgb_to_cmyk(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    GimpRGB *rgb;
+    GimpCMYK cmyk;
+    gdouble pullout = 1.0;
+    static char *kwlist[] = { "pullout", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "|d:to_cmyk", kwlist,
+				     &pullout))
+	return NULL;
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    gimp_rgb_to_cmyk(rgb, pullout, &cmyk);
+
+    return pygimp_cmyk_new(&cmyk);
+}
+
+/* __getstate__ isn't exposed */
+static PyObject *
+rgb_getstate(PyObject *self)
+{
+    GimpRGB *rgb;
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    return Py_BuildValue("dddd", rgb->r, rgb->g, rgb->b, rgb->a);
+}
+
+static PyObject *
+rgb_reduce(PyObject *self)
+{
+    return Py_BuildValue("ON", self->ob_type, rgb_getstate(self));
+}
+
+static PyMethodDef rgb_methods[] = {
+    { "set", (PyCFunction)rgb_set, METH_VARARGS|METH_KEYWORDS },
+    { "set_alpha", (PyCFunction)rgb_set_alpha, METH_VARARGS|METH_KEYWORDS },
+    { "add", (PyCFunction)rgb_add, METH_VARARGS|METH_KEYWORDS },
+    { "subtract", (PyCFunction)rgb_subtract, METH_VARARGS|METH_KEYWORDS },
+    { "multiply", (PyCFunction)rgb_multiply, METH_VARARGS|METH_KEYWORDS },
+    { "distance", (PyCFunction)rgb_distance, METH_VARARGS|METH_KEYWORDS },
+    { "max", (PyCFunction)rgb_max, METH_NOARGS },
+    { "min", (PyCFunction)rgb_min, METH_NOARGS },
+    { "clamp", (PyCFunction)rgb_clamp, METH_NOARGS },
+    { "gamma", (PyCFunction)rgb_gamma, METH_VARARGS|METH_KEYWORDS },
+    { "luminance", (PyCFunction)rgb_luminance, METH_NOARGS },
+    { "composite", (PyCFunction)rgb_composite, METH_VARARGS|METH_KEYWORDS },
+    { "parse_name", (PyCFunction)rgb_parse_name, METH_VARARGS|METH_KEYWORDS },
+    { "parse_hex", (PyCFunction)rgb_parse_hex, METH_VARARGS|METH_KEYWORDS },
+    { "parse_css", (PyCFunction)rgb_parse_css, METH_VARARGS|METH_KEYWORDS },
+    { "to_hsv", (PyCFunction)rgb_to_hsv, METH_NOARGS },
+    { "to_hsl", (PyCFunction)rgb_to_hsl, METH_NOARGS },
+    { "to_cmyk", (PyCFunction)rgb_to_cmyk, METH_VARARGS|METH_KEYWORDS },
+    { "__reduce__", (PyCFunction)rgb_reduce, METH_NOARGS },
+    { NULL, NULL, 0 }
+};
+
+#define MEMBER_ACCESSOR(m) \
+static PyObject *							\
+rgb_get_ ## m(PyObject *self, void *closure)				\
+{									\
+    return PyFloat_FromDouble(pyg_boxed_get(self, GimpRGB)->m);		\
+}									\
+static int								\
+rgb_set_ ## m(PyObject *self, PyObject *value, void *closure)		\
+{									\
+    GimpRGB *rgb = pyg_boxed_get(self, GimpRGB);			\
+    if (value == NULL) {						\
+	PyErr_SetString(PyExc_TypeError, "cannot delete value");	\
+	return -1;							\
+    }									\
+    else if (PyInt_Check(value))					\
+	rgb->m = (double) PyInt_AS_LONG(value) / 255.0;			\
+    else if (PyFloat_Check(value))					\
+        rgb->m = PyFloat_AS_DOUBLE(value);				\
+    else {								\
+	PyErr_SetString(PyExc_TypeError, "type mismatch");		\
+	return -1;							\
+    }									\
+    return 0;								\
+}
+
+MEMBER_ACCESSOR(r);
+MEMBER_ACCESSOR(g);
+MEMBER_ACCESSOR(b);
+MEMBER_ACCESSOR(a);
+
+#undef MEMBER_ACCESSOR
+
+static PyGetSetDef rgb_getsets[] = {
+    { "r", (getter)rgb_get_r, (setter)rgb_set_r },
+    { "g", (getter)rgb_get_g, (setter)rgb_set_g },
+    { "b", (getter)rgb_get_b, (setter)rgb_set_b },
+    { "a", (getter)rgb_get_a, (setter)rgb_set_a },
+    { "red",   (getter)rgb_get_r, (setter)rgb_set_r },
+    { "green", (getter)rgb_get_g, (setter)rgb_set_g },
+    { "blue",  (getter)rgb_get_b, (setter)rgb_set_b },
+    { "alpha", (getter)rgb_get_a, (setter)rgb_set_a },
+    { NULL, (getter)0, (setter)0 },
+};
+
+static Py_ssize_t
+rgb_length(PyObject *self)
+{
+    return 4;
+}
+
+static PyObject *
+rgb_getitem(PyObject *self, Py_ssize_t pos)
+{
+    GimpRGB *rgb;
+    double val;
+
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return NULL;
+    }
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    switch (pos) {
+    case 0: val = rgb->r; break;
+    case 1: val = rgb->g; break;
+    case 2: val = rgb->b; break;
+    case 3: val = rgb->a; break;
+    default:
+        g_assert_not_reached();
+        return NULL;
+    }
+
+    return PyInt_FromLong(ROUND(CLAMP(val, 0.0, 1.0) * 255.0));
+}
+
+static int
+rgb_setitem(PyObject *self, Py_ssize_t pos, PyObject *value)
+{
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return -1;
+    }
+
+    switch (pos) {
+    case 0: return rgb_set_r(self, value, NULL);
+    case 1: return rgb_set_g(self, value, NULL);
+    case 2: return rgb_set_b(self, value, NULL);
+    case 3: return rgb_set_a(self, value, NULL);
+    default:
+        g_assert_not_reached();
+        return -1;
+    }
+}
+
+static PyObject *
+rgb_slice(PyObject *self, Py_ssize_t start, Py_ssize_t end)
+{
+    PyTupleObject *ret;
+    Py_ssize_t i;
+
+    if (start < 0)
+	start = 0;
+    if (end > 4)
+	end = 4;
+    if (end < start)
+	end = start;
+
+    ret = (PyTupleObject *)PyTuple_New(end - start);
+    if (ret == NULL)
+	return NULL;
+
+    for (i = start; i < end; i++)
+	PyTuple_SET_ITEM(ret, i - start, rgb_getitem(self, i));
+
+    return (PyObject *)ret;
+}
+
+static PySequenceMethods rgb_as_sequence = {
+    rgb_length,
+    (binaryfunc)0,
+    0,
+    rgb_getitem,
+    rgb_slice,
+    rgb_setitem,
+    0,
+    (objobjproc)0,
+};
+
+static PyObject *
+rgb_subscript(PyObject *self, PyObject *item)
+{
+    if (PyInt_Check(item)) {
+	long i = PyInt_AS_LONG(item);
+	return rgb_getitem(self, i);
+    } else if (PyLong_Check(item)) {
+	long i = PyLong_AsLong(item);
+	if (i == -1 && PyErr_Occurred())
+	    return NULL;
+	return rgb_getitem(self, i);
+    } else if (PySlice_Check(item)) {
+	Py_ssize_t start, stop, step, slicelength, cur, i;
+	PyObject *ret;
+
+	if (PySlice_GetIndicesEx((PySliceObject*)item, 4,
+				 &start, &stop, &step, &slicelength) < 0)
+	    return NULL;
+
+	if (slicelength <= 0) {
+	    return PyTuple_New(0);
+	} else {
+	    ret = PyTuple_New(slicelength);
+	    if (!ret)
+		return NULL;
+
+	    for (cur = start, i = 0; i < slicelength; cur += step, i++)
+		PyTuple_SET_ITEM(ret, i, rgb_getitem(self, cur));
+
+	    return ret;
+	}
+    } else if (PyString_Check(item)) {
+	char *s = PyString_AsString(item);
+
+	if (g_ascii_strcasecmp(s, "r") == 0 ||
+	    g_ascii_strcasecmp(s, "red") == 0)
+	    return rgb_get_r(self, NULL);
+	else if (g_ascii_strcasecmp(s, "g")  == 0 ||
+		 g_ascii_strcasecmp(s, "green") == 0)
+	    return rgb_get_g(self, NULL);
+	else if (g_ascii_strcasecmp(s, "b")  == 0 ||
+		 g_ascii_strcasecmp(s, "blue") == 0)
+	    return rgb_get_b(self, NULL);
+	else if (g_ascii_strcasecmp(s, "a")  == 0 ||
+		 g_ascii_strcasecmp(s, "alpha") == 0)
+	    return rgb_get_a(self, NULL);
+	else {
+	    PyErr_SetObject(PyExc_KeyError, item);
+	    return NULL;
+	}
+    } else {
+	PyErr_SetString(PyExc_TypeError,
+			"indices must be integers");
+	return NULL;
+    }
+}
+
+static PyMappingMethods rgb_as_mapping = {
+    rgb_length,
+    (binaryfunc)rgb_subscript,
+    (objobjargproc)0
+};
+
+static long
+rgb_hash(PyObject *self)
+{
+    long ret = -1;
+
+    PyObject *temp = rgb_getstate(self);
+    if (temp != NULL) {
+	ret = PyObject_Hash(temp);
+	Py_DECREF(temp);
+    }
+
+    return ret;
+}
+
+static PyObject *
+rgb_richcompare(PyObject *self, PyObject *other, int op)
+{
+    GimpRGB *c1, *c2;
+    PyObject *ret;
+
+    if (!pygimp_rgb_check(other)) {
+	PyErr_Format(PyExc_TypeError,
+		     "can't compare %s to %s",
+		     self->ob_type->tp_name, other->ob_type->tp_name);
+	return NULL;
+    }
+
+    if (op != Py_EQ && op != Py_NE) {
+	PyErr_SetString(PyExc_TypeError,
+			"can't compare color values using <, <=, >, >=");
+	return NULL;
+    }
+
+    c1 = pyg_boxed_get(self, GimpRGB);
+    c2 = pyg_boxed_get(other, GimpRGB);
+
+    if ((c1->r == c2->r && c1->g == c2->g && c1->b == c2->b && c1->a == c2->a) == (op == Py_EQ))
+	ret = Py_True;
+    else
+	ret = Py_False;
+
+    Py_INCREF(ret);
+    return ret;
+}
+
+static PyObject *
+rgb_pretty_print(PyObject *self, gboolean inexact)
+{
+    GimpRGB *rgb;
+    PyObject *ret = NULL;
+    PyObject *r_f = NULL, *g_f = NULL, *b_f = NULL, *a_f = NULL;
+    PyObject *r = NULL, *g = NULL, *b = NULL, *a = NULL;
+    reprfunc repr;
+    const char *prefix;
+
+    if (inexact) {
+	repr = PyObject_Str;
+	prefix = "RGB ";
+    } else {
+	repr = PyObject_Repr;
+	prefix = self->ob_type->tp_name;
+    }
+
+    rgb = pyg_boxed_get(self, GimpRGB);
+
+    if ((r_f = PyFloat_FromDouble(rgb->r)) == NULL) goto cleanup;
+    if ((g_f = PyFloat_FromDouble(rgb->g)) == NULL) goto cleanup;
+    if ((b_f = PyFloat_FromDouble(rgb->b)) == NULL) goto cleanup;
+    if ((a_f = PyFloat_FromDouble(rgb->a)) == NULL) goto cleanup;
+
+    if ((r = repr(r_f)) == NULL) goto cleanup;
+    if ((g = repr(g_f)) == NULL) goto cleanup;
+    if ((b = repr(b_f)) == NULL) goto cleanup;
+    if ((a = repr(a_f)) == NULL) goto cleanup;
+
+    ret = PyString_FromFormat("%s(%s, %s, %s, %s)",
+			      prefix,
+			      PyString_AsString(r),
+			      PyString_AsString(g),
+			      PyString_AsString(b),
+			      PyString_AsString(a));
+
+cleanup:
+    Py_XDECREF(r); Py_XDECREF(g); Py_XDECREF(b); Py_XDECREF(a);
+    Py_XDECREF(r_f); Py_XDECREF(g_f); Py_XDECREF(b_f); Py_XDECREF(a_f);
+
+    return ret;
+}
+
+static PyObject *
+rgb_repr(PyObject *self)
+{
+    return rgb_pretty_print(self, FALSE);
+}
+
+static PyObject *
+rgb_str(PyObject *self)
+{
+    return rgb_pretty_print(self, TRUE);
+}
+
+static int
+rgb_init(PyGBoxed *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *r, *g, *b, *a = NULL;
+    GimpRGB rgb;
+    static char *kwlist[] = { "r", "g", "b", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "OOO|O:set", kwlist,
+				     &r, &g, &b, &a))
+        return -1;
+
+#define SET_MEMBER(m)	G_STMT_START {				\
+    if (PyInt_Check(m))						\
+	rgb.m = (double) PyInt_AS_LONG(m) / 255.0;		\
+    else if (PyFloat_Check(m))					\
+        rgb.m = PyFloat_AS_DOUBLE(m);				\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return -1;						\
+    }								\
+} G_STMT_END
+
+    SET_MEMBER(r);
+    SET_MEMBER(g);
+    SET_MEMBER(b);
+
+    if (a)
+	SET_MEMBER(a);
+    else
+        rgb.a = 1.0;
+
+#undef SET_MEMBER
+
+    self->gtype = GIMP_TYPE_RGB;
+    self->free_on_dealloc = TRUE;
+    self->boxed = g_boxed_copy(GIMP_TYPE_RGB, &rgb);
+
+    return 0;
+}
+
+PyTypeObject PyGimpRGB_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size */
+    "gimpcolor.RGB",			/* tp_name */
+    sizeof(PyGBoxed),			/* tp_basicsize */
+    0,					/* tp_itemsize */
+    /* methods */
+    (destructor)0,			/* tp_dealloc */
+    (printfunc)0,			/* tp_print */
+    (getattrfunc)0,			/* tp_getattr */
+    (setattrfunc)0,			/* tp_setattr */
+    (cmpfunc)0,				/* tp_compare */
+    (reprfunc)rgb_repr,			/* tp_repr */
+    (PyNumberMethods*)0,		/* tp_as_number */
+    &rgb_as_sequence,			/* tp_as_sequence */
+    &rgb_as_mapping,			/* tp_as_mapping */
+    (hashfunc)rgb_hash,			/* tp_hash */
+    (ternaryfunc)0,			/* tp_call */
+    (reprfunc)rgb_str,			/* tp_str */
+    (getattrofunc)0,			/* tp_getattro */
+    (setattrofunc)0,			/* tp_setattro */
+    (PyBufferProcs*)0,			/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,			/* tp_flags */
+    NULL, 				/* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)rgb_richcompare,	/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    rgb_methods,			/* tp_methods */
+    0,					/* tp_members */
+    rgb_getsets,			/* tp_getset */
+    NULL,				/* tp_base */
+    NULL,				/* tp_dict */
+    (descrgetfunc)0,			/* tp_descr_get */
+    (descrsetfunc)0,			/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)rgb_init,			/* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+    (freefunc)0,			/* tp_free */
+    (inquiry)0				/* tp_is_gc */
+};
+
+PyObject *
+pygimp_rgb_new(const GimpRGB *rgb)
+{
+    return pyg_boxed_new(GIMP_TYPE_RGB, (gpointer)rgb, TRUE, TRUE);
+}
+
+
+static PyObject *
+hsv_set(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *h = NULL, *s = NULL, *v = NULL, *a = NULL;
+    GimpHSV tmphsv, *hsv;
+    static char *kwlist[] = { "h", "s", "v", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:set", kwlist,
+				     &h, &s, &v, &a))
+        return NULL;
+
+    if (!h && !s && !v && !a) {
+	PyErr_SetString(PyExc_TypeError, "must provide h,s,v or a arguments");
+	return NULL;
+    }
+
+    if ((h && (!s || !v)) ||
+        (s && (!h || !v)) ||
+        (v && (!h || !s))) {
+	PyErr_SetString(PyExc_TypeError, "must provide all 3 h,s,v arguments");
+	return NULL;
+    }
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+    tmphsv = *hsv;
+
+#define SET_MEMBER(m, s)	G_STMT_START {			\
+    if (PyInt_Check(m))						\
+        tmphsv.m = (double) PyInt_AS_LONG(m) / s;		\
+    else if (PyFloat_Check(m))					\
+        tmphsv.m = PyFloat_AS_DOUBLE(m);			\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be a float");			\
+	return NULL;						\
+    }								\
+} G_STMT_END
+
+    if (h) {
+	SET_MEMBER(h, 360.0);
+	SET_MEMBER(s, 100.0);
+	SET_MEMBER(v, 100.0);
+    }
+
+    if (a)
+	SET_MEMBER(a, 255.0);
+
+#undef SET_MEMBER
+
+    *hsv = tmphsv;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+hsv_set_alpha(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_a;
+    GimpHSV *hsv;
+    static char *kwlist[] = { "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "O:set_alpha", kwlist,
+				     &py_a))
+        return NULL;
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+
+    if (PyInt_Check(py_a))
+        hsv->a = (double) PyInt_AS_LONG(py_a) / 255.0;
+    else if (PyFloat_Check(py_a))
+        hsv->a = PyFloat_AS_DOUBLE(py_a);
+    else {
+	PyErr_SetString(PyExc_TypeError, "a must be a float");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+hsv_clamp(PyObject *self)
+{
+    gimp_hsv_clamp(pyg_boxed_get(self, GimpHSV));
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+hsv_to_rgb(PyObject *self)
+{
+    GimpHSV *hsv;
+    GimpRGB rgb;
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+
+    gimp_hsv_to_rgb(hsv, &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+
+/* __getstate__ isn't exposed */
+static PyObject *
+hsv_getstate(PyObject *self)
+{
+    GimpHSV *hsv;
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+
+    return Py_BuildValue("dddd", hsv->h, hsv->s, hsv->v, hsv->a);
+}
+
+static PyObject *
+hsv_reduce(PyObject *self)
+{
+    return Py_BuildValue("ON", self->ob_type, hsv_getstate(self));
+}
+
+static PyMethodDef hsv_methods[] = {
+    { "set", (PyCFunction)hsv_set, METH_VARARGS|METH_KEYWORDS },
+    { "set_alpha", (PyCFunction)hsv_set_alpha, METH_VARARGS|METH_KEYWORDS },
+    { "clamp", (PyCFunction)hsv_clamp, METH_NOARGS },
+    { "to_rgb", (PyCFunction)hsv_to_rgb, METH_NOARGS },
+    { "__reduce__", (PyCFunction)hsv_reduce, METH_NOARGS },
+    { NULL, NULL, 0 }
+};
+
+#define MEMBER_ACCESSOR(m, s) \
+static PyObject *							\
+hsv_get_ ## m(PyObject *self, void *closure)				\
+{									\
+    return PyFloat_FromDouble(pyg_boxed_get(self, GimpHSV)->m);		\
+}									\
+static int								\
+hsv_set_ ## m(PyObject *self, PyObject *value, void *closure)		\
+{									\
+    GimpHSV *hsv = pyg_boxed_get(self, GimpHSV);			\
+    if (value == NULL) {						\
+	PyErr_SetString(PyExc_TypeError, "cannot delete value");	\
+	return -1;							\
+    }									\
+    else if (PyInt_Check(value))					\
+        hsv->m = (double) PyInt_AS_LONG(value) / s;			\
+    else if (PyFloat_Check(value))					\
+        hsv->m = PyFloat_AS_DOUBLE(value);				\
+    else {								\
+	PyErr_SetString(PyExc_TypeError, "type mismatch");		\
+	return -1;							\
+    }									\
+    return 0;								\
+}
+
+MEMBER_ACCESSOR(h, 360.0);
+MEMBER_ACCESSOR(s, 100.0);
+MEMBER_ACCESSOR(v, 100.0);
+MEMBER_ACCESSOR(a, 255.0);
+
+#undef MEMBER_ACCESSOR
+
+static PyGetSetDef hsv_getsets[] = {
+    { "h", (getter)hsv_get_h, (setter)hsv_set_h },
+    { "s", (getter)hsv_get_s, (setter)hsv_set_s },
+    { "v", (getter)hsv_get_v, (setter)hsv_set_v },
+    { "a", (getter)hsv_get_a, (setter)hsv_set_a },
+    { "hue", (getter)hsv_get_h, (setter)hsv_set_h },
+    { "saturation", (getter)hsv_get_s, (setter)hsv_set_s },
+    { "value", (getter)hsv_get_v, (setter)hsv_set_v },
+    { "alpha", (getter)hsv_get_a, (setter)hsv_set_a },
+    { NULL, (getter)0, (setter)0 },
+};
+
+static Py_ssize_t
+hsv_length(PyObject *self)
+{
+    return 4;
+}
+
+static PyObject *
+hsv_getitem(PyObject *self, Py_ssize_t pos)
+{
+    GimpHSV *hsv;
+    double val, scale_factor;
+
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return NULL;
+    }
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+
+    switch (pos) {
+    case 0: val = hsv->h; scale_factor = 360.0; break;
+    case 1: val = hsv->s; scale_factor = 100.0; break;
+    case 2: val = hsv->v; scale_factor = 100.0; break;
+    case 3: val = hsv->a; scale_factor = 255.0; break;
+    default:
+        g_assert_not_reached();
+        return NULL;
+    }
+
+    return PyInt_FromLong(ROUND(CLAMP(val, 0.0, 1.0) * scale_factor));
+}
+
+static int
+hsv_setitem(PyObject *self, Py_ssize_t pos, PyObject *value)
+{
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return -1;
+    }
+
+    switch (pos) {
+    case 0: return hsv_set_h(self, value, NULL);
+    case 1: return hsv_set_s(self, value, NULL);
+    case 2: return hsv_set_v(self, value, NULL);
+    case 3: return hsv_set_a(self, value, NULL);
+    default:
+        g_assert_not_reached();
+        return -1;
+    }
+}
+
+static PyObject *
+hsv_slice(PyObject *self, Py_ssize_t start, Py_ssize_t end)
+{
+    PyTupleObject *ret;
+    Py_ssize_t i;
+
+    if (start < 0)
+	start = 0;
+    if (end > 4)
+	end = 4;
+    if (end < start)
+	end = start;
+
+    ret = (PyTupleObject *)PyTuple_New(end - start);
+    if (ret == NULL)
+	return NULL;
+
+    for (i = start; i < end; i++)
+	PyTuple_SET_ITEM(ret, i - start, hsv_getitem(self, i));
+
+    return (PyObject *)ret;
+}
+
+static PySequenceMethods hsv_as_sequence = {
+    hsv_length,
+    (binaryfunc)0,
+    0,
+    hsv_getitem,
+    hsv_slice,
+    hsv_setitem,
+    0,
+    (objobjproc)0,
+};
+
+static PyObject *
+hsv_subscript(PyObject *self, PyObject *item)
+{
+    if (PyInt_Check(item)) {
+	long i = PyInt_AS_LONG(item);
+	return hsv_getitem(self, i);
+    } else if (PyLong_Check(item)) {
+	long i = PyLong_AsLong(item);
+	if (i == -1 && PyErr_Occurred())
+	    return NULL;
+	return hsv_getitem(self, i);
+    } else if (PySlice_Check(item)) {
+	Py_ssize_t start, stop, step, slicelength, cur, i;
+	PyObject *ret;
+
+	if (PySlice_GetIndicesEx((PySliceObject*)item, 4,
+				 &start, &stop, &step, &slicelength) < 0)
+	    return NULL;
+
+	if (slicelength <= 0) {
+	    return PyTuple_New(0);
+	} else {
+	    ret = PyTuple_New(slicelength);
+	    if (!ret)
+		return NULL;
+
+	    for (cur = start, i = 0; i < slicelength; cur += step, i++)
+		PyTuple_SET_ITEM(ret, i, hsv_getitem(self, cur));
+
+	    return ret;
+	}
+    } else if (PyString_Check(item)) {
+	char *s = PyString_AsString(item);
+
+	if (g_ascii_strcasecmp(s, "h") == 0 ||
+	    g_ascii_strcasecmp(s, "hue") == 0)
+	    return hsv_get_h(self, NULL);
+	else if (g_ascii_strcasecmp(s, "s")  == 0 ||
+		 g_ascii_strcasecmp(s, "saturation") == 0)
+	    return hsv_get_s(self, NULL);
+	else if (g_ascii_strcasecmp(s, "v")  == 0 ||
+		 g_ascii_strcasecmp(s, "value") == 0)
+	    return hsv_get_v(self, NULL);
+	else if (g_ascii_strcasecmp(s, "a")  == 0 ||
+		 g_ascii_strcasecmp(s, "alpha") == 0)
+	    return hsv_get_a(self, NULL);
+	else {
+	    PyErr_SetObject(PyExc_KeyError, item);
+	    return NULL;
+	}
+    } else {
+	PyErr_SetString(PyExc_TypeError,
+			"indices must be integers");
+	return NULL;
+    }
+}
+
+static PyMappingMethods hsv_as_mapping = {
+    hsv_length,
+    (binaryfunc)hsv_subscript,
+    (objobjargproc)0
+};
+
+static long
+hsv_hash(PyObject *self)
+{
+    long ret = -1;
+
+    PyObject *temp = hsv_getstate(self);
+    if (temp != NULL) {
+	ret = PyObject_Hash(temp);
+	Py_DECREF(temp);
+    }
+
+    return ret;
+}
+
+static PyObject *
+hsv_richcompare(PyObject *self, PyObject *other, int op)
+{
+    GimpHSV *c1, *c2;
+    PyObject *ret;
+
+    if (!pygimp_hsv_check(other)) {
+	PyErr_Format(PyExc_TypeError,
+		     "can't compare %s to %s",
+		     self->ob_type->tp_name, other->ob_type->tp_name);
+	return NULL;
+    }
+
+    if (op != Py_EQ && op != Py_NE) {
+	PyErr_SetString(PyExc_TypeError,
+			"can't compare color values using <, <=, >, >=");
+	return NULL;
+    }
+
+    c1 = pyg_boxed_get(self, GimpHSV);
+    c2 = pyg_boxed_get(other, GimpHSV);
+
+    if ((c1->h == c2->h && c1->s == c2->s && c1->v == c2->v && c1->a == c2->a) == (op == Py_EQ))
+	ret = Py_True;
+    else
+	ret = Py_False;
+
+    Py_INCREF(ret);
+    return ret;
+}
+
+static PyObject *
+hsv_pretty_print(PyObject *self, gboolean inexact)
+{
+    GimpHSV *hsv;
+    PyObject *ret = NULL;
+    PyObject *h_f = NULL, *s_f = NULL, *v_f = NULL, *a_f = NULL;
+    PyObject *h = NULL, *s = NULL, *v = NULL, *a = NULL;
+    reprfunc repr;
+    const char *prefix;
+
+    if (inexact) {
+	repr = PyObject_Str;
+	prefix = "HSV ";
+    } else {
+	repr = PyObject_Repr;
+	prefix = self->ob_type->tp_name;
+    }
+
+    hsv = pyg_boxed_get(self, GimpHSV);
+
+    if ((h_f = PyFloat_FromDouble(hsv->h)) == NULL) goto cleanup;
+    if ((s_f = PyFloat_FromDouble(hsv->s)) == NULL) goto cleanup;
+    if ((v_f = PyFloat_FromDouble(hsv->v)) == NULL) goto cleanup;
+    if ((a_f = PyFloat_FromDouble(hsv->a)) == NULL) goto cleanup;
+
+    if ((h = repr(h_f)) == NULL) goto cleanup;
+    if ((s = repr(s_f)) == NULL) goto cleanup;
+    if ((v = repr(v_f)) == NULL) goto cleanup;
+    if ((a = repr(a_f)) == NULL) goto cleanup;
+
+    ret = PyString_FromFormat("%s(%s, %s, %s, %s)",
+			      prefix,
+			      PyString_AsString(h),
+			      PyString_AsString(s),
+			      PyString_AsString(v),
+			      PyString_AsString(a));
+
+cleanup:
+    Py_XDECREF(h); Py_XDECREF(s); Py_XDECREF(v); Py_XDECREF(a);
+    Py_XDECREF(h_f); Py_XDECREF(s_f); Py_XDECREF(v_f); Py_XDECREF(a_f);
+
+    return ret;
+}
+
+static PyObject *
+hsv_repr(PyObject *self)
+{
+    return hsv_pretty_print(self, FALSE);
+}
+
+static PyObject *
+hsv_str(PyObject *self)
+{
+    return hsv_pretty_print(self, TRUE);
+}
+
+static int
+hsv_init(PyGBoxed *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *h, *s, *v, *a = NULL;
+    GimpHSV hsv;
+    static char *kwlist[] = { "h", "s", "v", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "OOO|O:set", kwlist,
+				     &h, &s, &v, &a))
+        return -1;
+
+#define SET_MEMBER(m, s)	G_STMT_START {			\
+    if (PyInt_Check(m))						\
+        hsv.m = (double) PyInt_AS_LONG(m) / s;			\
+    else if (PyFloat_Check(m))					\
+        hsv.m = PyFloat_AS_DOUBLE(m);				\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return -1;						\
+    }								\
+} G_STMT_END
+
+    SET_MEMBER(h, 360.0);
+    SET_MEMBER(s, 100.0);
+    SET_MEMBER(v, 100.0);
+
+    if (a)
+	SET_MEMBER(a, 255.0);
+    else
+        hsv.a = 1.0;
+
+#undef SET_MEMBER
+
+    self->gtype = GIMP_TYPE_HSV;
+    self->free_on_dealloc = TRUE;
+    self->boxed = g_boxed_copy(GIMP_TYPE_HSV, &hsv);
+
+    return 0;
+}
+
+PyTypeObject PyGimpHSV_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size */
+    "gimpcolor.HSV",			/* tp_name */
+    sizeof(PyGBoxed),			/* tp_basicsize */
+    0,					/* tp_itemsize */
+    /* methods */
+    (destructor)0,			/* tp_dealloc */
+    (printfunc)0,			/* tp_print */
+    (getattrfunc)0,			/* tp_getattr */
+    (setattrfunc)0,			/* tp_setattr */
+    (cmpfunc)0,				/* tp_compare */
+    (reprfunc)hsv_repr,			/* tp_repr */
+    (PyNumberMethods*)0,		/* tp_as_number */
+    &hsv_as_sequence,			/* tp_as_sequence */
+    &hsv_as_mapping,			/* tp_as_mapping */
+    (hashfunc)hsv_hash,			/* tp_hash */
+    (ternaryfunc)0,			/* tp_call */
+    (reprfunc)hsv_str,			/* tp_repr */
+    (getattrofunc)0,			/* tp_getattro */
+    (setattrofunc)0,			/* tp_setattro */
+    (PyBufferProcs*)0,			/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,			/* tp_flags */
+    NULL, 				/* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)hsv_richcompare,	/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    hsv_methods,			/* tp_methods */
+    0,					/* tp_members */
+    hsv_getsets,			/* tp_getset */
+    NULL,				/* tp_base */
+    NULL,				/* tp_dict */
+    (descrgetfunc)0,			/* tp_descr_get */
+    (descrsetfunc)0,			/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)hsv_init,			/* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+    (freefunc)0,			/* tp_free */
+    (inquiry)0				/* tp_is_gc */
+};
+
+PyObject *
+pygimp_hsv_new(const GimpHSV *hsv)
+{
+    return pyg_boxed_new(GIMP_TYPE_HSV, (gpointer)hsv, TRUE, TRUE);
+}
+
+
+static PyObject *
+hsl_set(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *h = NULL, *s = NULL, *l = NULL, *a = NULL;
+    GimpHSL tmphsl, *hsl;
+    static char *kwlist[] = { "h", "s", "l", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:set", kwlist,
+				     &h, &s, &l, &a))
+        return NULL;
+
+    if (!h && !s && !l && !a) {
+	PyErr_SetString(PyExc_TypeError, "must provide h,s,l or a arguments");
+	return NULL;
+    }
+
+    if ((h && (!s || !l)) ||
+        (s && (!h || !l)) ||
+        (l && (!h || !s))) {
+	PyErr_SetString(PyExc_TypeError, "must provide all 3 h,s,l arguments");
+	return NULL;
+    }
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+    tmphsl = *hsl;
+
+#define SET_MEMBER(m, s)	G_STMT_START {			\
+    if (PyInt_Check(m))						\
+        tmphsl.m = (double) PyInt_AS_LONG(m) / s;		\
+    else if (PyFloat_Check(m))					\
+        tmphsl.m = PyFloat_AS_DOUBLE(m);			\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be a float");			\
+	return NULL;						\
+    }								\
+} G_STMT_END
+
+    if (h) {
+	SET_MEMBER(h, 360.0);
+	SET_MEMBER(s, 100.0);
+	SET_MEMBER(l, 100.0);
+    }
+
+    if (a)
+	SET_MEMBER(a, 255.0);
+
+#undef SET_MEMBER
+
+    *hsl = tmphsl;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+hsl_set_alpha(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_a;
+    GimpHSL *hsl;
+    static char *kwlist[] = { "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "O:set_alpha", kwlist,
+				     &py_a))
+        return NULL;
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+
+    if (PyInt_Check(py_a))
+        hsl->a = (double) PyInt_AS_LONG(py_a) / 255.0;
+    else if (PyFloat_Check(py_a))
+        hsl->a = PyFloat_AS_DOUBLE(py_a);
+    else {
+	PyErr_SetString(PyExc_TypeError, "a must be a float");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+hsl_to_rgb(PyObject *self)
+{
+    GimpHSL *hsl;
+    GimpRGB rgb;
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+
+    gimp_hsl_to_rgb(hsl, &rgb);
+
+    return pygimp_rgb_new(&rgb);
+}
+
+/* __getstate__ isn't exposed */
+static PyObject *
+hsl_getstate(PyObject *self)
+{
+    GimpHSL *hsl;
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+
+    return Py_BuildValue("dddd", hsl->h, hsl->s, hsl->l, hsl->a);
+}
+
+static PyObject *
+hsl_reduce(PyObject *self)
+{
+    return Py_BuildValue("ON", self->ob_type, hsl_getstate(self));
+}
+
+static PyMethodDef hsl_methods[] = {
+    { "set", (PyCFunction)hsl_set, METH_VARARGS|METH_KEYWORDS },
+    { "set_alpha", (PyCFunction)hsl_set_alpha, METH_VARARGS|METH_KEYWORDS },
+    { "to_rgb", (PyCFunction)hsl_to_rgb, METH_NOARGS },
+    { "__reduce__", (PyCFunction)hsl_reduce, METH_NOARGS },
+    { NULL, NULL, 0 }
+};
+
+#define MEMBER_ACCESSOR(m, s) \
+static PyObject *							\
+hsl_get_ ## m(PyObject *self, void *closure)				\
+{									\
+    return PyFloat_FromDouble(pyg_boxed_get(self, GimpHSL)->m);		\
+}									\
+static int								\
+hsl_set_ ## m(PyObject *self, PyObject *value, void *closure)		\
+{									\
+    GimpHSL *hsl = pyg_boxed_get(self, GimpHSL);			\
+    if (value == NULL) {						\
+	PyErr_SetString(PyExc_TypeError, "cannot delete value");	\
+	return -1;							\
+    }									\
+    else if (PyInt_Check(value))					\
+        hsl->m = (double) PyInt_AS_LONG(value) / s;			\
+    else if (PyFloat_Check(value))					\
+        hsl->m = PyFloat_AS_DOUBLE(value);				\
+    else {								\
+	PyErr_SetString(PyExc_TypeError, "type mismatch");		\
+	return -1;							\
+    }									\
+    return 0;								\
+}
+
+MEMBER_ACCESSOR(h, 360.0);
+MEMBER_ACCESSOR(s, 100.0);
+MEMBER_ACCESSOR(l, 100.0);
+MEMBER_ACCESSOR(a, 255.0);
+
+#undef MEMBER_ACCESSOR
+
+static PyGetSetDef hsl_getsets[] = {
+    { "h", (getter)hsl_get_h, (setter)hsl_set_h },
+    { "s", (getter)hsl_get_s, (setter)hsl_set_s },
+    { "l", (getter)hsl_get_l, (setter)hsl_set_l },
+    { "a", (getter)hsl_get_a, (setter)hsl_set_a },
+    { "hue", (getter)hsl_get_h, (setter)hsl_set_h },
+    { "saturation", (getter)hsl_get_s, (setter)hsl_set_s },
+    { "lightness", (getter)hsl_get_l, (setter)hsl_set_l },
+    { "alpha", (getter)hsl_get_a, (setter)hsl_set_a },
+    { NULL, (getter)0, (setter)0 },
+};
+
+static Py_ssize_t
+hsl_length(PyObject *self)
+{
+    return 4;
+}
+
+static PyObject *
+hsl_getitem(PyObject *self, Py_ssize_t pos)
+{
+    GimpHSL *hsl;
+    double val, scale_factor;
+
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return NULL;
+    }
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+
+    switch (pos) {
+    case 0: val = hsl->h; scale_factor = 360.0; break;
+    case 1: val = hsl->s; scale_factor = 100.0; break;
+    case 2: val = hsl->l; scale_factor = 100.0; break;
+    case 3: val = hsl->a; scale_factor = 255.0; break;
+    default:
+        g_assert_not_reached();
+        return NULL;
+    }
+
+    return PyInt_FromLong(ROUND(CLAMP(val, 0.0, 1.0) * scale_factor));
+}
+
+static int
+hsl_setitem(PyObject *self, Py_ssize_t pos, PyObject *value)
+{
+    if (pos < 0)
+        pos += 4;
+
+    if (pos < 0 || pos >= 4) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return -1;
+    }
+
+    switch (pos) {
+    case 0: return hsl_set_h(self, value, NULL);
+    case 1: return hsl_set_s(self, value, NULL);
+    case 2: return hsl_set_l(self, value, NULL);
+    case 3: return hsl_set_a(self, value, NULL);
+    default:
+        g_assert_not_reached();
+        return -1;
+    }
+}
+
+static PyObject *
+hsl_slice(PyObject *self, Py_ssize_t start, Py_ssize_t end)
+{
+    PyTupleObject *ret;
+    Py_ssize_t i;
+
+    if (start < 0)
+        start = 0;
+    if (end > 4)
+        end = 4;
+    if (end < start)
+        end = start;
+
+    ret = (PyTupleObject *)PyTuple_New(end - start);
+    if (ret == NULL)
+        return NULL;
+
+    for (i = start; i < end; i++)
+        PyTuple_SET_ITEM(ret, i - start, hsl_getitem(self, i));
+
+    return (PyObject *)ret;
+}
+
+static PySequenceMethods hsl_as_sequence = {
+    hsl_length,
+    (binaryfunc)0,
+    0,
+    hsl_getitem,
+    hsl_slice,
+    hsl_setitem,
+    0,
+    (objobjproc)0,
+};
+
+static PyObject *
+hsl_subscript(PyObject *self, PyObject *item)
+{
+    if (PyInt_Check(item)) {
+        long i = PyInt_AS_LONG(item);
+        return hsl_getitem(self, i);
+    } else if (PyLong_Check(item)) {
+        long i = PyLong_AsLong(item);
+        if (i == -1 && PyErr_Occurred())
+            return NULL;
+        return hsl_getitem(self, i);
+    } else if (PySlice_Check(item)) {
+        Py_ssize_t start, stop, step, slicelength, cur, i;
+        PyObject *ret;
+
+        if (PySlice_GetIndicesEx((PySliceObject*)item, 4,
+                                 &start, &stop, &step, &slicelength) < 0)
+            return NULL;
+
+        if (slicelength <= 0) {
+            return PyTuple_New(0);
+        } else {
+            ret = PyTuple_New(slicelength);
+            if (!ret)
+                return NULL;
+
+            for (cur = start, i = 0; i < slicelength; cur += step, i++)
+                PyTuple_SET_ITEM(ret, i, hsl_getitem(self, cur));
+
+            return ret;
+        }
+    } else if (PyString_Check(item)) {
+        char *s = PyString_AsString(item);
+
+        if (g_ascii_strcasecmp(s, "h") == 0 ||
+            g_ascii_strcasecmp(s, "hue") == 0)
+            return hsl_get_h(self, NULL);
+        else if (g_ascii_strcasecmp(s, "s")  == 0 ||
+                 g_ascii_strcasecmp(s, "saturation") == 0)
+            return hsl_get_s(self, NULL);
+        else if (g_ascii_strcasecmp(s, "l")  == 0 ||
+                 g_ascii_strcasecmp(s, "lightness") == 0)
+            return hsl_get_l(self, NULL);
+        else if (g_ascii_strcasecmp(s, "a")  == 0 ||
+                 g_ascii_strcasecmp(s, "alpha") == 0)
+            return hsl_get_a(self, NULL);
+        else {
+            PyErr_SetObject(PyExc_KeyError, item);
+            return NULL;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+                        "indices must be integers");
+        return NULL;
+    }
+}
+
+static PyMappingMethods hsl_as_mapping = {
+    hsl_length,
+    (binaryfunc)hsl_subscript,
+    (objobjargproc)0
+};
+
+static long
+hsl_hash(PyObject *self)
+{
+    long ret = -1;
+
+    PyObject *temp = hsl_getstate(self);
+    if (temp != NULL) {
+	ret = PyObject_Hash(temp);
+	Py_DECREF(temp);
+    }
+
+    return ret;
+}
+
+static PyObject *
+hsl_richcompare(PyObject *self, PyObject *other, int op)
+{
+    GimpHSL *c1, *c2;
+    PyObject *ret;
+
+    if (!pygimp_hsl_check(other)) {
+	PyErr_Format(PyExc_TypeError,
+		     "can't compare %s to %s",
+		     self->ob_type->tp_name, other->ob_type->tp_name);
+	return NULL;
+    }
+
+    if (op != Py_EQ && op != Py_NE) {
+	PyErr_SetString(PyExc_TypeError,
+			"can't compare color values using <, <=, >, >=");
+	return NULL;
+    }
+
+    c1 = pyg_boxed_get(self, GimpHSL);
+    c2 = pyg_boxed_get(other, GimpHSL);
+
+    if ((c1->h == c2->h && c1->s == c2->s && c1->l == c2->l && c1->a == c2->a) == (op == Py_EQ))
+	ret = Py_True;
+    else
+	ret = Py_False;
+
+    Py_INCREF(ret);
+    return ret;
+}
+
+static PyObject *
+hsl_pretty_print(PyObject *self, gboolean inexact)
+{
+    GimpHSL *hsl;
+    PyObject *ret = NULL;
+    PyObject *h_f = NULL, *s_f = NULL, *l_f = NULL, *a_f = NULL;
+    PyObject *h = NULL, *s = NULL, *l = NULL, *a = NULL;
+    reprfunc repr;
+    const char *prefix;
+
+    if (inexact) {
+	repr = PyObject_Str;
+	prefix = "HSL ";
+    } else {
+	repr = PyObject_Repr;
+	prefix = self->ob_type->tp_name;
+    }
+
+    hsl = pyg_boxed_get(self, GimpHSL);
+
+    if ((h_f = PyFloat_FromDouble(hsl->h)) == NULL) goto cleanup;
+    if ((s_f = PyFloat_FromDouble(hsl->s)) == NULL) goto cleanup;
+    if ((l_f = PyFloat_FromDouble(hsl->l)) == NULL) goto cleanup;
+    if ((a_f = PyFloat_FromDouble(hsl->a)) == NULL) goto cleanup;
+
+    if ((h = repr(h_f)) == NULL) goto cleanup;
+    if ((s = repr(s_f)) == NULL) goto cleanup;
+    if ((l = repr(l_f)) == NULL) goto cleanup;
+    if ((a = repr(a_f)) == NULL) goto cleanup;
+
+    ret = PyString_FromFormat("%s(%s, %s, %s, %s)",
+			      prefix,
+			      PyString_AsString(h),
+			      PyString_AsString(s),
+			      PyString_AsString(l),
+			      PyString_AsString(a));
+
+cleanup:
+    Py_XDECREF(h); Py_XDECREF(s); Py_XDECREF(l); Py_XDECREF(a);
+    Py_XDECREF(h_f); Py_XDECREF(s_f); Py_XDECREF(l_f); Py_XDECREF(a_f);
+
+    return ret;
+}
+
+static PyObject *
+hsl_repr(PyObject *self)
+{
+    return hsl_pretty_print(self, FALSE);
+}
+
+static PyObject *
+hsl_str(PyObject *self)
+{
+    return hsl_pretty_print(self, TRUE);
+}
+
+static int
+hsl_init(PyGBoxed *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *h, *s, *l, *a = NULL;
+    GimpHSL hsl;
+    static char *kwlist[] = { "h", "s", "l", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "OOO|O:set", kwlist,
+				     &h, &s, &l, &a))
+        return -1;
+
+#define SET_MEMBER(m, s)	G_STMT_START {			\
+    if (PyInt_Check(m))						\
+        hsl.m = (double) PyInt_AS_LONG(m) / s;			\
+    else if (PyFloat_Check(m))					\
+        hsl.m = PyFloat_AS_DOUBLE(m);				\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be a float");			\
+	return -1;						\
+    }								\
+} G_STMT_END
+
+    SET_MEMBER(h, 360.0);
+    SET_MEMBER(s, 100.0);
+    SET_MEMBER(l, 100.0);
+
+    if (a)
+	SET_MEMBER(a, 255.0);
+    else
+        hsl.a = 1.0;
+
+#undef SET_MEMBER
+
+    self->gtype = GIMP_TYPE_HSL;
+    self->free_on_dealloc = TRUE;
+    self->boxed = g_boxed_copy(GIMP_TYPE_HSL, &hsl);
+
+    return 0;
+}
+
+PyTypeObject PyGimpHSL_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size */
+    "gimpcolor.HSL",			/* tp_name */
+    sizeof(PyGBoxed),			/* tp_basicsize */
+    0,					/* tp_itemsize */
+    /* methods */
+    (destructor)0,			/* tp_dealloc */
+    (printfunc)0,			/* tp_print */
+    (getattrfunc)0,			/* tp_getattr */
+    (setattrfunc)0,			/* tp_setattr */
+    (cmpfunc)0,				/* tp_compare */
+    (reprfunc)hsl_repr,			/* tp_repr */
+    (PyNumberMethods*)0,		/* tp_as_number */
+    &hsl_as_sequence,			/* tp_as_sequence */
+    &hsl_as_mapping,			/* tp_as_mapping */
+    (hashfunc)hsl_hash,			/* tp_hash */
+    (ternaryfunc)0,			/* tp_call */
+    (reprfunc)hsl_str,			/* tp_repr */
+    (getattrofunc)0,			/* tp_getattro */
+    (setattrofunc)0,			/* tp_setattro */
+    (PyBufferProcs*)0,			/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,			/* tp_flags */
+    NULL, 				/* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)hsl_richcompare,	/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    hsl_methods,			/* tp_methods */
+    0,					/* tp_members */
+    hsl_getsets,			/* tp_getset */
+    NULL,				/* tp_base */
+    NULL,				/* tp_dict */
+    (descrgetfunc)0,			/* tp_descr_get */
+    (descrsetfunc)0,			/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)hsl_init,			/* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+    (freefunc)0,			/* tp_free */
+    (inquiry)0				/* tp_is_gc */
+};
+
+PyObject *
+pygimp_hsl_new(const GimpHSL *hsl)
+{
+    return pyg_boxed_new(GIMP_TYPE_HSL, (gpointer)hsl, TRUE, TRUE);
+}
+
+
+static PyObject *
+cmyk_set(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *c = NULL, *m = NULL, *y = NULL, *k = NULL, *a = NULL;
+    GimpCMYK tmpcmyk, *cmyk;
+    static char *kwlist[] = { "c", "m", "y", "k", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOOO:set", kwlist,
+				     &c, &m, &y, &k, &a))
+        return NULL;
+
+    if (!c && !y && !m && !k && !a) {
+	PyErr_SetString(PyExc_TypeError, "must provide c,m,y,k or a arguments");
+	return NULL;
+    }
+
+    if ((c && (!m || !y || !k)) ||
+        (m && (!c || !y || !k)) ||
+        (y && (!c || !m || !k)) ||
+        (k && (!c || !m || !y))) {
+	PyErr_SetString(PyExc_TypeError, "must provide all 4 c,m,y,k arguments");
+	return NULL;
+    }
+
+    cmyk = pyg_boxed_get(self, GimpCMYK);
+    tmpcmyk = *cmyk;
+
+#define SET_MEMBER(m)	G_STMT_START {				\
+    if (PyInt_Check(m))						\
+	tmpcmyk.m = (double) PyInt_AS_LONG(m) / 255.0;		\
+    else if (PyFloat_Check(m))					\
+        tmpcmyk.m = PyFloat_AS_DOUBLE(m);			\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return NULL;						\
+    }								\
+} G_STMT_END
+
+    if (c) {
+	SET_MEMBER(c);
+	SET_MEMBER(y);
+	SET_MEMBER(m);
+	SET_MEMBER(k);
+    }
+
+    if (a)
+	SET_MEMBER(a);
+
+#undef SET_MEMBER
+
+    *cmyk = tmpcmyk;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+cmyk_set_alpha(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *py_a;
+    GimpCMYK *cmyk;
+    static char *kwlist[] = { "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "O:set_alpha", kwlist,
+				     &py_a))
+        return NULL;
+
+    cmyk = pyg_boxed_get(self, GimpCMYK);
+
+    if (PyInt_Check(py_a))
+	cmyk->a = (double) PyInt_AS_LONG(py_a) / 255.0;
+    else if (PyFloat_Check(py_a))
+        cmyk->a = PyFloat_AS_DOUBLE(py_a);
+    else {
+	PyErr_SetString(PyExc_TypeError, "a must be an int or a float");
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+/* __getstate__ isn't exposed */
+static PyObject *
+cmyk_getstate(PyObject *self)
+{
+    GimpCMYK *cmyk;
+
+    cmyk = pyg_boxed_get(self, GimpCMYK);
+
+    return Py_BuildValue("ddddd", cmyk->c, cmyk->m, cmyk->y, cmyk->k, cmyk->a);
+}
+
+static PyObject *
+cmyk_reduce(PyObject *self)
+{
+    return Py_BuildValue("ON", self->ob_type, cmyk_getstate(self));
+}
+
+static PyMethodDef cmyk_methods[] = {
+    { "set", (PyCFunction)cmyk_set, METH_VARARGS|METH_KEYWORDS },
+    { "set_alpha", (PyCFunction)cmyk_set_alpha, METH_VARARGS|METH_KEYWORDS },
+    { "__reduce__", (PyCFunction)cmyk_reduce, METH_NOARGS },
+    { NULL, NULL, 0 }
+};
+
+#define MEMBER_ACCESSOR(m) \
+static PyObject *							\
+cmyk_get_ ## m(PyObject *self, void *closure)				\
+{									\
+    return PyFloat_FromDouble(pyg_boxed_get(self, GimpCMYK)->m);	\
+}									\
+static int								\
+cmyk_set_ ## m(PyObject *self, PyObject *value, void *closure)		\
+{									\
+    GimpCMYK *cmyk = pyg_boxed_get(self, GimpCMYK);			\
+    if (value == NULL) {						\
+	PyErr_SetString(PyExc_TypeError, "cannot delete value");	\
+	return -1;							\
+    }									\
+    else if (PyInt_Check(value))					\
+	cmyk->m = (double) PyInt_AS_LONG(value) / 255.0;		\
+    else if (PyFloat_Check(value))					\
+        cmyk->m = PyFloat_AS_DOUBLE(value);				\
+    else {								\
+	PyErr_SetString(PyExc_TypeError, "type mismatch");		\
+	return -1;							\
+    }									\
+    return 0;								\
+}
+
+MEMBER_ACCESSOR(c);
+MEMBER_ACCESSOR(m);
+MEMBER_ACCESSOR(y);
+MEMBER_ACCESSOR(k);
+MEMBER_ACCESSOR(a);
+
+#undef MEMBER_ACCESSOR
+
+static PyGetSetDef cmyk_getsets[] = {
+    { "c", (getter)cmyk_get_c, (setter)cmyk_set_c },
+    { "m", (getter)cmyk_get_m, (setter)cmyk_set_m },
+    { "y", (getter)cmyk_get_y, (setter)cmyk_set_y },
+    { "k", (getter)cmyk_get_k, (setter)cmyk_set_k },
+    { "a", (getter)cmyk_get_a, (setter)cmyk_set_a },
+    { "cyan", (getter)cmyk_get_c, (setter)cmyk_set_c },
+    { "magenta", (getter)cmyk_get_m, (setter)cmyk_set_m },
+    { "yellow", (getter)cmyk_get_y, (setter)cmyk_set_y },
+    { "black", (getter)cmyk_get_k, (setter)cmyk_set_k },
+    { "alpha", (getter)cmyk_get_a, (setter)cmyk_set_a },
+    { NULL, (getter)0, (setter)0 },
+};
+
+static Py_ssize_t
+cmyk_length(PyObject *self)
+{
+    return 5;
+}
+
+static PyObject *
+cmyk_getitem(PyObject *self, Py_ssize_t pos)
+{
+    GimpCMYK *cmyk;
+    double val;
+
+    if (pos < 0)
+        pos += 5;
+
+    if (pos < 0 || pos >= 5) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return NULL;
+    }
+
+    cmyk = pyg_boxed_get(self, GimpCMYK);
+
+    switch (pos) {
+    case 0: val = cmyk->c; break;
+    case 1: val = cmyk->m; break;
+    case 2: val = cmyk->y; break;
+    case 3: val = cmyk->k; break;
+    case 4: val = cmyk->a; break;
+    default:
+        g_assert_not_reached();
+        return NULL;
+    }
+
+    return PyInt_FromLong(ROUND(CLAMP(val, 0.0, 1.0) * 255.0));
+}
+
+static int
+cmyk_setitem(PyObject *self, Py_ssize_t pos, PyObject *value)
+{
+    if (pos < 0)
+        pos += 5;
+
+    if (pos < 0 || pos >= 5) {
+	PyErr_SetString(PyExc_IndexError, "index out of range");
+	return -1;
+    }
+
+    switch (pos) {
+    case 0: return cmyk_set_c(self, value, NULL);
+    case 1: return cmyk_set_m(self, value, NULL);
+    case 2: return cmyk_set_y(self, value, NULL);
+    case 3: return cmyk_set_k(self, value, NULL);
+    case 4: return cmyk_set_a(self, value, NULL);
+    default:
+        g_assert_not_reached();
+        return -1;
+    }
+}
+
+static PyObject *
+cmyk_slice(PyObject *self, Py_ssize_t start, Py_ssize_t end)
+{
+    PyTupleObject *ret;
+    Py_ssize_t i;
+
+    if (start < 0)
+        start = 0;
+    if (end > 5)
+        end = 5;
+    if (end < start)
+        end = start;
+
+    ret = (PyTupleObject *)PyTuple_New(end - start);
+    if (ret == NULL)
+        return NULL;
+
+    for (i = start; i < end; i++)
+        PyTuple_SET_ITEM(ret, i - start, cmyk_getitem(self, i));
+
+    return (PyObject *)ret;
+}
+
+static PySequenceMethods cmyk_as_sequence = {
+    cmyk_length,
+    (binaryfunc)0,
+    0,
+    cmyk_getitem,
+    cmyk_slice,
+    cmyk_setitem,
+    0,
+    (objobjproc)0,
+};
+
+static PyObject *
+cmyk_subscript(PyObject *self, PyObject *item)
+{
+    if (PyInt_Check(item)) {
+        long i = PyInt_AS_LONG(item);
+        return cmyk_getitem(self, i);
+    } else if (PyLong_Check(item)) {
+        long i = PyLong_AsLong(item);
+        if (i == -1 && PyErr_Occurred())
+            return NULL;
+        return cmyk_getitem(self, i);
+    } else if (PySlice_Check(item)) {
+        Py_ssize_t start, stop, step, slicelength, cur, i;
+        PyObject *ret;
+
+        if (PySlice_GetIndicesEx((PySliceObject*)item, 5,
+                                 &start, &stop, &step, &slicelength) < 0)
+            return NULL;
+
+        if (slicelength <= 0) {
+            return PyTuple_New(0);
+        } else {
+            ret = PyTuple_New(slicelength);
+            if (!ret)
+                return NULL;
+
+            for (cur = start, i = 0; i < slicelength; cur += step, i++)
+                PyTuple_SET_ITEM(ret, i, cmyk_getitem(self, cur));
+
+            return ret;
+        }
+    } else if (PyString_Check(item)) {
+        char *s = PyString_AsString(item);
+
+        if (g_ascii_strcasecmp(s, "c") == 0 ||
+            g_ascii_strcasecmp(s, "cyan") == 0)
+            return cmyk_get_c(self, NULL);
+        else if (g_ascii_strcasecmp(s, "m")  == 0 ||
+                 g_ascii_strcasecmp(s, "magenta") == 0)
+            return cmyk_get_m(self, NULL);
+        else if (g_ascii_strcasecmp(s, "y")  == 0 ||
+                 g_ascii_strcasecmp(s, "yellow") == 0)
+            return cmyk_get_y(self, NULL);
+        else if (g_ascii_strcasecmp(s, "k")  == 0 ||
+                 g_ascii_strcasecmp(s, "black") == 0)
+            return cmyk_get_k(self, NULL);
+        else if (g_ascii_strcasecmp(s, "a")  == 0 ||
+                 g_ascii_strcasecmp(s, "alpha") == 0)
+            return cmyk_get_a(self, NULL);
+        else {
+            PyErr_SetObject(PyExc_KeyError, item);
+            return NULL;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+                        "indices must be integers");
+        return NULL;
+    }
+}
+
+static PyMappingMethods cmyk_as_mapping = {
+    cmyk_length,
+    (binaryfunc)cmyk_subscript,
+    (objobjargproc)0
+};
+
+static long
+cmyk_hash(PyObject *self)
+{
+    long ret = -1;
+
+    PyObject *temp = cmyk_getstate(self);
+    if (temp != NULL) {
+	ret = PyObject_Hash(temp);
+	Py_DECREF(temp);
+    }
+
+    return ret;
+}
+
+static PyObject *
+cmyk_richcompare(PyObject *self, PyObject *other, int op)
+{
+    GimpCMYK *c1, *c2;
+    PyObject *ret;
+
+    if (!pygimp_cmyk_check(other)) {
+	PyErr_Format(PyExc_TypeError,
+		     "can't compare %s to %s",
+		     self->ob_type->tp_name, other->ob_type->tp_name);
+	return NULL;
+    }
+
+    if (op != Py_EQ && op != Py_NE) {
+	PyErr_SetString(PyExc_TypeError,
+			"can't compare color values using <, <=, >, >=");
+	return NULL;
+    }
+
+    c1 = pyg_boxed_get(self, GimpCMYK);
+    c2 = pyg_boxed_get(other, GimpCMYK);
+
+    if ((c1->c == c2->c && c1->m == c2->m && c1->y == c2->y && c1->k == c2->k && c1->a == c2->a) == (op == Py_EQ))
+	ret = Py_True;
+    else
+	ret = Py_False;
+
+    Py_INCREF(ret);
+    return ret;
+}
+
+static PyObject *
+cmyk_pretty_print(PyObject *self, gboolean inexact)
+{
+    GimpCMYK *cmyk;
+    PyObject *ret = NULL;
+    PyObject *c_f = NULL, *m_f = NULL, *y_f = NULL, *k_f = NULL, *a_f = NULL;
+    PyObject *c = NULL, *m = NULL, *y = NULL, *k = NULL, *a = NULL;
+    reprfunc repr;
+    const char *prefix;
+
+    if (inexact) {
+	repr = PyObject_Str;
+	prefix = "CMYK ";
+    } else {
+	repr = PyObject_Repr;
+	prefix = self->ob_type->tp_name;
+    }
+
+    cmyk = pyg_boxed_get(self, GimpCMYK);
+
+    if ((c_f = PyFloat_FromDouble(cmyk->c)) == NULL) goto cleanup;
+    if ((m_f = PyFloat_FromDouble(cmyk->m)) == NULL) goto cleanup;
+    if ((y_f = PyFloat_FromDouble(cmyk->y)) == NULL) goto cleanup;
+    if ((k_f = PyFloat_FromDouble(cmyk->k)) == NULL) goto cleanup;
+    if ((a_f = PyFloat_FromDouble(cmyk->a)) == NULL) goto cleanup;
+
+    if ((c = repr(c_f)) == NULL) goto cleanup;
+    if ((m = repr(m_f)) == NULL) goto cleanup;
+    if ((y = repr(y_f)) == NULL) goto cleanup;
+    if ((k = repr(k_f)) == NULL) goto cleanup;
+    if ((a = repr(a_f)) == NULL) goto cleanup;
+
+    ret = PyString_FromFormat("%s(%s, %s, %s, %s, %s)",
+			      prefix,
+			      PyString_AsString(c),
+			      PyString_AsString(m),
+			      PyString_AsString(y),
+			      PyString_AsString(k),
+			      PyString_AsString(a));
+
+cleanup:
+    Py_XDECREF(c); Py_XDECREF(m); Py_XDECREF(y); Py_XDECREF(k); Py_XDECREF(a);
+    Py_XDECREF(c_f); Py_XDECREF(m_f); Py_XDECREF(y_f); Py_XDECREF(k_f); Py_XDECREF(a_f);
+
+    return ret;
+}
+
+static PyObject *
+cmyk_repr(PyObject *self)
+{
+    return cmyk_pretty_print(self, FALSE);
+}
+
+static PyObject *
+cmyk_str(PyObject *self)
+{
+    return cmyk_pretty_print(self, TRUE);
+}
+
+static int
+cmyk_init(PyGBoxed *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *c, *m, *y, *k, *a = NULL;
+    GimpCMYK cmyk;
+    static char *kwlist[] = { "c", "m", "y", "k", "a", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+	                             "OOOO|O:set", kwlist,
+				     &c, &m, &y, &k, &a))
+        return -1;
+
+#define SET_MEMBER(m)	G_STMT_START {				\
+    if (PyInt_Check(m))						\
+	cmyk.m = (double) PyInt_AS_LONG(m) / 255.0;		\
+    else if (PyFloat_Check(m))					\
+        cmyk.m = PyFloat_AS_DOUBLE(m);				\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return -1;						\
+    }								\
+} G_STMT_END
+
+    SET_MEMBER(c);
+    SET_MEMBER(m);
+    SET_MEMBER(y);
+    SET_MEMBER(k);
+
+    if (a)
+	SET_MEMBER(a);
+    else
+        cmyk.a = 1.0;
+
+#undef SET_MEMBER
+
+    self->gtype = GIMP_TYPE_CMYK;
+    self->free_on_dealloc = TRUE;
+    self->boxed = g_boxed_copy(GIMP_TYPE_CMYK, &cmyk);
+
+    return 0;
+}
+
+PyTypeObject PyGimpCMYK_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,					/* ob_size */
+    "gimpcolor.CMYK",			/* tp_name */
+    sizeof(PyGBoxed),			/* tp_basicsize */
+    0,					/* tp_itemsize */
+    /* methods */
+    (destructor)0,			/* tp_dealloc */
+    (printfunc)0,			/* tp_print */
+    (getattrfunc)0,			/* tp_getattr */
+    (setattrfunc)0,			/* tp_setattr */
+    (cmpfunc)0,				/* tp_compare */
+    (reprfunc)cmyk_repr,		/* tp_repr */
+    (PyNumberMethods*)0,		/* tp_as_number */
+    &cmyk_as_sequence,			/* tp_as_sequence */
+    &cmyk_as_mapping,			/* tp_as_mapping */
+    (hashfunc)cmyk_hash,		/* tp_hash */
+    (ternaryfunc)0,			/* tp_call */
+    (reprfunc)cmyk_str,			/* tp_repr */
+    (getattrofunc)0,			/* tp_getattro */
+    (setattrofunc)0,			/* tp_setattro */
+    (PyBufferProcs*)0,			/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,			/* tp_flags */
+    NULL, 				/* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)cmyk_richcompare,	/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    cmyk_methods,			/* tp_methods */
+    0,					/* tp_members */
+    cmyk_getsets,			/* tp_getset */
+    NULL,				/* tp_base */
+    NULL,				/* tp_dict */
+    (descrgetfunc)0,			/* tp_descr_get */
+    (descrsetfunc)0,			/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)cmyk_init,		/* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+    (freefunc)0,			/* tp_free */
+    (inquiry)0				/* tp_is_gc */
+};
+
+PyObject *
+pygimp_cmyk_new(const GimpCMYK *cmyk)
+{
+    return pyg_boxed_new(GIMP_TYPE_CMYK, (gpointer)cmyk, TRUE, TRUE);
+}
+
+int
+pygimp_rgb_from_pyobject(PyObject *object, GimpRGB *color)
+{
+    g_return_val_if_fail(color != NULL, FALSE);
+
+    if (pygimp_rgb_check(object)) {
+        *color = *pyg_boxed_get(object, GimpRGB);
+        return 1;
+    } else if (PyString_Check(object)) {
+        if (gimp_rgb_parse_css (color, PyString_AsString(object), -1)) {
+            return 1;
+        } else {
+            PyErr_SetString(PyExc_TypeError, "unable to parse color string");
+            return 0;
+        }
+    } else if (PySequence_Check(object)) {
+        PyObject *r, *g, *b, *a = NULL;
+
+        if (!PyArg_ParseTuple(object, "OOO|O", &r, &g, &b, &a))
+            return 0;
+
+#define SET_MEMBER(m)	G_STMT_START {				\
+    if (PyInt_Check(m))						\
+        color->m = (double) PyInt_AS_LONG(m) / 255.0;		\
+    else if (PyFloat_Check(m))					\
+        color->m = PyFloat_AS_DOUBLE(m);			\
+    else {							\
+	PyErr_SetString(PyExc_TypeError,			\
+			#m " must be an int or a float");	\
+	return 0;						\
+    }								\
+} G_STMT_END
+
+        SET_MEMBER(r);
+        SET_MEMBER(g);
+        SET_MEMBER(b);
+
+        if (a)
+            SET_MEMBER(a);
+        else
+            color->a = 1.0;
+
+        gimp_rgb_clamp(color);
+
+        return 1;
+    }
+
+    PyErr_SetString(PyExc_TypeError, "could not convert to GimpRGB");
+    return 0;
+}
diff --git a/plug-ins/pygimp/pygimp-display.c b/plug-ins/pygimp/pygimp-display.c
new file mode 100644
index 0000000..cf138d3
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-display.c
@@ -0,0 +1,140 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "pygimp.h"
+
+static PyMethodDef disp_methods[] = {
+    {NULL,	NULL}		/* sentinel */
+};
+
+static PyObject *
+disp_get_ID(PyGimpDisplay *self, void *closure)
+{
+    return PyInt_FromLong(self->ID);
+}
+
+static PyGetSetDef disp_getsets[] = {
+    { "ID", (getter)disp_get_ID, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+/* ---------- */
+
+
+PyObject *
+pygimp_display_new(gint32 ID)
+{
+    PyGimpDisplay *self;
+
+    if (!gimp_display_is_valid(ID)) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    self = PyObject_NEW(PyGimpDisplay, &PyGimpDisplay_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    self->ID = ID;
+
+    return (PyObject *)self;
+}
+
+static void
+disp_dealloc(PyGimpDisplay *self)
+{
+    PyObject_DEL(self);
+}
+
+static PyObject *
+disp_repr(PyGimpDisplay *self)
+{
+    PyObject *s;
+
+    s = PyString_FromString("<display>");
+
+    return s;
+}
+
+static int
+disp_init(PyGimpDisplay *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+
+    if (!PyArg_ParseTuple(args, "O!:gimp.Display.__init__",
+			  &PyGimpImage_Type, &img))
+	return -1;
+
+    self->ID = gimp_display_new(img->ID);
+
+    if (self->ID < 0) {
+	PyErr_Format(pygimp_error, "could not create display for image (ID %d)",
+		     img->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+PyTypeObject PyGimpDisplay_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Display",                     /* tp_name */
+    sizeof(PyGimpDisplay),              /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)disp_dealloc,           /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)disp_repr,                /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    disp_methods,			/* tp_methods */
+    0,					/* tp_members */
+    disp_getsets,			/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)disp_init,                /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
diff --git a/plug-ins/pygimp/pygimp-drawable.c b/plug-ins/pygimp/pygimp-drawable.c
new file mode 100644
index 0000000..9134d9b
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-drawable.c
@@ -0,0 +1,2459 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#define GIMP_DISABLE_DEPRECATION_WARNINGS
+#include "pygimp.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+#include <glib-object.h>
+
+#include <gegl.h>
+
+static void
+ensure_drawable(PyGimpDrawable *self)
+{
+    if (!self->drawable)
+	self->drawable = gimp_drawable_get(self->ID);
+}
+
+static PyObject *
+drw_flush(PyGimpDrawable *self)
+{
+    ensure_drawable(self);
+
+    gimp_drawable_flush(self->drawable);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+drw_update(PyGimpDrawable *self, PyObject *args)
+{
+    int x, y;
+    unsigned int w, h;
+
+    if (!PyArg_ParseTuple(args, "iiii:update", &x, &y, &w, &h))
+	return NULL;
+
+    if (!gimp_drawable_update(self->ID, x, y, w, h)) {
+	PyErr_Format(pygimp_error,
+		     "could not update drawable (ID %d): "
+		     "x=%d, y=%d, w=%d, h=%d",
+		     self->ID, x, y, (int)w, (int)h);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+drw_merge_shadow(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    gboolean undo = FALSE;
+
+    static char *kwlist[] = { "undo", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:merge_shadow", kwlist,
+				     &undo))
+	return NULL;
+
+    if (!gimp_drawable_merge_shadow(self->ID, undo)) {
+	PyErr_Format(pygimp_error,
+		     "could not merge the shadow buffer on drawable (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_free_shadow(PyGimpDrawable *self)
+{
+    if (!gimp_drawable_free_shadow(self->ID)) {
+	PyErr_Format(pygimp_error, "could not free shadow tiles on drawable (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_fill(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int fill = GIMP_FILL_FOREGROUND;
+
+    static char *kwlist[] = { "fill", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:fill", kwlist, &fill))
+	return NULL;
+
+    if (!gimp_drawable_fill(self->ID, fill)) {
+	PyErr_Format(pygimp_error,
+		     "could not fill drawable (ID %d) with fill mode %d",
+		     self->ID, fill);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+drw_get_tile(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    GimpTile *t;
+    int shadow, row, col;
+
+    static char *kwlist[] = { "shadow", "row", "col", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii:get_tile", kwlist,
+				     &shadow, &row, &col))
+	return NULL;
+
+    ensure_drawable(self);
+
+    if(row < 0 || row >= self->drawable->ntile_rows ||
+       col < 0 || col >= self->drawable->ntile_cols) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    t = gimp_drawable_get_tile(self->drawable, shadow, row, col);
+    return pygimp_tile_new(t, self);
+}
+
+static PyObject *
+drw_get_tile2(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    GimpTile *t;
+    int shadow, x, y, row, col;
+
+    static char *kwlist[] = { "shadow", "x", "y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii:get_tile2", kwlist,
+				     &shadow, &x ,&y))
+	return NULL;
+
+    ensure_drawable(self);
+    if(x < 0 || x >= self->drawable->width ||
+       y < 0 || y >= self->drawable->height) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    col = x / gimp_tile_width ();
+    row = y / gimp_tile_height ();
+
+    t = gimp_drawable_get_tile(self->drawable, shadow, row, col);
+    return pygimp_tile_new(t, self);
+}
+
+static PyObject *
+drw_get_pixel_rgn(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int x, y, width, height, dirty = 1, shadow = 0;
+
+    static char *kwlist[] = { "x", "y", "width", "height", "dirty", "shadow",
+			      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "iiii|ii:get_pixel_rgn", kwlist,
+				     &x, &y, &width, &height, &dirty, &shadow))
+	return NULL;
+
+    ensure_drawable(self);
+
+    return pygimp_pixel_rgn_new(self, x, y, width, height, dirty, shadow);
+}
+
+static PyObject *
+drw_offset(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int wrap_around;
+    GimpOffsetType fill_type;
+    int offset_x, offset_y;
+
+    static char *kwlist[] = { "wrap_around", "fill_type",
+			      "offset_x", "offset_y",
+			      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iiii:offset", kwlist,
+				     &wrap_around, &fill_type,
+				     &offset_x, &offset_y))
+	return NULL;
+
+    if (!gimp_drawable_offset(self->ID, wrap_around, fill_type,
+			      offset_x, offset_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not offset drawable (ID %d) by x: %d, y: %d",
+		     self->ID, offset_x, offset_y);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_parasite_find(PyGimpDrawable *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_find", &name))
+	return NULL;
+
+    return pygimp_parasite_new(gimp_item_get_parasite(self->ID, name));
+}
+
+static PyObject *
+drw_parasite_attach(PyGimpDrawable *self, PyObject *args)
+{
+    PyGimpParasite *parasite;
+
+    if (!PyArg_ParseTuple(args, "O!:parasite_attach", &PyGimpParasite_Type,
+			  &parasite))
+	return NULL;
+
+    if (!gimp_item_attach_parasite(self->ID, parasite->para)) {
+	PyErr_Format(pygimp_error,
+		     "could not attach parasite '%s' on drawable (ID %d)",
+		     gimp_parasite_name(parasite->para), self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_attach_new_parasite(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    char         *name;
+    int           flags, size;
+    guint8       *data;
+    GimpParasite *parasite;
+    gboolean      success;
+
+    static char *kwlist[] = { "name", "flags", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "sis#:attach_new_parasite", kwlist,
+				     &name, &flags, &data, &size))
+	return NULL;
+
+    parasite = gimp_parasite_new (name,
+                                  flags, size + 1, data);
+    success = gimp_item_attach_parasite (self->ID, parasite);
+    gimp_parasite_free (parasite);
+
+    if (!success) {
+	PyErr_Format(pygimp_error,
+		     "could not attach new parasite '%s' to drawable (ID %d)",
+		     name, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_parasite_detach(PyGimpDrawable *self, PyObject *args)
+{
+    char *name;
+    if (!PyArg_ParseTuple(args, "s:detach_parasite", &name))
+	return NULL;
+
+    if (!gimp_item_detach_parasite(self->ID, name)) {
+	PyErr_Format(pygimp_error,
+		     "could not detach parasite '%s' from drawable (ID %d)",
+		     name, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+drw_parasite_list(PyGimpDrawable *self)
+{
+    gint num_parasites;
+    gchar **parasites;
+    PyObject *ret;
+    gint i;
+
+    parasites = gimp_item_get_parasite_list(self->ID, &num_parasites);
+
+    ret = PyTuple_New(num_parasites);
+
+    for (i = 0; i < num_parasites; i++)
+        PyTuple_SetItem(ret, i, PyString_FromString(parasites[i]));
+
+    g_strfreev(parasites);
+    return ret;
+}
+
+static PyObject *
+drw_get_pixel(PyGimpDrawable *self, PyObject *args)
+{
+    int x, y;
+    int num_channels, i;
+    guint8 *pixel;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, "(ii):get_pixel", &x, &y)) {
+	PyErr_Clear();
+	if (!PyArg_ParseTuple(args, "ii:get_pixel", &x, &y))
+	    return NULL;
+    }
+
+    pixel = gimp_drawable_get_pixel(self->ID, x, y, &num_channels);
+
+    if (!pixel) {
+	PyErr_Format(pygimp_error,
+		     "could not get pixel (%d, %d) on drawable (ID %d)",
+		     x, y, self->ID);
+	return NULL;
+    }
+
+    ret = PyTuple_New(num_channels);
+
+    for (i = 0; i < num_channels; i++)
+	PyTuple_SetItem(ret, i, PyInt_FromLong(pixel[i]));
+
+    g_free(pixel);
+
+    return ret;
+}
+
+static PyObject *
+drw_set_pixel(PyGimpDrawable *self, PyObject *args)
+{
+    int x, y;
+    int num_channels, i, val;
+    guint8 *pixel;
+    PyObject *seq, *item;
+    gboolean is_string, error = TRUE;
+
+    if (!PyArg_ParseTuple(args, "(ii)O:set_pixel", &x, &y, &seq)) {
+	PyErr_Clear();
+	if (!PyArg_ParseTuple(args, "iiO:set_pixel", &x, &y, &seq))
+	    return NULL;
+    }
+
+    if (!PyString_Check(seq)) {
+	if (!PySequence_Check(seq)) {
+	    PyErr_SetString(PyExc_TypeError,
+			    "pixel values must be a sequence");
+	    return NULL;
+	}
+
+	is_string = FALSE;
+
+	num_channels = PySequence_Length(seq);
+	pixel = g_new(guint8, num_channels);
+
+	for (i = 0; i < num_channels; i++) {
+	    item = PySequence_GetItem(seq, i);
+
+	    if (!PyInt_Check(item)) {
+		PyErr_SetString(PyExc_TypeError,
+				"pixel values must be a sequence of ints");
+		goto out;
+	    }
+
+	    val = PyInt_AsLong(item);
+
+	    if (val < 0 || val > 255) {
+		PyErr_SetString(PyExc_TypeError,
+				"pixel values must be between 0 and 255");
+		goto out;
+	    }
+
+	    pixel[i] = val;
+	}
+    } else {
+	is_string = TRUE;
+
+	num_channels = PyString_Size(seq);
+	pixel = (guint8 *)PyString_AsString(seq);
+    }
+
+    error = !gimp_drawable_set_pixel(self->ID, x, y, num_channels, pixel);
+
+    if (error)
+	PyErr_Format(pygimp_error,
+		     "could not set %d-element pixel (%d, %d) on "
+		     "drawable (ID %d)",
+		     num_channels, x, y, self->ID);
+
+out:
+    if (!is_string)
+	g_free(pixel);
+
+    if (!error) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    } else
+	return NULL;
+}
+
+static PyObject *
+drw_mask_intersect(PyGimpDrawable *self)
+{
+    int x, y, width, height;
+
+    if (!gimp_drawable_mask_intersect(self->ID, &x, &y, &width, &height)) {
+	PyErr_Format(pygimp_error,
+		     "could not get selection bounds of drawable (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    return Py_BuildValue("(iiii)", x, y, width, height);
+}
+
+static PyObject *
+transform_result(PyGimpDrawable *self, gint32 id, const char *err_desc)
+{
+    if (id == self->ID) {
+	Py_INCREF(self);
+	return (PyObject *)self;
+    } else if (id != -1) {
+	return pygimp_drawable_new(NULL, id);
+    } else {
+	PyErr_Format(pygimp_error, "could not %s drawable (ID %d)",
+		     err_desc, self->ID);
+	return NULL;
+    }
+}
+
+static PyObject *
+drw_transform_flip(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1;
+    int transform_direction, interpolation, recursion_level = 3;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddddii|iii:transform_flip", kwlist,
+				     &x0, &y0, &x1, &y1, &transform_direction,
+				     &interpolation, &supersample,
+				     &recursion_level, &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_flip (self->ID, x0, y0, x1, y1);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "flip");
+}
+
+static PyObject *
+drw_transform_flip_simple(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int flip_type;
+    gboolean auto_center, clip_result = FALSE;
+    double axis;
+    gint32 id;
+
+    static char *kwlist[] = { "flip_type", "auto_center", "axis",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "iid|i:transform_flip_simple", kwlist,
+				     &flip_type, &auto_center, &axis,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_flip_simple (self->ID, flip_type,
+                                          auto_center, axis);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "flip");
+}
+
+static PyObject *
+drw_transform_flip_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", "interpolate",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddd|ii:transform_flip_default", kwlist,
+				     &x0, &y0, &x1, &y1, &interpolate,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_flip (self->ID, x0, y0, x1, y1);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "flip");
+}
+
+static PyObject *
+drw_transform_perspective(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1, x2, y2, x3, y3;
+    int transform_direction, interpolation, recursion_level = 3;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", "x2", "y2", "x3", "y3",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddddddddii|iii:transform_perspective",
+				     kwlist,
+				     &x0, &y0, &x1, &y1, &x2, &y2, &x3, &y3,
+				     &transform_direction, &interpolation,
+				     &supersample, &recursion_level,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_perspective (self->ID,
+                                          x0, y0, x1, y1, x2, y2, x3, y3);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply perspective transform to");
+}
+
+static PyObject *
+drw_transform_perspective_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1, x2, y2, x3, y3;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", "x2", "y2", "x3", "y3",
+			      "interpolate", "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddddddd|ii:transform_perspective_default",
+				     kwlist,
+				     &x0, &y0, &x1, &y1, &x2, &y2, &x3, &y3,
+				     &interpolate, &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_perspective (self->ID,
+                                          x0, y0, x1, y1, x2, y2, x3, y3);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply perspective transform to");
+}
+
+static PyObject *
+drw_transform_rotate(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double angle;
+    gboolean auto_center, supersample = FALSE, clip_result = FALSE;
+    int center_x, center_y, transform_direction, interpolation,
+	recursion_level = 3;
+    gint32 id;
+
+    static char *kwlist[] = { "angle", "auto_center", "center_x", "center_y",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "diiiii|iii:transform_rotate", kwlist,
+				     &angle, &auto_center, &center_x, &center_y,
+				     &transform_direction, &interpolation,
+				     &supersample, &recursion_level,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_rotate (self->ID, angle, auto_center,
+                                     center_x, center_y);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "rotate");
+}
+
+static PyObject *
+drw_transform_rotate_simple(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int rotate_type, center_x, center_y;
+    gboolean auto_center, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "rotate_type", "auto_center",
+			      "center_x", "center_y",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "iiii|i:transform_rotate_simple", kwlist,
+				     &rotate_type, &auto_center,
+				     &center_x, &center_y,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_resize (clip_result);
+
+   id = gimp_item_transform_rotate_simple (self->ID, rotate_type,
+                                           auto_center,
+                                           center_x, center_y);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "rotate");
+}
+
+static PyObject *
+drw_transform_rotate_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double angle;
+    gboolean auto_center, interpolate = FALSE, clip_result = FALSE;
+    int center_x, center_y;
+    gint32 id;
+
+    static char *kwlist[] = { "angle", "auto_center", "center_x", "center_y",
+			      "interpolate", "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddd|ii:transform_rotate_default", kwlist,
+				     &angle, &auto_center, &center_x, &center_y,
+				     &interpolate, &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_rotate (self->ID, angle, auto_center,
+                                     center_x, center_y);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "rotate");
+}
+
+static PyObject *
+drw_transform_scale(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1;
+    int transform_direction, interpolation, recursion_level = 3;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddddii|iii:transform_scale", kwlist,
+				     &x0, &y0, &x1, &y1, &transform_direction,
+				     &interpolation, &supersample,
+				     &recursion_level, &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_scale (self->ID, x0, y0, x1, y1);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "scale");
+}
+
+static PyObject *
+drw_transform_scale_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", "interpolate",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddd|ii:transform_scale_default", kwlist,
+				     &x0, &y0, &x1, &y1, &interpolate,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_scale (self->ID, x0, y0, x1, y1);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "scale");
+}
+
+static PyObject *
+drw_transform_shear(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int shear_type, transform_direction, interpolation, recursion_level = 3;
+    double magnitude;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "shear_type", "magnitude",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "idii|iii:transform_shear", kwlist,
+				     &shear_type, &magnitude,
+				     &transform_direction, &interpolation,
+				     &supersample, &recursion_level,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_shear (self->ID, shear_type, magnitude);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "shear");
+}
+
+static PyObject *
+drw_transform_shear_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    int shear_type;
+    double magnitude;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "shear_type", "magnitude", "interpolate",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "id|ii:transform_shear_default", kwlist,
+				     &shear_type, &magnitude, &interpolate,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_shear (self->ID, shear_type, magnitude);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "shear");
+}
+
+static PyObject *
+drw_transform_2d(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double source_x, source_y, scale_x, scale_y, angle, dest_x, dest_y;
+    int transform_direction, interpolation, recursion_level = 3;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "source_x", "source_y", "scale_x", "scale_y",
+			      "angle", "dest_x", "dest_y",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddddddii|iii:transform_2d", kwlist,
+				     &source_x, &source_y, &scale_x, &scale_y,
+				     &angle, &dest_x, &dest_y,
+				     &transform_direction, &interpolation,
+				     &supersample, &recursion_level,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_2d (self->ID, source_x, source_y,
+                                 scale_x, scale_y, angle, dest_x, dest_y);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply 2d transform to");
+}
+
+static PyObject *
+drw_transform_2d_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double source_x, source_y, scale_x, scale_y, angle, dest_x, dest_y;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "source_x", "source_y", "scale_x", "scale_y",
+			      "angle", "dest_x", "dest_y", "interpolate",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddddddd|ii:transform_2d_default", kwlist,
+				     &source_x, &source_y, &scale_x, &scale_y,
+				     &angle, &dest_x, &dest_y, &interpolate,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_2d (self->ID, source_x, source_y,
+                                 scale_x, scale_y, angle, dest_x, dest_y);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply 2d transform to");
+}
+
+static PyObject *
+drw_transform_matrix(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double coeff_0_0, coeff_0_1, coeff_0_2,
+	   coeff_1_0, coeff_1_1, coeff_1_2,
+	   coeff_2_0, coeff_2_1, coeff_2_2;
+    int transform_direction, interpolation, recursion_level = 3;
+    gboolean supersample = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "coeff_0_0", "coeff_0_1", "coeff_0_2",
+			      "coeff_1_0", "coeff_1_1", "coeff_1_2",
+			      "coeff_2_0", "coeff_2_1", "coeff_2_2",
+			      "transform_direction", "interpolation",
+			      "supersample", "recursion_level",
+			      "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "dddddddddii|iii:transform_matrix", kwlist,
+				     &coeff_0_0, &coeff_0_1, &coeff_0_2,
+				     &coeff_1_0, &coeff_1_1, &coeff_1_2,
+				     &coeff_2_0, &coeff_2_1, &coeff_2_2,
+				     &transform_direction, &interpolation,
+				     &supersample, &recursion_level,
+				     &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    gimp_context_set_transform_direction (transform_direction);
+    gimp_context_set_interpolation (interpolation);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_matrix (self->ID,
+                                     coeff_0_0, coeff_0_1, coeff_0_2,
+                                     coeff_1_0, coeff_1_1, coeff_1_2,
+                                     coeff_2_0, coeff_2_1, coeff_2_2);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply 2d matrix transform to");
+}
+
+static PyObject *
+drw_transform_matrix_default(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    double coeff_0_0, coeff_0_1, coeff_0_2,
+	   coeff_1_0, coeff_1_1, coeff_1_2,
+	   coeff_2_0, coeff_2_1, coeff_2_2;
+    gboolean interpolate = FALSE, clip_result = FALSE;
+    gint32 id;
+
+    static char *kwlist[] = { "coeff_0_0", "coeff_0_1", "coeff_0_2",
+			      "coeff_1_0", "coeff_1_1", "coeff_1_2",
+			      "coeff_2_0", "coeff_2_1", "coeff_2_2",
+			      "interpolate", "clip_result", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ddddddddd|ii:transform_matrix_default",
+				     kwlist,
+				     &coeff_0_0, &coeff_0_1, &coeff_0_2,
+				     &coeff_1_0, &coeff_1_1, &coeff_1_2,
+				     &coeff_2_0, &coeff_2_1, &coeff_2_2,
+				     &interpolate, &clip_result))
+	return NULL;
+
+    gimp_context_push ();
+    if (! interpolate)
+        gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE);
+    gimp_context_set_transform_resize (clip_result);
+
+    id = gimp_item_transform_matrix (self->ID,
+                                     coeff_0_0, coeff_0_1, coeff_0_2,
+                                     coeff_1_0, coeff_1_1, coeff_1_2,
+                                     coeff_2_0, coeff_2_1, coeff_2_2);
+
+    gimp_context_pop ();
+
+    return transform_result(self, id, "apply 2d matrix transform to");
+}
+
+static PyObject *
+drw_get_data(PyGimpDrawable *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "format", NULL };
+    gchar  *format = "RGBA float";
+    const Babl *bbl_format;
+    void *output_buffer;
+    GeglBuffer *buffer;
+    int bpp;
+    Py_ssize_t size;
+    PyObject *buffer_data, *ret;
+    PyObject *array_module;
+    PyObject *array_type;
+    char array_data_type;
+
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "|s:get_data",
+                                      kwlist, &format
+                                      ))
+        return NULL;
+
+    if (g_str_has_suffix (format, "double")) {
+        array_data_type = 'd';
+    } else if (g_str_has_suffix (format, "float")) {
+        array_data_type = 'f';
+    }
+     else if (g_str_has_suffix (format, "u16")) {
+        array_data_type = 'H';
+    } else if (g_str_has_suffix (format, "u8")) {
+        array_data_type = 'B';
+    } else {
+        PyErr_Warn (PyExc_Warning,
+            "Could not find appropriate data format - returning raw bytes");
+        array_data_type = 'B';
+    }
+
+    bbl_format = babl_format (format);
+    bpp = babl_format_get_bytes_per_pixel (bbl_format);
+    ensure_drawable(self);
+    buffer = gimp_drawable_get_buffer (self->ID);
+    size = bpp * self->drawable->width * self->drawable->height;
+    output_buffer = g_malloc ((gsize) size);
+    if (output_buffer == NULL) {
+        return PyErr_NoMemory();
+    }
+    gegl_buffer_get (buffer,
+                     GEGL_RECTANGLE (0, 0, self->drawable->width, self->drawable->height),
+                     1.0,
+                     bbl_format,
+                     output_buffer,
+                     GEGL_AUTO_ROWSTRIDE,
+                     GEGL_ABYSS_NONE);
+    buffer_data = PyString_FromStringAndSize (output_buffer, size);
+
+    array_module = PyImport_ImportModule ("array");
+    if (!array_module) {
+        PyErr_SetString (pygimp_error, "could not import array module");
+        return NULL;
+    }
+
+    array_type = PyObject_GetAttrString (array_module, "array");
+    Py_DECREF(array_module);
+    if (!array_type) {
+        PyErr_SetString (pygimp_error, "could not get array.array type");
+        return NULL;
+     }
+
+    ret = PyObject_CallFunction (array_type, "cO", array_data_type, buffer_data);
+    if (!ret) {
+        PyErr_SetString (pygimp_error, "could not create array object");
+        return NULL;
+     }
+
+    Py_DECREF (buffer_data);
+    g_free (output_buffer);
+
+    return ret;
+}
+
+
+/* for inclusion with the methods of layer and channel objects */
+static PyMethodDef drw_methods[] = {
+    {"flush",	(PyCFunction)drw_flush,	METH_NOARGS},
+    {"update",	(PyCFunction)drw_update,	METH_VARARGS},
+    {"merge_shadow",	(PyCFunction)drw_merge_shadow,	METH_VARARGS | METH_KEYWORDS},
+    {"free_shadow", (PyCFunction)drw_free_shadow, METH_NOARGS},
+    {"fill",	(PyCFunction)drw_fill,	METH_VARARGS | METH_KEYWORDS},
+    {"get_tile",	(PyCFunction)drw_get_tile,	METH_VARARGS | METH_KEYWORDS},
+    {"get_tile2",	(PyCFunction)drw_get_tile2,	METH_VARARGS | METH_KEYWORDS},
+    {"get_pixel_rgn", (PyCFunction)drw_get_pixel_rgn, METH_VARARGS | METH_KEYWORDS},
+    {"get_data", (PyCFunction)drw_get_data, METH_VARARGS | METH_KEYWORDS,
+     "Takes a BABL format string, returns a Python array.array object"},
+    {"offset", (PyCFunction)drw_offset, METH_VARARGS | METH_KEYWORDS},
+    {"parasite_find",       (PyCFunction)drw_parasite_find, METH_VARARGS},
+    {"parasite_attach",     (PyCFunction)drw_parasite_attach, METH_VARARGS},
+    {"attach_new_parasite",(PyCFunction)drw_attach_new_parasite,METH_VARARGS | METH_KEYWORDS},
+    {"parasite_detach",     (PyCFunction)drw_parasite_detach, METH_VARARGS},
+    {"parasite_list",     (PyCFunction)drw_parasite_list, METH_VARARGS},
+    {"get_pixel",	(PyCFunction)drw_get_pixel, METH_VARARGS},
+    {"set_pixel",	(PyCFunction)drw_set_pixel, METH_VARARGS},
+    {"mask_intersect",	(PyCFunction)drw_mask_intersect, METH_NOARGS},
+    {"transform_flip",	(PyCFunction)drw_transform_flip, METH_VARARGS | METH_KEYWORDS},
+    {"transform_flip_simple",	(PyCFunction)drw_transform_flip_simple, METH_VARARGS | METH_KEYWORDS},
+    {"transform_flip_default",	(PyCFunction)drw_transform_flip_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_perspective",	(PyCFunction)drw_transform_perspective, METH_VARARGS | METH_KEYWORDS},
+    {"transform_perspective_default",	(PyCFunction)drw_transform_perspective_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_rotate",	(PyCFunction)drw_transform_rotate, METH_VARARGS | METH_KEYWORDS},
+    {"transform_rotate_simple",	(PyCFunction)drw_transform_rotate_simple, METH_VARARGS | METH_KEYWORDS},
+    {"transform_rotate_default",	(PyCFunction)drw_transform_rotate_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_scale",	(PyCFunction)drw_transform_scale, METH_VARARGS | METH_KEYWORDS},
+    {"transform_scale_default",	(PyCFunction)drw_transform_scale_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_shear",	(PyCFunction)drw_transform_shear, METH_VARARGS | METH_KEYWORDS},
+    {"transform_shear_default",	(PyCFunction)drw_transform_shear_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_2d",	(PyCFunction)drw_transform_2d, METH_VARARGS | METH_KEYWORDS},
+    {"transform_2d_default",	(PyCFunction)drw_transform_2d_default, METH_VARARGS | METH_KEYWORDS},
+    {"transform_matrix",	(PyCFunction)drw_transform_matrix, METH_VARARGS | METH_KEYWORDS},
+    {"transform_matrix_default",	(PyCFunction)drw_transform_matrix_default, METH_VARARGS | METH_KEYWORDS},
+    {NULL, NULL, 0}
+};
+
+static PyObject *
+drw_get_ID(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(self->ID);
+}
+
+static PyObject *
+drw_get_name(PyGimpDrawable *self, void *closure)
+{
+    return PyString_FromString(gimp_item_get_name(self->ID));
+}
+
+static int
+drw_set_name(PyGimpDrawable *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete name");
+        return -1;
+    }
+
+    if (!PyString_Check(value) && !PyUnicode_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_name(self->ID, PyString_AsString(value));
+
+    return 0;
+}
+
+static PyObject *
+drw_get_bpp(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_drawable_bpp(self->ID));
+}
+
+static PyObject *
+drw_get_has_alpha(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_drawable_has_alpha(self->ID));
+}
+
+static PyObject *
+drw_get_height(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_drawable_height(self->ID));
+}
+
+static PyObject *
+drw_get_image(PyGimpDrawable *self, void *closure)
+{
+    return pygimp_image_new(gimp_item_get_image(self->ID));
+}
+
+static PyObject *
+drw_get_is_rgb(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_drawable_is_rgb(self->ID));
+}
+
+static PyObject *
+drw_get_is_gray(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_drawable_is_gray(self->ID));
+}
+
+static PyObject *
+drw_get_is_indexed(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_drawable_is_indexed(self->ID));
+}
+
+static PyObject *
+drw_get_is_layer_mask(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_item_is_layer_mask(self->ID));
+}
+
+static PyObject *
+drw_get_mask_bounds(PyGimpDrawable *self, void *closure)
+{
+    gint x1, y1, x2, y2;
+
+    gimp_drawable_mask_bounds(self->ID, &x1, &y1, &x2, &y2);
+    return Py_BuildValue("(iiii)", x1, y1, x2, y2);
+}
+
+static PyObject *
+drw_get_mask_intersect(PyGimpDrawable *self, void *closure)
+{
+    gint x, y, w, h;
+
+    if(!gimp_drawable_mask_intersect(self->ID, &x, &y, &w, &h))
+      return Py_BuildValue("");
+    return Py_BuildValue("(iiii)", x, y, w, h);
+}
+
+static PyObject *
+drw_get_offsets(PyGimpDrawable *self, void *closure)
+{
+    gint x, y;
+
+    gimp_drawable_offsets(self->ID, &x, &y);
+
+    return Py_BuildValue("(ii)", x, y);
+}
+
+static PyObject *
+drw_get_type(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_drawable_type(self->ID));
+}
+
+static PyObject *
+drw_get_type_with_alpha(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_drawable_type_with_alpha(self->ID));
+}
+
+static PyObject *
+drw_get_width(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_drawable_width(self->ID));
+}
+
+static PyObject *
+drw_get_linked(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_item_get_linked(self->ID));
+}
+
+static int
+drw_set_linked(PyGimpDrawable *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete linked");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    gimp_item_set_linked(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+drw_get_tattoo(PyGimpDrawable *self, void *closure)
+{
+    return PyInt_FromLong(gimp_item_get_tattoo(self->ID));
+}
+
+static int
+drw_set_tattoo(PyGimpDrawable *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete tattoo");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_tattoo(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+drw_get_visible(PyGimpDrawable *self, void *closure)
+{
+    return PyBool_FromLong(gimp_item_get_visible(self->ID));
+}
+
+static int
+drw_set_visible(PyGimpDrawable *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete visible");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_visible(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static  PyGetSetDef drw_getsets[] = {
+    { "ID", (getter)drw_get_ID, (setter)0 },
+    { "name", (getter)drw_get_name, (setter)drw_set_name },
+    { "bpp", (getter)drw_get_bpp, (setter)0 },
+    { "has_alpha", (getter)drw_get_has_alpha, (setter)0 },
+    { "height", (getter)drw_get_height, (setter)0 },
+    { "image", (getter)drw_get_image, (setter)0 },
+    { "is_rgb", (getter)drw_get_is_rgb, (setter)0 },
+    { "is_gray", (getter)drw_get_is_gray, (setter)0 },
+    { "is_grey", (getter)drw_get_is_gray, (setter)0 },
+    { "is_indexed", (getter)drw_get_is_indexed, (setter)0 },
+    { "is_layer_mask", (getter)drw_get_is_layer_mask, (setter)0 },
+    { "mask_bounds", (getter)drw_get_mask_bounds, (setter)0 },
+    { "mask_intersect", (getter)drw_get_mask_intersect, (setter)0 },
+    { "offsets", (getter)drw_get_offsets, (setter)0 },
+    { "type", (getter)drw_get_type, (setter)0 },
+    { "type_with_alpha", (getter)drw_get_type_with_alpha, (setter)0 },
+    { "width", (getter)drw_get_width, (setter)0 },
+    { "linked", (getter)drw_get_linked, (setter)drw_set_linked },
+    { "tattoo", (getter)drw_get_tattoo, (setter)drw_set_tattoo },
+    { "visible", (getter)drw_get_visible, (setter)drw_set_visible },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static void
+drw_dealloc(PyGimpDrawable *self)
+{
+    if (self->drawable)
+	gimp_drawable_detach(self->drawable);
+
+    PyObject_DEL(self);
+}
+
+static PyObject *
+drw_repr(PyGimpDrawable *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.Drawable '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+drw_cmp(PyGimpDrawable *self, PyGimpDrawable *other)
+{
+    if (self->ID == other->ID)
+	return 0;
+    if (self->ID > other->ID)
+	return -1;
+    return 1;
+}
+
+PyTypeObject PyGimpDrawable_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Drawable",                    /* tp_name */
+    sizeof(PyGimpDrawable),             /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)drw_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)drw_cmp,                   /* tp_compare */
+    (reprfunc)drw_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    drw_methods,			/* tp_methods */
+    0,					/* tp_members */
+    drw_getsets,			/* tp_getset */
+    &PyGimpItem_Type,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)0,                        /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+
+PyObject *
+pygimp_drawable_new(GimpDrawable *drawable, gint32 ID)
+{
+    PyObject *self;
+
+    if (drawable != NULL)
+    ID = drawable->drawable_id;
+
+    if (!gimp_item_is_valid(ID)) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    /* create the appropriate object type */
+    if (gimp_item_is_layer(ID))
+	self = pygimp_layer_new(ID);
+    else
+	self = pygimp_channel_new(ID);
+
+    if (self == NULL)
+	return NULL;
+
+    if (PyObject_TypeCheck(self, &PyGimpDrawable_Type))
+    ((PyGimpDrawable *)self)->drawable = drawable;
+
+    return self;
+}
+
+/* End of code for Drawable objects */
+/* -------------------------------------------------------- */
+
+
+static PyObject *
+lay_copy(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    int nreturn_vals;
+    GimpParam *return_vals;
+    gboolean add_alpha = FALSE;
+    gint32 id = -1;
+
+    static char *kwlist[] = { "add_alpha", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:copy", kwlist,
+				     &add_alpha))
+	return NULL;
+
+    return_vals = gimp_run_procedure("gimp-layer-copy",
+				     &nreturn_vals,
+				     GIMP_PDB_LAYER, self->ID,
+				     GIMP_PDB_INT32, add_alpha,
+				     GIMP_PDB_END);
+
+    if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
+	id = return_vals[1].data.d_layer;
+    else
+	PyErr_Format(pygimp_error,
+		     "could not create new layer copy from layer (ID %d)",
+		     self->ID);
+
+    gimp_destroy_params(return_vals, nreturn_vals);
+
+    return id != -1 ? pygimp_layer_new(id) : NULL;
+}
+
+
+static PyObject *
+lay_add_alpha(PyGimpLayer *self)
+{
+    if (!gimp_layer_add_alpha(self->ID)) {
+	PyErr_Format(pygimp_error, "could not add alpha to layer (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+lay_add_mask(PyGimpLayer *self, PyObject *args)
+{
+    PyGimpChannel *mask;
+
+    if (!PyArg_ParseTuple(args, "O!:add_mask", &PyGimpChannel_Type, &mask))
+	return NULL;
+
+    if (!gimp_layer_add_mask(self->ID, mask->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not add mask (ID %d) to layer (ID %d)",
+		     mask->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+lay_create_mask(PyGimpLayer *self, PyObject *args)
+{
+    int type;
+    gint32 id;
+
+    if (!PyArg_ParseTuple(args, "i:create_mask", &type))
+	return NULL;
+
+    id = gimp_layer_create_mask(self->ID, type);
+
+    if (id == -1) {
+	PyErr_Format(pygimp_error,
+		     "could not create mask of type %d on layer (ID %d)",
+		     type, self->ID);
+	return NULL;
+    }
+
+    return pygimp_channel_new(id);
+}
+
+static PyObject *
+lay_remove_mask(PyGimpLayer *self, PyObject *args)
+{
+    int mode;
+
+    if (!PyArg_ParseTuple(args, "i:remove_mask", &mode))
+	return NULL;
+
+    if (!gimp_layer_remove_mask(self->ID, mode)) {
+	PyErr_Format(pygimp_error,
+		     "could not remove mask from layer (ID %d) with mode %d",
+		      self->ID, mode);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+lay_resize(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    unsigned int new_h, new_w;
+    int offs_x = 0, offs_y = 0;
+
+    static char *kwlist[] = { "width", "height", "offset_x", "offset_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii:resize", kwlist,
+				     &new_w, &new_h, &offs_x, &offs_y))
+	return NULL;
+
+    if (!gimp_layer_resize(self->ID, new_w, new_h, offs_x, offs_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not resize layer (ID %d) to size %dx%d "
+		     "(offset %d, %d)",
+		     self->ID, new_w, new_h, offs_x, offs_y);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+lay_resize_to_image_size(PyGimpLayer *self)
+{
+    if (!gimp_layer_resize_to_image_size(self->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not resize layer (ID %d) to image size",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+lay_scale(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    int new_width, new_height;
+    int interpolation = -1;
+    gboolean local_origin = FALSE;
+
+    static char *kwlist[] = { "width", "height", "local_origin",
+                              "interpolation", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii:scale", kwlist,
+				     &new_width, &new_height,
+                                     &local_origin, &interpolation))
+	return NULL;
+
+    if (interpolation != -1) {
+        gimp_context_push();
+        gimp_context_set_interpolation(interpolation);
+    }
+
+    if (!gimp_layer_scale(self->ID, new_width, new_height, local_origin)) {
+        PyErr_Format(pygimp_error,
+                     "could not scale layer (ID %d) to size %dx%d",
+                     self->ID, new_width, new_height);
+        if (interpolation != -1) {
+            gimp_context_pop();
+        }
+        return NULL;
+    }
+
+    if (interpolation != -1) {
+        gimp_context_pop();
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+lay_translate(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    int offs_x, offs_y;
+
+    static char *kwlist[] = { "offset_x", "offset_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:translate", kwlist,
+				     &offs_x, &offs_y))
+	return NULL;
+
+    if (!gimp_item_transform_translate(self->ID, offs_x, offs_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not translate layer (ID %d) to offset %d, %d",
+		     self->ID, offs_x, offs_y);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+lay_set_offsets(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    int offs_x, offs_y;
+
+    static char *kwlist[] = { "offset_x", "offset_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:set_offsets", kwlist,
+				     &offs_x, &offs_y))
+	return NULL;
+
+    if (!gimp_layer_set_offsets(self->ID, offs_x, offs_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not set offset %d, %d on layer (ID %d)",
+		     offs_x, offs_y, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef lay_methods[] = {
+    {"copy",	(PyCFunction)lay_copy,	METH_VARARGS | METH_KEYWORDS},
+    {"add_alpha",	(PyCFunction)lay_add_alpha,	METH_NOARGS},
+    {"add_mask",        (PyCFunction)lay_add_mask,      METH_VARARGS},
+    {"create_mask",	(PyCFunction)lay_create_mask,	METH_VARARGS},
+    {"remove_mask",     (PyCFunction)lay_remove_mask,   METH_VARARGS},
+    {"resize",	(PyCFunction)lay_resize,	METH_VARARGS | METH_KEYWORDS},
+    {"resize_to_image_size",	(PyCFunction)lay_resize_to_image_size,	METH_NOARGS},
+    {"scale",	(PyCFunction)lay_scale,	METH_VARARGS | METH_KEYWORDS},
+    {"translate",	(PyCFunction)lay_translate,	METH_VARARGS | METH_KEYWORDS},
+    {"set_offsets",	(PyCFunction)lay_set_offsets,	METH_VARARGS | METH_KEYWORDS},
+    {NULL,		NULL}		/* sentinel */
+};
+
+static PyObject *
+lay_get_is_floating_sel(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_layer_is_floating_sel(self->ID));
+}
+
+static PyObject *
+lay_get_mask(PyGimpLayer *self, void *closure)
+{
+    gint32 id = gimp_layer_get_mask(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_channel_new(id);
+}
+
+static PyObject *
+lay_get_apply_mask(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_layer_get_apply_mask(self->ID));
+}
+
+static int
+lay_set_apply_mask(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete apply_mask");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_apply_mask(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error,
+		     "could not set layer mask on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_edit_mask(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_layer_get_edit_mask(self->ID));
+}
+
+static int
+lay_set_edit_mask(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete edit_mask");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_edit_mask(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error,
+		     "could not set layer mask active on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_mode(PyGimpLayer *self, void *closure)
+{
+    return PyInt_FromLong(gimp_layer_get_mode(self->ID));
+}
+
+static int
+lay_set_mode(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete mode");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_mode(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error, "could not set mode on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_opacity(PyGimpLayer *self, void *closure)
+{
+    return PyFloat_FromDouble(gimp_layer_get_opacity(self->ID));
+}
+
+static int
+lay_set_opacity(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete opacity");
+        return -1;
+    }
+
+    if (!PyFloat_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_opacity(self->ID, PyFloat_AsDouble(value))) {
+	PyErr_Format(pygimp_error, "could not set opacity on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_lock_alpha(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_layer_get_lock_alpha(self->ID));
+}
+
+static int
+lay_set_lock_alpha(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+			"cannot delete lock_alpha");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_lock_alpha(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error,
+	             "could not set lock alpha setting on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_show_mask(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_layer_get_show_mask(self->ID));
+}
+
+static int
+lay_set_show_mask(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete show_mask");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_layer_set_show_mask(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error,
+	             "could not set mask visibility on layer (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+lay_get_preserve_trans(PyGimpLayer *self, void *closure)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use lock_alpha attribute") < 0)
+	return NULL;
+
+    return lay_get_lock_alpha(self, closure);
+}
+
+static int
+lay_set_preserve_trans(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use lock_alpha attribute") < 0)
+	return -1;
+
+    return lay_set_lock_alpha(self, value, closure);
+}
+
+static PyGetSetDef lay_getsets[] = {
+    { "is_floating_sel", (getter)lay_get_is_floating_sel, (setter)0 },
+    { "mask", (getter)lay_get_mask, (setter)0 },
+    { "apply_mask", (getter)lay_get_apply_mask, (setter)lay_set_apply_mask },
+    { "edit_mask", (getter)lay_get_edit_mask, (setter)lay_set_edit_mask },
+    { "mode", (getter)lay_get_mode, (setter)lay_set_mode },
+    { "opacity", (getter)lay_get_opacity, (setter)lay_set_opacity },
+    { "lock_alpha", (getter)lay_get_lock_alpha, (setter)lay_set_lock_alpha },
+    { "show_mask", (getter)lay_get_show_mask, (setter)lay_set_show_mask },
+    { "preserve_trans", (getter)lay_get_preserve_trans,
+      (setter)lay_set_preserve_trans },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static PyObject *
+lay_repr(PyGimpLayer *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.Layer '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+lay_init(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    char *name;
+    unsigned int width, height;
+    GimpImageType type = GIMP_RGB_IMAGE;
+    double opacity = 100.0;
+    GimpLayerMode mode = GIMP_LAYER_MODE_NORMAL;
+
+
+    if (!PyArg_ParseTuple(args, "O!sii|idi:gimp.Layer.__init__",
+			  &PyGimpImage_Type, &img, &name, &width, &height,
+			  &type, &opacity, &mode))
+	return -1;
+
+    self->ID = gimp_layer_new(img->ID, name, width, height,
+			      type, opacity, mode);
+
+    self->drawable = NULL;
+
+    if (self->ID < 0) {
+	PyErr_Format(pygimp_error,
+		     "could not create %dx%d layer '%s' of type %d on "
+		     "image (ID %d)",
+		     width, height, name, type, img->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+PyTypeObject PyGimpLayer_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Layer",                       /* tp_name */
+    sizeof(PyGimpLayer),                /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)drw_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)drw_cmp,                   /* tp_compare */
+    (reprfunc)lay_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    lay_methods,			/* tp_methods */
+    0,					/* tp_members */
+    lay_getsets,			/* tp_getset */
+    &PyGimpDrawable_Type,		/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)lay_init,                 /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+PyObject *
+pygimp_layer_new(gint32 ID)
+{
+    PyGimpLayer *self;
+
+    if (!gimp_item_is_valid(ID) || !gimp_item_is_layer(ID)) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+
+    if (gimp_item_is_group(ID)) {
+        self = PyObject_NEW(PyGimpGroupLayer, &PyGimpGroupLayer_Type);
+    }
+    else {
+        self = PyObject_NEW(PyGimpLayer, &PyGimpLayer_Type);
+    }
+
+    if (self == NULL)
+        return NULL;
+
+    self->ID = ID;
+    self->drawable = NULL;
+
+    return (PyObject *)self;
+}
+
+/* End of code for Layer objects */
+/* -------------------------------------------------------- */
+
+/* Since this help will primarily be seen from within
+ * GIMP's Python console, we should make it fit in that
+ * window's default size.
+ */
+
+#define GROUPLAYER_DOC ""                                \
+"gimp.GroupLayer(img, name="", opacity=100.0,   "        \
+"mode=gimp.LAYER_MODE_NORMAL)\n"                         \
+"\n"                                                     \
+" Creates a new GroupLayer object that has to be \n"     \
+"subsequently added to an image. Use Image.add_layer \n" \
+"or pdb.gimp_image_insert_layer calls to do that. \n"    \
+
+static PyMethodDef grouplay_methods[] = {
+    {NULL,              NULL}           /* sentinel */
+};
+
+static PyObject *
+grouplay_get_layers(PyGimpGroupLayer *self, void *closure)
+{
+    gint32 *layers;
+    gint n_layers, i;
+    PyObject *ret;
+
+    layers = gimp_item_get_children(self->ID, &n_layers);
+
+    ret = PyList_New(n_layers);
+
+    for (i = 0; i < n_layers; i++)
+        PyList_SetItem(ret, i, pygimp_group_layer_new(layers[i]));
+
+    g_free(layers);
+
+    return ret;
+}
+
+static PyGetSetDef grouplay_getsets[] = {
+    { "layers", (getter)grouplay_get_layers, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static PyObject *
+grouplay_repr(PyGimpLayer *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.GroupLayer '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+grouplay_init(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    char *name = "Layer Group";
+    GimpImageType type = GIMP_RGB_IMAGE;
+    double opacity = 100.0;
+    GimpLayerMode mode = GIMP_LAYER_MODE_NORMAL;
+
+
+    if (!PyArg_ParseTuple(args, "O!|sdi:gimp.Layer.__init__",
+                          &PyGimpImage_Type, &img, &name,
+                          &opacity, &mode))
+        return -1;
+
+    self->ID = gimp_layer_group_new(img->ID);
+
+    self->drawable = NULL;
+
+    if (self->ID < 0) {
+        PyErr_Format(pygimp_error,
+                     "could not create layer group '%s' of type %d on "
+                     "image (ID %d)",
+                     name, type, img->ID);
+        return -1;
+    }
+
+    gimp_layer_set_opacity(self->ID, opacity);
+    gimp_layer_set_mode(self->ID, mode);
+
+    gimp_item_set_name(self->ID, name);
+
+    return 0;
+}
+
+PyTypeObject PyGimpGroupLayer_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.GroupLayer",                  /* tp_name */
+    sizeof(PyGimpGroupLayer),           /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)drw_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)drw_cmp,                   /* tp_compare */
+    (reprfunc)grouplay_repr,            /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    GROUPLAYER_DOC, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    grouplay_methods,                   /* tp_methods */
+    0,                                  /* tp_members */
+    grouplay_getsets,                   /* tp_getset */
+    &PyGimpLayer_Type,                  /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)grouplay_init,            /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
+
+PyObject *
+pygimp_group_layer_new(gint32 ID)
+{
+    PyGimpGroupLayer *self;
+
+    if (!gimp_item_is_valid(ID) || !gimp_item_is_layer(ID)) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    if (!gimp_item_is_group(ID)) {
+        return pygimp_layer_new(ID);
+    }
+
+    self = PyObject_NEW(PyGimpGroupLayer, &PyGimpGroupLayer_Type);
+
+    if (self == NULL)
+        return NULL;
+
+    self->ID = ID;
+    self->drawable = NULL;
+
+    return (PyObject *)self;
+}
+
+/* End of code for GroupLayer objects */
+/* -------------------------------------------------------- */
+
+
+static PyObject *
+chn_copy(PyGimpChannel *self)
+{
+    gint32 id;
+
+    id = gimp_channel_copy(self->ID);
+
+    if (id == -1) {
+	PyErr_Format(pygimp_error,
+		     "could not create new channel copy from channel (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    return pygimp_channel_new(id);
+}
+
+static PyObject *
+chn_combine_masks(PyGimpChannel *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpChannel *channel2;
+    GimpChannelOps operation;
+    int offx = 0, offy = 0;
+
+    static char *kwlist[] = { "channel", "operation", "offset_x", "offset_y",
+			      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!i|ii:combine_masks",
+				     kwlist,
+				     &PyGimpChannel_Type, &channel2,
+				     &operation, &offx, &offy))
+	return NULL;
+
+    if (!gimp_channel_combine_masks(self->ID, channel2->ID, operation,
+				    offx, offy)) {
+	PyErr_Format(pygimp_error,
+		     "could not combine masks with channels (ID %d and ID %d) "
+		     "with operation %d, offset %d, %d",
+		     self->ID, channel2->ID, operation, offx, offy);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef chn_methods[] = {
+    {"copy",	(PyCFunction)chn_copy,	METH_NOARGS},
+    {"combine_masks",	(PyCFunction)chn_combine_masks,	METH_VARARGS},
+    {NULL,		NULL}		/* sentinel */
+};
+
+static PyObject *
+chn_get_color(PyGimpChannel *self, void *closure)
+{
+    GimpRGB rgb;
+
+    if (!gimp_channel_get_color(self->ID, &rgb)) {
+	PyErr_Format(pygimp_error,
+		     "could not get compositing color of channel (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    return pygimp_rgb_new(&rgb);
+}
+
+static int
+chn_set_color(PyGimpChannel *self, PyObject *value, void *closure)
+{
+    guchar r, g, b;
+    GimpRGB tmprgb, *rgb;
+
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete color");
+        return -1;
+    }
+
+    if (pygimp_rgb_check(value)) {
+	rgb = pyg_boxed_get(value, GimpRGB);
+    } else if (PyTuple_Check(value) &&
+	       PyArg_ParseTuple(value, "(BBB)", &r, &g, &b)) {
+	gimp_rgb_set_uchar(&tmprgb, r, g, b);
+	rgb = &tmprgb;
+    } else {
+	PyErr_Clear();
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_channel_set_color(self->ID, rgb)) {
+	PyErr_Format(pygimp_error,
+		     "could not set compositing color on channel (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+chn_get_opacity(PyGimpLayer *self, void *closure)
+{
+    return PyFloat_FromDouble(gimp_channel_get_opacity(self->ID));
+}
+
+static int
+chn_set_opacity(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete opacity");
+        return -1;
+    }
+
+    if (!PyFloat_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_channel_set_opacity(self->ID, PyFloat_AsDouble(value))) {
+	PyErr_Format(pygimp_error,
+		     "could not set opacity on channel (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+chn_get_show_masked(PyGimpLayer *self, void *closure)
+{
+    return PyBool_FromLong(gimp_channel_get_show_masked(self->ID));
+}
+
+static int
+chn_set_show_masked(PyGimpLayer *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete show_masked");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_channel_set_show_masked(self->ID, PyInt_AsLong(value))) {
+	PyErr_Format(pygimp_error,
+		     "could not set composite method on channel (ID %d)",
+		     self->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+static PyGetSetDef chn_getsets[] = {
+    { "color", (getter)chn_get_color, (setter)chn_set_color },
+    { "colour", (getter)chn_get_color, (setter)chn_set_color },
+    { "opacity", (getter)chn_get_opacity, (setter)chn_set_opacity },
+    { "show_masked", (getter)chn_get_show_masked, (setter)chn_set_show_masked},
+    { NULL, (getter)0, (setter)0 }
+};
+
+static PyObject *
+chn_repr(PyGimpChannel *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.Channel '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+chn_init(PyGimpChannel *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    PyObject *color;
+    char *name;
+    unsigned int width, height, r, g, b;
+    double opacity;
+    GimpRGB tmprgb, *rgb;
+
+    if (!PyArg_ParseTuple(args, "O!siidO:gimp.Channel.__init__",
+			  &PyGimpImage_Type, &img, &name, &width,
+			  &height, &opacity, &color))
+	return -1;
+
+    if (pygimp_rgb_check(color)) {
+	rgb = pyg_boxed_get(color, GimpRGB);
+    } else if (PyTuple_Check(color) &&
+	       PyArg_ParseTuple(color, "(BBB)", &r, &g, &b)) {
+	gimp_rgb_set_uchar(&tmprgb, r, g, b);
+	rgb = &tmprgb;
+    } else {
+	PyErr_Clear();
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    self->ID = gimp_channel_new(img->ID, name, width, height, opacity, rgb);
+
+    self->drawable = NULL;
+
+    if (self->ID < 0) {
+	PyErr_Format(pygimp_error,
+		     "could not create %dx%d channel '%s' on image (ID %d)",
+		     width, height, name, img->ID);
+	return -1;
+    }
+
+    return 0;
+}
+
+PyTypeObject PyGimpChannel_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Channel",                     /* tp_name */
+    sizeof(PyGimpChannel),              /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)drw_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)drw_cmp,                   /* tp_compare */
+    (reprfunc)chn_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    chn_methods,			/* tp_methods */
+    0,					/* tp_members */
+    chn_getsets,			/* tp_getset */
+    &PyGimpDrawable_Type,		/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)chn_init,                 /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+PyObject *
+pygimp_channel_new(gint32 ID)
+{
+    PyGimpChannel *self;
+
+    if (!gimp_item_is_valid(ID) || !gimp_item_is_channel(ID)) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    self = PyObject_NEW(PyGimpChannel, &PyGimpChannel_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    self->ID = ID;
+    self->drawable = NULL;
+
+    return (PyObject *)self;
+}
diff --git a/plug-ins/pygimp/pygimp-image.c b/plug-ins/pygimp/pygimp-image.c
new file mode 100644
index 0000000..d8c0cbf
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-image.c
@@ -0,0 +1,1564 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "pygimp.h"
+
+static PyObject *
+img_add_channel(PyGimpImage *self, PyObject *args)
+{
+    PyGimpChannel *chn;
+    int pos = -1;
+
+    if (!PyArg_ParseTuple(args, "O!|i:add_channel",
+	                        &PyGimpChannel_Type, &chn, &pos))
+	return NULL;
+
+    if (!gimp_image_insert_channel(self->ID, chn->ID, -1, pos)) {
+	PyErr_Format(pygimp_error,
+		     "could not add channel (ID %d) to image (ID %d)",
+		     chn->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_insert_channel(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpChannel *chn;
+    PyGimpChannel *parent = NULL;
+    int pos = -1;
+
+    static char *kwlist[] = { "channel", "parent", "position", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|O!i:insert_channel", kwlist,
+                                     &PyGimpChannel_Type, &chn,
+                                     &PyGimpChannel_Type, &parent,
+                                     &pos))
+	return NULL;
+
+    if (!gimp_image_insert_channel(self->ID,
+                                   chn->ID, parent ? parent->ID : -1, pos)) {
+	PyErr_Format(pygimp_error,
+		     "could not insert channel (ID %d) to image (ID %d)",
+		     chn->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_add_layer(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+    int pos = -1;
+
+    if (!PyArg_ParseTuple(args, "O!|i:add_layer", &PyGimpLayer_Type, &lay,
+			  &pos))
+	return NULL;
+
+    if (!gimp_image_insert_layer(self->ID, lay->ID, -1, pos)) {
+	PyErr_Format(pygimp_error,
+		     "could not add layer (ID %d) to image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_insert_layer(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpLayer *lay;
+    PyGimpLayer *parent = NULL;
+    int pos = -1;
+
+    static char *kwlist[] = { "layer", "parent", "position", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|O!i:insert_layer", kwlist,
+                                     &PyGimpLayer_Type, &lay,
+                                     &PyGimpLayer_Type, &parent,
+                                     &pos))
+	return NULL;
+
+    if (!gimp_image_insert_layer(self->ID,
+                                 lay->ID, parent ? parent->ID : -1, pos)) {
+	PyErr_Format(pygimp_error,
+		     "could not insert layer (ID %d) to image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_new_layer(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    char *layer_name;
+    int layer_id;
+    int width, height;
+    int layer_type;
+    int offs_x = 0, offs_y = 0;
+    gboolean alpha = TRUE;
+    int pos = -1;
+    double opacity = 100.0;
+    GimpLayerMode mode = GIMP_LAYER_MODE_NORMAL;
+    GimpFillType fill_mode = -1;
+
+    static char *kwlist[] = { "name", "width", "height", "offset_x", "offset_y",
+                              "alpha", "pos", "opacity", "mode", "fill_mode",
+                              NULL };
+
+    layer_name = "New Layer";
+
+    width = gimp_image_width(self->ID);
+    height = gimp_image_height(self->ID);
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|siiiiiidii:new_layer", kwlist,
+                                     &layer_name, &width, &height,
+                                     &offs_x, &offs_y, &alpha, &pos,
+                                     &opacity, &mode, &fill_mode))
+        return NULL;
+
+
+    switch (gimp_image_base_type(self->ID))  {
+        case GIMP_RGB:
+            layer_type = alpha ? GIMP_RGBA_IMAGE: GIMP_RGB_IMAGE;
+            break;
+        case GIMP_GRAY:
+            layer_type = alpha ? GIMP_GRAYA_IMAGE: GIMP_GRAY_IMAGE;
+            break;
+        case GIMP_INDEXED:
+            layer_type = alpha ? GIMP_INDEXEDA_IMAGE: GIMP_INDEXED_IMAGE;
+            break;
+        default:
+            PyErr_SetString(pygimp_error, "Unknown image base type");
+            return NULL;
+    }
+
+    if (fill_mode == -1)
+        fill_mode = alpha ? GIMP_FILL_TRANSPARENT: GIMP_FILL_BACKGROUND;
+
+
+    layer_id = gimp_layer_new(self->ID, layer_name, width, height,
+                              layer_type, opacity, mode);
+
+    if (!layer_id) {
+        PyErr_Format(pygimp_error,
+                     "could not create new layer in image (ID %d)",
+                     self->ID);
+        return NULL;
+    }
+
+    if (!gimp_drawable_fill(layer_id, fill_mode)) {
+        gimp_item_delete(layer_id);
+        PyErr_Format(pygimp_error,
+                     "could not fill new layer with fill mode %d",
+                     fill_mode);
+        return NULL;
+    }
+
+    if (!gimp_image_insert_layer(self->ID, layer_id, -1, pos)) {
+        gimp_item_delete(layer_id);
+        PyErr_Format(pygimp_error,
+                     "could not add layer (ID %d) to image (ID %d)",
+                     layer_id, self->ID);
+        return NULL;
+    }
+
+    if (!gimp_layer_set_offsets(layer_id, offs_x, offs_y)) {
+        gimp_image_remove_layer(self->ID, layer_id);
+        PyErr_Format(pygimp_error,
+                     "could not set offset %d, %d on layer (ID %d)",
+                      offs_x, offs_y, layer_id);
+        return NULL;
+    }
+
+    return pygimp_group_layer_new(layer_id);
+}
+
+
+static PyObject *
+img_clean_all(PyGimpImage *self)
+{
+    if (!gimp_image_clean_all(self->ID)) {
+	PyErr_Format(pygimp_error, "could not clean all on image (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_disable_undo(PyGimpImage *self)
+{
+    return PyBool_FromLong(gimp_image_undo_disable(self->ID));
+}
+
+static PyObject *
+img_enable_undo(PyGimpImage *self)
+{
+    return PyBool_FromLong(gimp_image_undo_enable(self->ID));
+}
+
+static PyObject *
+img_flatten(PyGimpImage *self)
+{
+    return pygimp_group_layer_new(gimp_image_flatten(self->ID));
+}
+
+static PyObject *
+img_lower_channel(PyGimpImage *self, PyObject *args)
+{
+    PyGimpChannel *chn;
+
+    if (!PyArg_ParseTuple(args, "O!:lower_channel", &PyGimpChannel_Type, &chn))
+	return NULL;
+
+    if (!gimp_image_lower_item(self->ID, chn->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not lower channel (ID %d) on image (ID %d)",
+		     chn->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_lower_layer(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+
+    if (!PyArg_ParseTuple(args, "O!:lower_layer", &PyGimpLayer_Type, &lay))
+	return NULL;
+
+    if (!gimp_image_lower_item(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not lower layer (ID %d) on image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_lower_layer_to_bottom(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+
+    if (!PyArg_ParseTuple(args, "O!:lower_layer_to_bottom",
+			  &PyGimpLayer_Type, &lay))
+	return NULL;
+
+    if (!gimp_image_lower_item_to_bottom(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not lower layer (ID %d) to bottom on image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_merge_visible_layers(PyGimpImage *self, PyObject *args)
+{
+    gint32 id;
+    int merge;
+
+    if (!PyArg_ParseTuple(args, "i:merge_visible_layers", &merge))
+	return NULL;
+
+    id = gimp_image_merge_visible_layers(self->ID, merge);
+
+    if (id == -1) {
+	PyErr_Format(pygimp_error,
+		     "could not merge visible layers on image (ID %d) "
+		     "with merge type %d",
+		     self->ID, merge);
+	return NULL;
+    }
+
+    return pygimp_group_layer_new(id);
+}
+
+static PyObject *
+img_merge_down(PyGimpImage *self, PyObject *args)
+{
+    gint32 id;
+    PyGimpLayer *layer;
+    int merge;
+
+    if (!PyArg_ParseTuple(args, "O!i:merge_down",
+			  &PyGimpLayer_Type, &layer, &merge))
+	return NULL;
+
+    id = gimp_image_merge_down(self->ID, layer->ID, merge);
+
+    if (id == -1) {
+	PyErr_Format(pygimp_error,
+		     "could not merge down layer (ID %d) on image (ID %d) "
+		     "with merge type %d",
+		     layer->ID, self->ID, merge);
+	return NULL;
+    }
+
+    return pygimp_group_layer_new(id);
+}
+
+static PyObject *
+img_pick_correlate_layer(PyGimpImage *self, PyObject *args)
+{
+    int x,y;
+    gint32 id;
+
+    if (!PyArg_ParseTuple(args, "ii:pick_correlate_layer", &x, &y))
+	return NULL;
+
+    id = gimp_image_pick_correlate_layer(self->ID, x, y);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_group_layer_new(id);
+}
+
+static PyObject *
+img_raise_channel(PyGimpImage *self, PyObject *args)
+{
+    PyGimpChannel *chn;
+
+    if (!PyArg_ParseTuple(args, "O!:raise_channel", &PyGimpChannel_Type, &chn))
+	return NULL;
+
+    if (!gimp_image_raise_item(self->ID, chn->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not raise channel (ID %d) on image (ID %d)",
+		     chn->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_raise_layer(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+
+    if (!PyArg_ParseTuple(args, "O!:raise_layer", &PyGimpLayer_Type, &lay))
+	return NULL;
+
+    if (!gimp_image_raise_item(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not raise layer (ID %d) on image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_raise_layer_to_top(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+
+    if (!PyArg_ParseTuple(args, "O!:raise_layer_to_top",
+			  &PyGimpLayer_Type, &lay))
+	return NULL;
+
+    if (!gimp_image_raise_item_to_top(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not raise layer (ID %d) to top on image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_remove_channel(PyGimpImage *self, PyObject *args)
+{
+    PyGimpChannel *chn;
+
+    if (!PyArg_ParseTuple(args, "O!:remove_channel", &PyGimpChannel_Type, &chn))
+	return NULL;
+
+    if (!gimp_image_remove_channel(self->ID, chn->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not remove channel (ID %d) from image (ID %d)",
+		     chn->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_remove_layer(PyGimpImage *self, PyObject *args)
+{
+    PyGimpLayer *lay;
+
+    if (!PyArg_ParseTuple(args, "O!:remove_layer", &PyGimpLayer_Type, &lay))
+	return NULL;
+
+    if (!gimp_image_remove_layer(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not remove layer (ID %d) from image (ID %d)",
+		     lay->ID, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_resize(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    int new_w, new_h;
+    int offs_x = 0, offs_y = 0;
+
+    static char *kwlist[] = { "width", "height", "offset_x", "offset_y",
+			      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii:resize", kwlist,
+				     &new_w, &new_h, &offs_x, &offs_y))
+	return NULL;
+
+    if (!gimp_image_resize(self->ID, new_w, new_h, offs_x, offs_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not resize image (ID %d) to %dx%d, offset %d, %d",
+		     self->ID, new_w, new_h, offs_x, offs_y);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_resize_to_layers(PyGimpImage *self)
+{
+    if (!gimp_image_resize_to_layers(self->ID)) {
+	PyErr_Format(pygimp_error, "could not resize to layers on image "
+	                           "(ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_scale(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    int new_width, new_height;
+    int interpolation = -1;
+
+    static char *kwlist[] = { "width", "height", "interpolation", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|i:scale", kwlist,
+				     &new_width, &new_height, &interpolation))
+	return NULL;
+
+    if (interpolation != -1) {
+        gimp_context_push();
+        gimp_context_set_interpolation(interpolation);
+    }
+
+    if (!gimp_image_scale(self->ID, new_width, new_height)) {
+        PyErr_Format(pygimp_error, "could not scale image (ID %d) to %dx%d",
+                     self->ID, new_width, new_height);
+        if (interpolation != -1) {
+            gimp_context_pop();
+        }
+        return NULL;
+    }
+
+    if (interpolation != -1) {
+        gimp_context_pop();
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_crop(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    int new_w, new_h;
+    int offs_x = 0, offs_y = 0;
+
+    static char *kwlist[] = { "width", "height", "offset_x", "offset_y",
+			      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii:crop", kwlist,
+				     &new_w, &new_h, &offs_x, &offs_y))
+	return NULL;
+
+    if (!gimp_image_crop(self->ID, new_w, new_h, offs_x, offs_y)) {
+	PyErr_Format(pygimp_error,
+		     "could not crop image (ID %d) to %dx%d, offset %d, %d",
+		     self->ID, new_w, new_h, offs_x, offs_y);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_free_shadow(PyGimpImage *self)
+{
+    /* this procedure is deprecated and does absolutely nothing */
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_unset_active_channel(PyGimpImage *self)
+{
+    if (!gimp_image_unset_active_channel(self->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not unset active channel on image (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_get_component_active(PyGimpImage *self, PyObject *args)
+{
+    int comp;
+
+    if (!PyArg_ParseTuple(args, "i:get_component_active", &comp))
+	return NULL;
+
+    return PyBool_FromLong(gimp_image_get_component_active(self->ID, comp));
+}
+
+
+static PyObject *
+img_get_component_visible(PyGimpImage *self, PyObject *args)
+{
+    int comp;
+
+    if (!PyArg_ParseTuple(args, "i:get_component_visible", &comp))
+	return NULL;
+
+    return PyBool_FromLong(gimp_image_get_component_visible(self->ID, comp));
+}
+
+
+static PyObject *
+img_set_component_active(PyGimpImage *self, PyObject *args)
+{
+    int comp, a;
+
+    if (!PyArg_ParseTuple(args, "ii:set_component_active", &comp, &a))
+	return NULL;
+
+    if (!gimp_image_set_component_active(self->ID, comp, a)) {
+	PyErr_Format(pygimp_error,
+		     "could not set component (%d) %sactive on image (ID %d)",
+		     comp, a ? "" : "in", self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_set_component_visible(PyGimpImage *self, PyObject *args)
+{
+    int comp, v;
+
+    if (!PyArg_ParseTuple(args, "ii:set_component_visible", &comp, &v))
+	return NULL;
+
+    if (!gimp_image_set_component_visible(self->ID, comp, v)) {
+	PyErr_Format(pygimp_error,
+		     "could not set component (%d) %svisible on image (ID %d)",
+		     comp, v ? "" : "in", self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_parasite_find(PyGimpImage *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_find", &name))
+	return NULL;
+
+    return pygimp_parasite_new (gimp_image_get_parasite (self->ID, name));
+}
+
+static PyObject *
+img_parasite_attach(PyGimpImage *self, PyObject *args)
+{
+    PyGimpParasite *parasite;
+
+    if (!PyArg_ParseTuple(args, "O!:parasite_attach", &PyGimpParasite_Type,
+			  &parasite))
+	return NULL;
+
+    if (! gimp_image_attach_parasite (self->ID, parasite->para)) {
+	PyErr_Format(pygimp_error,
+		     "could not attach parasite '%s' to image (ID %d)",
+		     parasite->para->name, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_attach_new_parasite(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    char *name;
+    int flags, size;
+    guint8 *data;
+    GimpParasite *parasite;
+    gboolean success;
+
+    static char *kwlist[] = { "name", "flags", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "sis#:attach_new_parasite", kwlist,
+				     &name, &flags, &data, &size))
+	return NULL;
+
+    parasite = gimp_parasite_new (name, flags, size, data);
+    success = gimp_image_attach_parasite (self->ID, parasite);
+    gimp_parasite_free (parasite);
+
+    if (!success) {
+	PyErr_Format(pygimp_error,
+		     "could not attach new parasite '%s' to image (ID %d)",
+		     name, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_parasite_detach(PyGimpImage *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_detach", &name))
+	return NULL;
+
+    if (!gimp_image_detach_parasite (self->ID, name)) {
+	PyErr_Format(pygimp_error,
+		     "could not detach parasite '%s' from image (ID %d)",
+		     name, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_parasite_list(PyGimpImage *self)
+{
+    gint num_parasites;
+    gchar **parasites;
+    PyObject *ret;
+    gint i;
+
+    parasites = gimp_image_get_parasite_list (self->ID, &num_parasites);
+
+    ret = PyTuple_New(num_parasites);
+
+    for (i = 0; i < num_parasites; i++)
+        PyTuple_SetItem(ret, i, PyString_FromString(parasites[i]));
+
+    g_strfreev(parasites);
+    return ret;
+}
+
+static PyObject *
+img_get_layer_by_tattoo(PyGimpImage *self, PyObject *args)
+{
+    int tattoo;
+
+    if (!PyArg_ParseTuple(args, "i:get_layer_by_tattoo", &tattoo))
+	return NULL;
+
+    return pygimp_group_layer_new(gimp_image_get_layer_by_tattoo(self->ID, tattoo));
+}
+
+static PyObject *
+img_get_channel_by_tattoo(PyGimpImage *self, PyObject *args)
+{
+    int tattoo;
+
+    if (!PyArg_ParseTuple(args, "i:get_channel_by_tattoo", &tattoo))
+	return NULL;
+
+    return pygimp_channel_new(gimp_image_get_channel_by_tattoo(self->ID,
+							       tattoo));
+}
+
+static PyObject *
+img_add_hguide(PyGimpImage *self, PyObject *args)
+{
+    int ypos;
+
+    if (!PyArg_ParseTuple(args, "i:add_hguide", &ypos))
+	return NULL;
+
+    return PyInt_FromLong(gimp_image_add_hguide(self->ID, ypos));
+}
+
+static PyObject *
+img_add_vguide(PyGimpImage *self, PyObject *args)
+{
+    int xpos;
+
+    if (!PyArg_ParseTuple(args, "i:add_vguide", &xpos))
+	return NULL;
+
+    return PyInt_FromLong(gimp_image_add_vguide(self->ID, xpos));
+}
+
+static PyObject *
+img_delete_guide(PyGimpImage *self, PyObject *args)
+{
+    int guide;
+
+    if (!PyArg_ParseTuple(args, "i:delete_guide", &guide))
+	return NULL;
+
+    if (!gimp_image_delete_guide(self->ID, guide)) {
+	PyErr_Format(pygimp_error,
+		     "could not delete guide (ID %d) from image (ID %d)",
+		     guide, self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_find_next_guide(PyGimpImage *self, PyObject *args)
+{
+    int guide;
+
+    if (!PyArg_ParseTuple(args, "i:find_next_guide", &guide))
+	return NULL;
+
+    return PyInt_FromLong(gimp_image_find_next_guide(self->ID, guide));
+}
+
+static PyObject *
+img_get_guide_orientation(PyGimpImage *self, PyObject *args)
+{
+    int guide;
+
+    if (!PyArg_ParseTuple(args, "i:get_guide_orientation", &guide))
+	return NULL;
+
+    return PyInt_FromLong(gimp_image_get_guide_orientation(self->ID, guide));
+}
+
+static PyObject *
+img_get_guide_position(PyGimpImage *self, PyObject *args)
+{
+    int guide;
+
+    if (!PyArg_ParseTuple(args, "i:get_guide_position", &guide))
+	return NULL;
+
+    return PyInt_FromLong(gimp_image_get_guide_position(self->ID, guide));
+}
+
+static PyObject *
+img_undo_is_enabled(PyGimpImage *self)
+{
+    return PyBool_FromLong(gimp_image_undo_is_enabled(self->ID));
+}
+
+static PyObject *
+img_undo_freeze(PyGimpImage *self)
+{
+    return PyBool_FromLong(gimp_image_undo_freeze(self->ID));
+}
+
+static PyObject *
+img_undo_thaw(PyGimpImage *self)
+{
+    return PyBool_FromLong(gimp_image_undo_thaw(self->ID));
+}
+
+static PyObject *
+img_duplicate(PyGimpImage *self)
+{
+    return pygimp_image_new(gimp_image_duplicate(self->ID));
+}
+
+static PyObject *
+img_undo_group_start(PyGimpImage *self)
+{
+    if (!gimp_image_undo_group_start(self->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not start undo group on image (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_undo_group_end(PyGimpImage *self)
+{
+    if (!gimp_image_undo_group_end(self->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not end undo group on image (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef img_methods[] = {
+    {"add_channel",	(PyCFunction)img_add_channel,	METH_VARARGS},
+    {"insert_channel",	(PyCFunction)img_insert_channel,	METH_VARARGS | METH_KEYWORDS},
+    {"add_layer",	(PyCFunction)img_add_layer,	METH_VARARGS},
+    {"insert_layer",	(PyCFunction)img_insert_layer,	METH_VARARGS | METH_KEYWORDS},
+    {"new_layer",       (PyCFunction)img_new_layer, METH_VARARGS | METH_KEYWORDS},
+    {"clean_all",	(PyCFunction)img_clean_all,	METH_NOARGS},
+    {"disable_undo",	(PyCFunction)img_disable_undo,	METH_NOARGS},
+    {"enable_undo",	(PyCFunction)img_enable_undo,	METH_NOARGS},
+    {"flatten",	(PyCFunction)img_flatten,	METH_NOARGS},
+    {"lower_channel",	(PyCFunction)img_lower_channel,	METH_VARARGS},
+    {"lower_layer",	(PyCFunction)img_lower_layer,	METH_VARARGS},
+    {"lower_layer_to_bottom",	(PyCFunction)img_lower_layer_to_bottom,	METH_VARARGS},
+    {"merge_visible_layers",	(PyCFunction)img_merge_visible_layers,	METH_VARARGS},
+    {"merge_down",	(PyCFunction)img_merge_down,	METH_VARARGS},
+    {"pick_correlate_layer",	(PyCFunction)img_pick_correlate_layer,	METH_VARARGS},
+    {"raise_channel",	(PyCFunction)img_raise_channel,	METH_VARARGS},
+    {"raise_layer",	(PyCFunction)img_raise_layer,	METH_VARARGS},
+    {"raise_layer_to_top",	(PyCFunction)img_raise_layer_to_top,	METH_VARARGS},
+    {"remove_channel",	(PyCFunction)img_remove_channel,	METH_VARARGS},
+    {"remove_layer",	(PyCFunction)img_remove_layer,	METH_VARARGS},
+    {"resize",	(PyCFunction)img_resize,	METH_VARARGS | METH_KEYWORDS},
+    {"resize_to_layers",	(PyCFunction)img_resize_to_layers,	METH_NOARGS},
+    {"get_component_active",	(PyCFunction)img_get_component_active,	METH_VARARGS},
+    {"get_component_visible",	(PyCFunction)img_get_component_visible,	METH_VARARGS},
+    {"set_component_active",	(PyCFunction)img_set_component_active,	METH_VARARGS},
+    {"set_component_visible",	(PyCFunction)img_set_component_visible,	METH_VARARGS},
+    {"parasite_find",       (PyCFunction)img_parasite_find,      METH_VARARGS},
+    {"parasite_attach",     (PyCFunction)img_parasite_attach,    METH_VARARGS},
+    {"attach_new_parasite", (PyCFunction)img_attach_new_parasite,	METH_VARARGS | METH_KEYWORDS},
+    {"parasite_detach",     (PyCFunction)img_parasite_detach,    METH_VARARGS},
+    {"parasite_list", (PyCFunction)img_parasite_list, METH_NOARGS},
+    {"get_layer_by_tattoo",(PyCFunction)img_get_layer_by_tattoo,METH_VARARGS},
+    {"get_channel_by_tattoo",(PyCFunction)img_get_channel_by_tattoo,METH_VARARGS},
+    {"add_hguide", (PyCFunction)img_add_hguide, METH_VARARGS},
+    {"add_vguide", (PyCFunction)img_add_vguide, METH_VARARGS},
+    {"delete_guide", (PyCFunction)img_delete_guide, METH_VARARGS},
+    {"find_next_guide", (PyCFunction)img_find_next_guide, METH_VARARGS},
+    {"get_guide_orientation",(PyCFunction)img_get_guide_orientation,METH_VARARGS},
+    {"get_guide_position", (PyCFunction)img_get_guide_position, METH_VARARGS},
+    {"scale", (PyCFunction)img_scale, METH_VARARGS | METH_KEYWORDS},
+    {"crop", (PyCFunction)img_crop, METH_VARARGS | METH_KEYWORDS},
+    {"free_shadow", (PyCFunction)img_free_shadow, METH_NOARGS},
+    {"unset_active_channel", (PyCFunction)img_unset_active_channel, METH_NOARGS},
+    {"undo_is_enabled", (PyCFunction)img_undo_is_enabled, METH_NOARGS},
+    {"undo_freeze", (PyCFunction)img_undo_freeze, METH_NOARGS},
+    {"undo_thaw", (PyCFunction)img_undo_thaw, METH_NOARGS},
+    {"duplicate", (PyCFunction)img_duplicate, METH_NOARGS},
+    {"undo_group_start", (PyCFunction)img_undo_group_start, METH_NOARGS},
+    {"undo_group_end", (PyCFunction)img_undo_group_end, METH_NOARGS},
+    {NULL,		NULL}		/* sentinel */
+};
+
+static PyObject *
+img_get_ID(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(self->ID);
+}
+
+static PyObject *
+img_get_active_channel(PyGimpImage *self, void *closure)
+{
+    gint32 id = gimp_image_get_active_channel(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_channel_new(id);
+}
+
+static int
+img_set_active_channel(PyGimpImage *self, PyObject *value, void *closure)
+{
+    PyGimpChannel *chn;
+
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete active_channel");
+	return -1;
+    }
+
+    if (!pygimp_channel_check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    chn = (PyGimpChannel *)value;
+
+    if (!gimp_image_set_active_channel(self->ID, chn->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not set active channel (ID %d) on image (ID %d)",
+		     chn->ID, self->ID);
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_active_drawable(PyGimpImage *self, void *closure)
+{
+    gint32 id = gimp_image_get_active_drawable(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_drawable_new(NULL, id);
+}
+
+static PyObject *
+img_get_active_layer(PyGimpImage *self, void *closure)
+{
+    gint32 id = gimp_image_get_active_layer(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_group_layer_new(id);
+}
+
+static int
+img_set_active_layer(PyGimpImage *self, PyObject *value, void *closure)
+{
+    PyGimpLayer *lay;
+
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete active_layer");
+	return -1;
+    }
+
+    if (!pygimp_layer_check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    lay = (PyGimpLayer *)value;
+
+    if (!gimp_image_set_active_layer(self->ID, lay->ID)) {
+	PyErr_Format(pygimp_error,
+		     "could not set active layer (ID %d) on image (ID %d)",
+		     lay->ID, self->ID);
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_base_type(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_base_type(self->ID));
+}
+
+static PyObject *
+img_get_channels(PyGimpImage *self, void *closure)
+{
+    gint32 *channels;
+    gint n_channels, i;
+    PyObject *ret;
+
+    channels = gimp_image_get_channels(self->ID, &n_channels);
+
+    ret = PyList_New(n_channels);
+
+    for (i = 0; i < n_channels; i++)
+	PyList_SetItem(ret, i, pygimp_channel_new(channels[i]));
+
+    g_free(channels);
+
+    return ret;
+}
+
+static PyObject *
+img_get_colormap(PyGimpImage *self, void *closure)
+{
+    guchar *cmap;
+    gint n_colours;
+    PyObject *ret;
+
+    cmap = gimp_image_get_colormap(self->ID, &n_colours);
+
+    if (cmap == NULL) {
+	PyErr_Format(pygimp_error, "could not get colormap for image (ID %d)",
+		     self->ID);
+	return NULL;
+    }
+
+    ret = PyString_FromStringAndSize((char *)cmap, n_colours * 3);
+    g_free(cmap);
+
+    return ret;
+}
+
+static int
+img_set_colormap(PyGimpImage *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete colormap");
+	return -1;
+    }
+
+    if (!PyString_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_image_set_colormap(self->ID, (guchar *)PyString_AsString(value),
+                                 PyString_Size(value) / 3)) {
+	PyErr_Format(pygimp_error, "could not set colormap on image (ID %d)",
+		     self->ID);
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_is_dirty(PyGimpImage *self, void *closure)
+{
+    return PyBool_FromLong(gimp_image_is_dirty(self->ID));
+}
+
+static PyObject *
+img_get_filename(PyGimpImage *self, void *closure)
+{
+    gchar *filename;
+
+    filename = gimp_image_get_filename(self->ID);
+
+    if (filename) {
+	PyObject *ret = PyString_FromString(filename);
+	g_free(filename);
+	return ret;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static int
+img_set_filename(PyGimpImage *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete filename");
+	return -1;
+    }
+
+    if (!PyString_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_image_set_filename(self->ID, PyString_AsString(value))) {
+        PyErr_SetString(PyExc_TypeError, "could not set filename "
+	                                 "(possibly bad encoding)");
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_uri(PyGimpImage *self, void *closure)
+{
+    gchar *uri;
+
+    uri = gimp_image_get_uri(self->ID);
+
+    if (uri) {
+	PyObject *ret = PyString_FromString(uri);
+	g_free(uri);
+	return ret;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_get_floating_selection(PyGimpImage *self, void *closure)
+{
+    gint32 id;
+
+    id = gimp_image_get_floating_sel(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_layer_new(id);
+}
+
+static PyObject *
+img_get_floating_sel_attached_to(PyGimpImage *self, void *closure)
+{
+    gint32 id;
+
+    id = gimp_image_floating_sel_attached_to(self->ID);
+
+    if (id == -1) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    return pygimp_layer_new(id);
+}
+
+static PyObject *
+img_get_layers(PyGimpImage *self, void *closure)
+{
+    gint32 *layers;
+    gint n_layers, i;
+    PyObject *ret;
+
+    layers = gimp_image_get_layers(self->ID, &n_layers);
+
+    ret = PyList_New(n_layers);
+
+    for (i = 0; i < n_layers; i++)
+	PyList_SetItem(ret, i, pygimp_group_layer_new(layers[i]));
+
+    g_free(layers);
+
+    return ret;
+}
+
+static PyObject *
+img_get_name(PyGimpImage *self, void *closure)
+{
+    gchar *name;
+
+    name = gimp_image_get_name(self->ID);
+
+    if (name) {
+	PyObject *ret = PyString_FromString(name);
+	g_free(name);
+	return ret;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+img_get_selection(PyGimpImage *self, void *closure)
+{
+    return pygimp_channel_new(gimp_image_get_selection(self->ID));
+}
+
+static PyObject *
+img_get_tattoo_state(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_get_tattoo_state(self->ID));
+}
+
+static int
+img_set_tattoo_state(PyGimpImage *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete tattoo_state");
+	return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    gimp_image_set_tattoo_state(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+img_get_height(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_height(self->ID));
+}
+
+static PyObject *
+img_get_width(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_width(self->ID));
+}
+
+
+static PyObject *
+img_get_precision(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_get_precision(self->ID));
+}
+
+static PyObject *
+img_get_resolution(PyGimpImage *self, void *closure)
+{
+    double xres, yres;
+
+    gimp_image_get_resolution(self->ID, &xres, &yres);
+
+    return Py_BuildValue("(dd)", xres, yres);
+}
+
+static int
+img_set_resolution(PyGimpImage *self, PyObject *value, void *closure)
+{
+    gdouble xres, yres;
+
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete resolution");
+	return -1;
+    }
+
+    if (!PySequence_Check(value) ||
+	!PyArg_ParseTuple(value, "dd", &xres, &yres)) {
+	PyErr_Clear();
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_image_set_resolution(self->ID, xres, yres)) {
+        PyErr_SetString(PyExc_TypeError, "could not set resolution");
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_unit(PyGimpImage *self, void *closure)
+{
+    return PyInt_FromLong(gimp_image_get_unit(self->ID));
+}
+
+static int
+img_set_unit(PyGimpImage *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+	PyErr_SetString(PyExc_TypeError, "cannot delete unit");
+	return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+	PyErr_SetString(PyExc_TypeError, "type mismatch");
+	return -1;
+    }
+
+    if (!gimp_image_set_unit(self->ID, PyInt_AsLong(value))) {
+        PyErr_SetString(PyExc_TypeError, "could not set unit");
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyObject *
+img_get_vectors(PyGimpImage *self, void *closure)
+{
+    int *vectors;
+    int i, num_vectors;
+    PyObject *ret;
+
+    vectors = gimp_image_get_vectors(self->ID, &num_vectors);
+
+    ret = PyList_New(num_vectors);
+
+    for (i = 0; i < num_vectors; i++)
+        PyList_SetItem(ret, i, pygimp_vectors_new(vectors[i]));
+
+    g_free(vectors);
+
+    return ret;
+}
+
+static PyObject *
+img_get_active_vectors(PyGimpImage *self, void *closure)
+{
+    gint32 id = gimp_image_get_active_vectors(self->ID);
+
+    if (id == -1) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    return pygimp_vectors_new(id);
+}
+
+static int
+img_set_active_vectors(PyGimpImage *self, PyObject *value, void *closure)
+{
+    PyGimpVectors *vtr;
+
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete active_vectors");
+        return -1;
+    }
+
+    if (!pygimp_vectors_check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    vtr = (PyGimpVectors *)value;
+
+    if (!gimp_image_set_active_vectors(self->ID, vtr->ID)) {
+        PyErr_Format(pygimp_error,
+                     "could not set active vectors (ID %d) on image (ID %d)",
+                     vtr->ID, self->ID);
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyGetSetDef img_getsets[] = {
+    { "ID", (getter)img_get_ID, (setter)0 },
+    { "active_channel", (getter)img_get_active_channel,
+      (setter)img_set_active_channel },
+    { "active_drawable", (getter)img_get_active_drawable, (setter)0 },
+    { "active_layer", (getter)img_get_active_layer,
+      (setter)img_set_active_layer },
+    { "active_vectors", (getter)img_get_active_vectors,
+      (setter)img_set_active_vectors},
+    { "base_type", (getter)img_get_base_type, (setter)0 },
+    { "channels", (getter)img_get_channels, (setter)0 },
+    { "colormap", (getter)img_get_colormap, (setter)img_set_colormap },
+    { "dirty", (getter)img_get_is_dirty, (setter)0 },
+    { "filename", (getter)img_get_filename, (setter)img_set_filename },
+    { "floating_selection", (getter)img_get_floating_selection, (setter)0 },
+    { "floating_sel_attached_to", (getter)img_get_floating_sel_attached_to,
+      (setter)0 },
+    { "height", (getter)img_get_height, (setter)0 },
+    { "layers", (getter)img_get_layers, (setter)0 },
+    { "name", (getter)img_get_name, (setter)0 },
+    { "precision", (getter)img_get_precision, (setter)0 },
+    { "resolution", (getter)img_get_resolution, (setter)img_set_resolution },
+    { "selection", (getter)img_get_selection, (setter)0 },
+    { "tattoo_state", (getter)img_get_tattoo_state,
+      (setter)img_set_tattoo_state },
+    { "unit", (getter)img_get_unit, (setter)img_set_unit },
+    { "uri", (getter)img_get_uri, (setter)0 },
+    { "vectors", (getter)img_get_vectors, (setter)0 },
+    { "width", (getter)img_get_width, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+/* ---------- */
+
+
+PyObject *
+pygimp_image_new(gint32 ID)
+{
+    PyGimpImage *self;
+
+    if (!gimp_image_is_valid(ID)) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    self = PyObject_NEW(PyGimpImage, &PyGimpImage_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    self->ID = ID;
+
+    return (PyObject *)self;
+}
+
+
+static void
+img_dealloc(PyGimpImage *self)
+{
+    /* XXXX Add your own cleanup code here */
+    PyObject_DEL(self);
+}
+
+static PyObject *
+img_repr(PyGimpImage *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_image_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.Image '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+img_cmp(PyGimpImage *self, PyGimpImage *other)
+{
+    if (self->ID == other->ID)
+        return 0;
+
+    if (self->ID > other->ID)
+        return -1;
+
+    return 1;
+}
+
+static int
+img_init(PyGimpImage *self, PyObject *args, PyObject *kwargs)
+{
+    guint width, height;
+    GimpImageBaseType type = GIMP_RGB;
+
+    static char *kwlist[] = { "width", "height", "type", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ii|i:gimp.Image.__init__", kwlist,
+				     &width, &height, &type))
+        return -1;
+
+    self->ID = gimp_image_new(width, height, type);
+
+    if (self->ID < 0) {
+	PyErr_Format(pygimp_error,
+		     "could not create image (width: %d, height: %d, type: %d)",
+		     width, height, type);
+	return -1;
+    }
+
+    return 0;
+}
+
+PyTypeObject PyGimpImage_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Image",                       /* tp_name */
+    sizeof(PyGimpImage),                /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)img_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)img_cmp,                   /* tp_compare */
+    (reprfunc)img_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    img_methods,			/* tp_methods */
+    0,					/* tp_members */
+    img_getsets,			/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)img_init,                 /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
diff --git a/plug-ins/pygimp/pygimp-intl.h b/plug-ins/pygimp/pygimp-intl.h
new file mode 100644
index 0000000..ef6fdf2
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-intl.h
@@ -0,0 +1,48 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * pygimp-intl.h
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef __PYGIMP_INTL_H__
+#define __PYGIMP_INTL_H__
+
+#ifndef GETTEXT_PACKAGE
+#error "config.h must be included prior to pygimp-intl.h"
+#endif
+
+#include <libintl.h>
+
+
+#define  _(String) dgettext (GETTEXT_PACKAGE "-python", String)
+#define Q_(String) g_dpgettext (GETTEXT_PACKAGE "-python", String, 0)
+#define C_(Context,String) g_dpgettext (GETTEXT_PACKAGE "-python", Context "\004" String, strlen (Context) + 1)
+
+#undef gettext
+#define gettext(String) dgettext (GETTEXT_PACKAGE "-python", String)
+
+#undef ngettext
+#define ngettext(String1, String2, number) dngettext (GETTEXT_PACKAGE "-python", String1, String2, number)
+
+#ifdef gettext_noop
+#    define N_(String) gettext_noop (String)
+#else
+#    define N_(String) (String)
+#endif
+
+
+#endif /* __PYGIMP_INTL_H__ */
diff --git a/plug-ins/pygimp/pygimp-item.c b/plug-ins/pygimp/pygimp-item.c
new file mode 100644
index 0000000..b3b0883
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-item.c
@@ -0,0 +1,181 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include "pygimp.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+#include <glib-object.h>
+
+static PyObject *
+item_from_id(PyObject *not_used, PyObject *args)
+{
+    gint32 ID;
+
+    if (!PyArg_ParseTuple(args, "i", &ID))
+        return NULL;
+    return pygimp_item_new(ID);
+}
+
+static PyMethodDef item_methods[] = {
+    {"from_id",   (PyCFunction)item_from_id,  METH_VARARGS | METH_STATIC},
+    {NULL,              NULL}           /* sentinel */
+};
+
+static PyObject *
+item_get_parent(PyGimpLayer *self, void *closure)
+{
+    gint32 id = gimp_item_get_parent(self->ID);
+
+    if (id == -1) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    return pygimp_item_new(id);
+}
+
+static PyObject *
+item_get_children(PyGimpLayer *self, void *closure)
+{
+    gint32 *children;
+    gint n_children, i;
+    PyObject *ret;
+
+    children = gimp_item_get_children(self->ID, &n_children);
+
+    ret = PyList_New(n_children);
+
+    for (i = 0; i < n_children; i++)
+        PyList_SetItem(ret, i, pygimp_item_new(children[i]));
+
+    g_free(children);
+
+    return ret;
+}
+
+static PyGetSetDef item_getsets[] = {
+    { "parent", (getter)item_get_parent, (setter)0 },
+    { "children", (getter) item_get_children, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+
+static void
+item_dealloc(PyGimpItem *self)
+{
+    PyObject_DEL(self);
+}
+
+static PyObject *
+item_repr(PyGimpItem *self)
+{
+    PyObject *s;
+
+    s = PyString_FromFormat("<gimp.Item '%d'>", self->ID);
+
+    return s;
+}
+
+static int
+item_init(PyGimpLayer *self, PyObject *args, PyObject *kwargs)
+{
+    return -1;
+}
+
+
+
+PyTypeObject PyGimpItem_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Item",                        /* tp_name */
+    sizeof(PyGimpItem),                 /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)item_dealloc,            /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)item_repr,                /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    item_methods,                       /* tp_methods */
+    0,                                  /* tp_members */
+    item_getsets,                       /* tp_getset */
+    (PyTypeObject *)0,                   /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)item_init,                /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
+
+
+PyObject *
+pygimp_item_new(gint32 ID)
+{
+    PyObject *self;
+
+    if (!gimp_item_is_valid(ID)) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    /* create the appropriate object type */
+    if (gimp_item_is_drawable(ID)) {
+        if (gimp_item_is_group(ID)) {
+            self = pygimp_group_layer_new(ID);
+        }
+        else {
+            self = pygimp_drawable_new(NULL, ID);
+        }
+    }
+    else /* Vectors */
+        self = pygimp_vectors_new(ID);
+
+    if (self == NULL)
+        return NULL;
+
+    return self;
+}
diff --git a/plug-ins/pygimp/pygimp-logo.png b/plug-ins/pygimp/pygimp-logo.png
new file mode 100644
index 0000000..6f7ef4d
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-logo.png
diff --git a/plug-ins/pygimp/pygimp-parasite.c b/plug-ins/pygimp/pygimp-parasite.c
new file mode 100644
index 0000000..279cfbd
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-parasite.c
@@ -0,0 +1,216 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "pygimp.h"
+
+static PyObject *
+para_copy(PyGimpParasite *self, PyObject *args)
+{
+    if (!PyArg_ParseTuple(args, ":copy"))
+	return NULL;
+
+    return pygimp_parasite_new(gimp_parasite_copy(self->para));
+}
+
+static PyObject *
+para_is_type(PyGimpParasite *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:is_type", &name))
+	return NULL;
+
+    return PyInt_FromLong(gimp_parasite_is_type(self->para, name));
+}
+
+static PyObject *
+para_has_flag(PyGimpParasite *self, PyObject *args)
+{
+    int flag;
+
+    if (!PyArg_ParseTuple(args, "i:has_flag", &flag))
+	return NULL;
+
+    return PyInt_FromLong(gimp_parasite_has_flag(self->para, flag));
+}
+
+
+static PyMethodDef para_methods[] = {
+    {"copy",	(PyCFunction)para_copy,	METH_VARARGS},
+    {"is_type",	(PyCFunction)para_is_type,	METH_VARARGS},
+    {"has_flag",(PyCFunction)para_has_flag,	METH_VARARGS},
+
+    {NULL,		NULL}		/* sentinel */
+};
+
+static PyObject *
+para_get_is_persistent(PyGimpParasite *self, void *closure)
+{
+    return PyBool_FromLong(gimp_parasite_is_persistent(self->para));
+}
+
+static PyObject *
+para_get_is_undoable(PyGimpParasite *self, void *closure)
+{
+    return PyBool_FromLong(gimp_parasite_is_undoable(self->para));
+}
+
+static PyObject *
+para_get_flags(PyGimpParasite *self, void *closure)
+{
+    return PyInt_FromLong(gimp_parasite_flags(self->para));
+}
+
+static PyObject *
+para_get_name(PyGimpParasite *self, void *closure)
+{
+    return PyString_FromString(gimp_parasite_name(self->para));
+}
+
+static PyObject *
+para_get_data(PyGimpParasite *self, void *closure)
+{
+    return PyString_FromStringAndSize(gimp_parasite_data(self->para),
+				      gimp_parasite_data_size(self->para));
+}
+
+static PyGetSetDef para_getsets[] = {
+    { "is_persistent", (getter)para_get_is_persistent, (setter)0 },
+    { "is_undoable", (getter)para_get_is_undoable, (setter)0 },
+    { "flags", (getter)para_get_flags, (setter)0 },
+    { "name", (getter)para_get_name, (setter)0 },
+    { "data", (getter)para_get_data, (setter)0 },
+    { NULL, (getter)0, (setter)0 },
+};
+
+static void
+para_dealloc(PyGimpParasite *self)
+{
+    gimp_parasite_free(self->para);
+    PyObject_DEL(self);
+}
+
+static PyObject *
+para_repr(PyGimpParasite *self)
+{
+    PyObject *s;
+
+    s = PyString_FromFormat("<parasite %s>", gimp_parasite_name(self->para));
+
+    return s;
+}
+
+static PyObject *
+para_str(PyGimpParasite *self)
+{
+    return PyString_FromStringAndSize(gimp_parasite_data(self->para),
+				      gimp_parasite_data_size(self->para));
+}
+
+static int
+para_init(PyGimpParasite *self, PyObject *args, PyObject *kwargs)
+{
+    char *name;
+    int flags, size;
+    guint8 *data;
+
+    static char *kwlist[] = { "name", "flags", "data", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "sis#:gimp.Parasite.__init__", kwlist,
+				     &name, &flags,
+				     &data, &size))
+	return -1;
+
+    self->para = gimp_parasite_new(name, flags, size, data);
+
+    if (!self->para) {
+	PyErr_Format(pygimp_error, "could not create parasite '%s'", name);
+	return -1;
+    }
+
+    return 0;
+}
+
+
+PyTypeObject PyGimpParasite_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Parasite",                    /* tp_name */
+    sizeof(PyGimpParasite),             /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)para_dealloc,           /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)para_repr,                /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)para_str,                 /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    para_methods,			/* tp_methods */
+    0,					/* tp_members */
+    para_getsets,			/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)para_init,                /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+PyObject *
+pygimp_parasite_new(GimpParasite *para)
+{
+    PyGimpParasite *self;
+
+    if (!para) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    }
+
+    self = PyObject_NEW(PyGimpParasite, &PyGimpParasite_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    self->para = para;
+
+    return (PyObject *)self;
+}
diff --git a/plug-ins/pygimp/pygimp-pdb.c b/plug-ins/pygimp/pygimp-pdb.c
new file mode 100644
index 0000000..2ec0da0
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-pdb.c
@@ -0,0 +1,1110 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#define NO_IMPORT_PYGOBJECT
+#include <pygobject.h>
+
+#include "pygimp.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+#include <structmember.h>
+
+#include <glib-object.h>
+#include <glib/gprintf.h>
+
+#ifndef PG_DEBUG
+# define PG_DEBUG 0
+#endif
+
+/* ----------------------------------------------------- */
+
+/* Declarations for objects of type pdb */
+
+typedef struct {
+    PyObject_HEAD
+} PyGimpPDB;
+
+
+/* ---------------------------------------------------------------- */
+
+/* Declarations for objects of type pdbFunc */
+
+typedef struct {
+    PyObject_HEAD
+    char *name;
+    PyObject *proc_name, *proc_blurb, *proc_help, *proc_author,
+	*proc_copyright, *proc_date, *proc_type, *py_params,
+	*py_return_vals;
+    int nparams, nreturn_vals;
+    GimpParamDef *params, *return_vals;
+} PyGimpPDBFunction;
+
+static PyObject *pygimp_pdb_function_new_from_proc_db(char *name);
+
+/* ---------------------------------------------------------------- */
+
+/* routines to convert between Python tuples and gimp GimpParam's */
+
+#if PG_DEBUG > 0
+
+static void
+pygimp_param_print(int nparams, GimpParam *params)
+{
+    int i;
+
+    for (i = 0; i < nparams; i++) {
+	g_printf("param_print: type: %d, PDB_ITEM: %d\n",  params[i].type, GIMP_PDB_ITEM);
+	switch(params[i].type) {
+	case GIMP_PDB_INT32:
+	    g_printerr("%i. int %i\n", i,
+                       params[i].data.d_int32);
+	    break;
+	case GIMP_PDB_INT16:
+	    g_printerr("%i. int %i\n", i,
+                       params[i].data.d_int16);
+	    break;
+	case GIMP_PDB_INT8:
+	    g_printerr("%i. int %u\n", i,
+                       params[i].data.d_int8);
+	    break;
+	case GIMP_PDB_FLOAT:
+	    g_printerr("%i. float %f\n", i,
+                       params[i].data.d_float);
+	    break;
+	case GIMP_PDB_STRING:
+	    g_printerr("%i. string %s\n", i,
+                       params[i].data.d_string);
+	    break;
+	case GIMP_PDB_INT32ARRAY:
+	case GIMP_PDB_INT16ARRAY:
+	case GIMP_PDB_INT8ARRAY:
+	case GIMP_PDB_FLOATARRAY:
+	case GIMP_PDB_STRINGARRAY:
+	    g_printerr("%i. array of type %i %s\n", i,
+                       params[i].type,
+                       params[i].data.d_int32array == NULL ? "(null)":"");
+	    break;
+	case GIMP_PDB_STATUS:
+	    g_printerr("%i. status %i\n", i,
+                       params[i].data.d_status);
+	    break;
+	default:
+	    g_printerr("%i. other %i\n", i,
+                       params[i].data.d_int32);
+	    break;
+	}
+    }
+}
+
+#endif
+
+PyObject *
+pygimp_param_to_tuple(int nparams, const GimpParam *params)
+{
+    PyObject *args, *tmp;
+    int i, j, n;
+
+    args = PyTuple_New(nparams);
+    for (i = 0; i < nparams && params[i].type != GIMP_PDB_END; i++) {
+	PyObject *value = NULL;
+
+#if PG_DEBUG > 1
+	g_printf("param_to_tuple: type: %d, PDB_ITEM: %d\n",  params[i].type, GIMP_PDB_ITEM);
+#endif
+
+	switch(params[i].type) {
+	case GIMP_PDB_INT32:
+	    value = PyInt_FromLong(params[i].data.d_int32);
+	    break;
+	case GIMP_PDB_INT16:
+	    value = PyInt_FromLong(params[i].data.d_int16);
+	    break;
+	case GIMP_PDB_INT8:
+	    value = PyInt_FromLong(params[i].data.d_int8);
+	    break;
+	case GIMP_PDB_FLOAT:
+	    value = PyFloat_FromDouble(params[i].data.d_float);
+	    break;
+	case GIMP_PDB_STRING:
+	    if (params[i].data.d_string == NULL) {
+		Py_INCREF(Py_None);
+		value = Py_None;
+	    } else
+		value = PyString_FromString(params[i].data.d_string);
+	    break;
+
+	    /* For these to work, the previous argument must have
+	     * been an integer
+	     */
+	case GIMP_PDB_INT32ARRAY:
+	    if (params[i].data.d_int32array == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+			PyInt_FromLong(params[i].data.d_int32array[j]));
+	    break;
+	case GIMP_PDB_INT16ARRAY:
+	    if (params[i].data.d_int16array == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+			PyInt_FromLong(params[i].data.d_int16array[j]));
+	    break;
+	case GIMP_PDB_INT8ARRAY:
+	    if (params[i].data.d_int8array == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+			PyInt_FromLong(params[i].data.d_int8array[j]));
+	    break;
+	case GIMP_PDB_FLOATARRAY:
+	    if (params[i].data.d_floatarray == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+			PyFloat_FromDouble(params[i].data.d_floatarray[j]));
+	    break;
+	case GIMP_PDB_STRINGARRAY:
+	    if (params[i].data.d_stringarray == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+			params[i].data.d_stringarray[j] ?
+			PyString_FromString(params[i].data.d_stringarray[j]) :
+			PyString_FromString(""));
+	    break;
+	case GIMP_PDB_COLOR:
+	    value = pygimp_rgb_new(&params[i].data.d_color);
+	    break;
+	/*
+	GIMP_PDB_REGION is deprecated in libgimpbase/gimpbaseenums.h
+	and conflicts with GIMP_PDB_ITEM
+	case GIMP_PDB_REGION:
+	    value = Py_BuildValue("(iiii)",
+				  (int) params[i].data.d_region.x,
+				  (int) params[i].data.d_region.y,
+				  (int) params[i].data.d_region.width,
+				  (int) params[i].data.d_region.height);
+	    break;
+	*/
+	case GIMP_PDB_DISPLAY:
+	    value = pygimp_display_new(params[i].data.d_display);
+	    break;
+	case GIMP_PDB_IMAGE:
+	    value = pygimp_image_new(params[i].data.d_image);
+	    break;
+	case GIMP_PDB_LAYER:
+	    value = pygimp_layer_new(params[i].data.d_layer);
+	    break;
+	case GIMP_PDB_CHANNEL:
+	    value = pygimp_channel_new(params[i].data.d_channel);
+	    break;
+	case GIMP_PDB_ITEM:
+	    value = pygimp_item_new(params[i].data.d_item);
+	    break;
+	case GIMP_PDB_DRAWABLE:
+	    value = pygimp_drawable_new(NULL, params[i].data.d_drawable);
+	    break;
+	case GIMP_PDB_SELECTION:
+	    value = pygimp_channel_new(params[i].data.d_selection);
+	    break;
+	case GIMP_PDB_COLORARRAY:
+	    if (params[i].data.d_colorarray == NULL) {
+		value = PyTuple_New(0);
+		break;
+	    }
+	    if ((tmp=PyTuple_GetItem(args, i-1)) == NULL) {
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    if (!PyInt_Check(tmp)) {
+		PyErr_SetString(PyExc_TypeError,
+				"count type must be integer");
+		Py_DECREF(args);
+		return NULL;
+	    }
+	    n = PyInt_AsLong(tmp);
+	    value = PyTuple_New(n);
+	    for (j = 0; j < n; j++)
+		PyTuple_SetItem(value, j,
+                                pygimp_rgb_new(&params[i].data.d_colorarray[j]));
+	    break;
+	case GIMP_PDB_VECTORS:
+	    value = pygimp_vectors_new(params[i].data.d_vectors);
+	    break;
+	case GIMP_PDB_PARASITE:
+	    value = pygimp_parasite_new(gimp_parasite_copy(
+					&(params[i].data.d_parasite)));
+	    break;
+	case GIMP_PDB_STATUS:
+	    value = PyInt_FromLong(params[i].data.d_status);
+	    break;
+	case GIMP_PDB_END:
+	    break;
+	}
+	PyTuple_SetItem(args, i, value);
+    }
+    return args;
+}
+
+GimpParam *
+pygimp_param_from_tuple(PyObject *args, const GimpParamDef *ptype, int nparams)
+{
+    PyObject *tuple, *item, *x, *y;
+    GimpParam *ret;
+    int i, j, len;
+    gint32 *i32a; gint16 *i16a; guint8 *i8a; gdouble *fa; gchar **sa;
+
+    if (nparams == 0)
+	tuple = PyTuple_New(0);
+    else if (!PyTuple_Check(args) && nparams == 1)
+	tuple = Py_BuildValue("(O)", args);
+    else {
+	Py_INCREF(args);
+	tuple = args;
+    }
+    if (!PyTuple_Check(tuple)) {
+	PyErr_SetString(PyExc_TypeError, "wrong type of parameter");
+        Py_DECREF(tuple);
+	return NULL;
+    }
+
+    if (PyTuple_Size(tuple) != nparams) {
+	PyErr_SetString(PyExc_TypeError, "wrong number of parameters");
+        Py_DECREF(tuple);
+	return NULL;
+    }
+
+    ret = g_new(GimpParam, nparams+1);
+    for (i = 0; i <= nparams; i++)
+	ret[i].type = GIMP_PDB_STATUS;
+#define check(expr) if (expr) { \
+	    PyErr_SetString(PyExc_TypeError, "wrong parameter type"); \
+	    Py_DECREF(tuple); \
+	    gimp_destroy_params(ret, nparams); \
+	    return NULL; \
+	}
+#define arraycheck(expr, ar) if (expr) { \
+	    PyErr_SetString(PyExc_TypeError, "subscript of wrong type"); \
+	    Py_DECREF(tuple); \
+	    gimp_destroy_params(ret, nparams); \
+	    g_free(ar); \
+	    return NULL; \
+	}
+    for (i = 1; i <= nparams; i++) {
+	item = PyTuple_GetItem(tuple, i-1);
+#if PG_DEBUG > 1
+	g_printf("param_from_tuple: type: %d, PDB_ITEM: %d\n",  ptype[i-1].type, GIMP_PDB_ITEM);
+#endif
+	switch (ptype[i-1].type) {
+	case GIMP_PDB_INT32:
+	    check((x = PyNumber_Int(item)) == NULL);
+	    ret[i].data.d_int32 = (gint32)PyInt_AsLong(x);
+	    Py_DECREF(x);
+	    break;
+	case GIMP_PDB_INT16:
+	    check((x = PyNumber_Int(item)) == NULL);
+	    ret[i].data.d_int16 = (gint16)PyInt_AsLong(x);
+	    Py_DECREF(x);
+	    break;
+	case GIMP_PDB_INT8:
+	    check((x = PyNumber_Int(item)) == NULL);
+	    ret[i].data.d_int8 = (guint8)PyInt_AsLong(x);
+	    Py_DECREF(x);
+	    break;
+	case GIMP_PDB_FLOAT:
+	    check((x = PyNumber_Float(item)) == NULL);
+	    ret[i].data.d_float = PyFloat_AsDouble(x);
+	    Py_DECREF(x);
+	    break;
+	case GIMP_PDB_STRING:
+	    if (item == Py_None) {
+		ret[i].data.d_string = NULL;
+		break;
+	    }
+	    check((x = PyObject_Str(item)) == NULL);
+	    ret[i].data.d_string = g_strdup(PyString_AsString(x));
+	    Py_DECREF(x);
+	    break;
+	case GIMP_PDB_INT32ARRAY:
+	    check(!PySequence_Check(item));
+	    len = PySequence_Length(item);
+	    i32a = g_new(gint32, len);
+	    for (j = 0; j < len; j++) {
+		x = PySequence_GetItem(item, j);
+		arraycheck((y=PyNumber_Int(x))==NULL,
+			   i32a);
+		i32a[j] = PyInt_AsLong(y);
+		Py_DECREF(y);
+	    }
+	    ret[i].data.d_int32array = i32a;
+	    break;
+	case GIMP_PDB_INT16ARRAY:
+	    check(!PySequence_Check(item));
+	    len = PySequence_Length(item);
+	    i16a = g_new(gint16, len);
+	    for (j = 0; j < len; j++) {
+		x = PySequence_GetItem(item, j);
+		arraycheck((y=PyNumber_Int(x))==NULL,
+			   i16a);
+		i16a[j] = PyInt_AsLong(y);
+		Py_DECREF(y);
+	    }
+	    ret[i].data.d_int16array = i16a;
+	    break;
+	case GIMP_PDB_INT8ARRAY:
+	    check(!PySequence_Check(item));
+	    len = PySequence_Length(item);
+	    i8a = g_new(guint8, len);
+	    for (j = 0; j < len; j++) {
+		x = PySequence_GetItem(item, j);
+		arraycheck((y=PyNumber_Int(x))==NULL,
+			   i8a);
+		i8a[j] = PyInt_AsLong(y);
+		Py_DECREF(y);
+	    }
+	    ret[i].data.d_int8array = i8a;
+	    break;
+	case GIMP_PDB_FLOATARRAY:
+	    check(!PySequence_Check(item));
+	    len = PySequence_Length(item);
+	    fa = g_new(gdouble, len);
+	    for (j = 0; j < len; j++) {
+		x = PySequence_GetItem(item, j);
+		arraycheck((y=PyNumber_Float(x))==NULL,
+			   fa);
+		fa[j] = PyFloat_AsDouble(y);
+		Py_DECREF(y);
+	    }
+	    ret[i].data.d_floatarray = fa;
+	    break;
+	case GIMP_PDB_STRINGARRAY:
+	    check(!PySequence_Check(item));
+	    len = PySequence_Length(item);
+	    sa = g_new(gchar *, len);
+	    for (j = 0; j < len; j++) {
+		x = PySequence_GetItem(item, j);
+		if (x == Py_None) {
+		    sa[j] = NULL;
+		    continue;
+		}
+		arraycheck((y=PyObject_Str(x))==NULL,
+			   sa);
+		sa[j] = g_strdup(PyString_AsString(y));
+		Py_DECREF(y);
+	    }
+	    ret[i].data.d_stringarray = sa;
+	    break;
+	case GIMP_PDB_COLOR:
+	    {
+                GimpRGB rgb;
+
+                if (!pygimp_rgb_from_pyobject(item, &rgb)) {
+                    Py_DECREF(tuple);
+                    gimp_destroy_params(ret, nparams);
+                    return NULL;
+		}
+
+                ret[i].data.d_color = rgb;
+	    }
+	    break;
+/*
+	case GIMP_PDB_REGION:
+	    check(!PySequence_Check(item) ||
+		  PySequence_Length(item) < 4);
+	    x = PySequence_GetItem(item, 0);
+	    y = PySequence_GetItem(item, 1);
+	    w = PySequence_GetItem(item, 2);
+	    h = PySequence_GetItem(item, 3);
+	    check(!PyInt_Check(x) || !PyInt_Check(y) ||
+		  !PyInt_Check(w) || !PyInt_Check(h));
+	    ret[i].data.d_region.x = PyInt_AsLong(x);
+	    ret[i].data.d_region.y = PyInt_AsLong(y);
+	    ret[i].data.d_region.width = PyInt_AsLong(w);
+	    ret[i].data.d_region.height = PyInt_AsLong(h);
+	    break;
+*/
+	case GIMP_PDB_DISPLAY:
+            if (item == Py_None) {
+                ret[i].data.d_display = -1;
+                break;
+            }
+	    check(!pygimp_display_check(item));
+	    ret[i].data.d_display = ((PyGimpDisplay *)item)->ID;
+	    break;
+	case GIMP_PDB_IMAGE:
+	    if (item == Py_None) {
+		ret[i].data.d_image = -1;
+		break;
+	    }
+	    check(!pygimp_image_check(item));
+	    ret[i].data.d_image = ((PyGimpImage *)item)->ID;
+	    break;
+	case GIMP_PDB_LAYER:
+	    if (item == Py_None) {
+		ret[i].data.d_layer = -1;
+		break;
+	    }
+	    check(!pygimp_layer_check(item));
+	    ret[i].data.d_layer = ((PyGimpLayer *)item)->ID;
+	    break;
+	case GIMP_PDB_CHANNEL:
+	    if (item == Py_None) {
+		ret[i].data.d_channel = -1;
+		break;
+	    }
+	    check(!pygimp_channel_check(item));
+	    ret[i].data.d_channel = ((PyGimpChannel *)item)->ID;
+	    break;
+	case GIMP_PDB_ITEM:
+	    if (item == Py_None) {
+		ret[i].data.d_channel = -1;
+		break;
+	    }
+	    check(!pygimp_item_check(item));
+	    ret[i].data.d_item = ((PyGimpItem *)item)->ID;
+	    break;
+	case GIMP_PDB_DRAWABLE:
+	    if (item == Py_None) {
+		ret[i].data.d_channel = -1;
+		break;
+	    }
+	    check(!pygimp_drawable_check(item));
+	    ret[i].data.d_channel = ((PyGimpDrawable *)item)->ID;
+	    break;
+	case GIMP_PDB_SELECTION:
+	    if (item == Py_None) {
+		ret[i].data.d_channel = -1;
+		break;
+	    }
+	    check(!pygimp_channel_check(item));
+	    ret[i].data.d_selection = ((PyGimpChannel *)item)->ID;
+	    break;
+	case GIMP_PDB_COLORARRAY:
+	    {
+                GimpRGB *rgb;
+
+		check(!PySequence_Check(item));
+		len = PySequence_Length(item);
+		rgb = g_new(GimpRGB, len);
+		for (j = 0; j < len; j++) {
+		    if (!pygimp_rgb_from_pyobject(item, &rgb[j])) {
+			Py_DECREF(tuple);
+			g_free(rgb);
+			gimp_destroy_params(ret, nparams);
+			return NULL;
+		    }
+		}
+                ret[i].data.d_colorarray = rgb;
+	    }
+	    break;
+	case GIMP_PDB_VECTORS:
+	    if (item == Py_None) {
+		ret[i].data.d_vectors = -1;
+		break;
+	    }
+	    check(!pygimp_vectors_check(item));
+	    ret[i].data.d_vectors = ((PyGimpVectors *)item)->ID;
+	    break;
+	case GIMP_PDB_PARASITE:
+	    /* can't do anything, since size of GimpParasite is not known */
+	    break;
+	case GIMP_PDB_STATUS:
+	    check(!PyInt_Check(item));
+	    ret[i].data.d_status = PyInt_AsLong(item);
+	    break;
+	case GIMP_PDB_END:
+	    break;
+	}
+#undef check
+#undef arraycheck
+	ret[i].type = ptype[i-1].type;
+    }
+
+    Py_DECREF(tuple);
+    return ret;
+}
+
+/* ---------------------------------------------------------------- */
+
+static PyObject *
+pdb_query(PyGimpPDB *self, PyObject *args)
+{
+    char *n=".*", *b=".*", *h=".*", *a=".*", *c=".*", *d=".*", *t=".*";
+    int num, i;
+    char **names;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, "|zzzzzzz:gimp.pdb.query", &n, &b, &h, &a,
+			  &c, &d, &t))
+	return NULL;
+
+    gimp_procedural_db_query(n, b, h, a, c, d, t, &num, &names);
+
+    ret = PyList_New(num);
+
+    for (i = 0; i < num; i++)
+	PyList_SetItem(ret, i, PyString_FromString(names[i]));
+
+    g_strfreev(names);
+
+    return ret;
+}
+
+static PyMethodDef pdb_methods[] = {
+    {"query", (PyCFunction)pdb_query, METH_VARARGS},
+    {NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+PyObject *
+pygimp_pdb_new(void)
+{
+    PyGimpPDB *self = PyObject_NEW(PyGimpPDB, &PyGimpPDB_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    return (PyObject *)self;
+}
+
+
+static void
+pdb_dealloc(PyGimpPDB *self)
+{
+    PyObject_DEL(self);
+}
+
+static PyObject *
+pdb_repr(PyGimpPDB *self)
+{
+    return PyString_FromString("<gimp procedural database>");
+}
+
+/* Code to access pdb objects as mappings */
+
+static PyObject *
+pdb_subscript(PyGimpPDB *self, PyObject *key)
+{
+    PyObject *r;
+
+    if (!PyString_Check(key)) {
+	PyErr_SetString(PyExc_TypeError, "Subscript must be a string");
+	return NULL;
+    }
+
+    r = (PyObject *)pygimp_pdb_function_new_from_proc_db(PyString_AsString(key));
+
+    if (r == NULL) {
+	PyErr_Clear();
+	PyErr_SetObject(PyExc_KeyError, key);
+    }
+
+    return r;
+}
+
+static PyMappingMethods pdb_as_mapping = {
+    (lenfunc)0,			/*mp_length*/
+    (binaryfunc)pdb_subscript,	/*mp_subscript*/
+    (objobjargproc)0,		/*mp_ass_subscript*/
+};
+
+/* -------------------------------------------------------- */
+
+static PyObject *
+build_procedure_list(void)
+{
+    int num, i;
+    char **names, *name, *p;
+    PyObject *ret;
+
+    gimp_procedural_db_query(".*", ".*", ".*", ".*", ".*", ".*", ".*",
+                             &num, &names);
+
+    ret = PyList_New(num);
+
+    for (i = 0; i < num; i++) {
+        name = g_strdup(names[i]);
+        for (p = name; *p != '\0'; p++) {
+            if (*p == '-')
+                *p = '_';
+	}
+        PyList_SetItem(ret, i, PyString_FromString(name));
+    }
+
+    g_strfreev(names);
+
+    return ret;
+}
+
+static PyObject *
+pdb_getattro(PyGimpPDB *self, PyObject *attr)
+{
+    char *attr_name;
+    PyObject *ret;
+
+    attr_name = PyString_AsString(attr);
+    if (!attr_name) {
+         PyErr_Clear();
+         return PyObject_GenericGetAttr((PyObject *)self, attr);
+    }
+
+    if (attr_name[0] == '_') {
+        if (!strcmp(attr_name, "__members__")) {
+            return build_procedure_list();
+        } else {
+            return PyObject_GenericGetAttr((PyObject *)self, attr);
+        }
+    }
+
+    ret = PyObject_GenericGetAttr((PyObject *)self, attr);
+    if (ret)
+        return ret;
+
+    PyErr_Clear();
+
+    return pygimp_pdb_function_new_from_proc_db(attr_name);
+}
+
+PyTypeObject PyGimpPDB_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.PDB",                         /* tp_name */
+    sizeof(PyGimpPDB),                  /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)pdb_dealloc,           /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)pdb_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    &pdb_as_mapping,                     /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)pdb_getattro,         /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    pdb_methods,			/* tp_methods */
+    0,					/* tp_members */
+    0,					/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)0,	                /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+/* End of code for pdb objects */
+/* -------------------------------------------------------- */
+
+
+static PyObject *
+pygimp_pdb_function_new_from_proc_db(char *name)
+{
+    PyObject *ret;
+    char *b,*h,*a,*c,*d;
+    int np, nr;
+    GimpPDBProcType pt;
+    GimpParamDef *p, *r;
+
+    if (!gimp_procedural_db_proc_info (name, &b, &h, &a, &c, &d, &pt,
+				       &np, &nr, &p, &r)) {
+	PyErr_SetString(pygimp_error, "procedure not found");
+	return NULL;
+    }
+
+    ret = pygimp_pdb_function_new(name, b, h, a, c, d, pt, np, nr, p, r);
+
+    g_free(b); g_free(h); g_free(a); g_free(c); g_free(d);
+
+    return ret;
+}
+
+static void
+pf_dealloc(PyGimpPDBFunction *self)
+{
+    g_free(self->name);
+
+    Py_DECREF(self->proc_name);
+    Py_DECREF(self->proc_blurb);
+    Py_DECREF(self->proc_help);
+    Py_DECREF(self->proc_author);
+    Py_DECREF(self->proc_copyright);
+    Py_DECREF(self->proc_date);
+    Py_DECREF(self->proc_type);
+    Py_DECREF(self->py_params);
+    Py_DECREF(self->py_return_vals);
+
+    gimp_destroy_paramdefs(self->params, self->nparams);
+    gimp_destroy_paramdefs(self->return_vals, self->nreturn_vals);
+
+    PyObject_DEL(self);
+}
+
+#define OFF(x) offsetof(PyGimpPDBFunction, x)
+static struct PyMemberDef pf_members[] = {
+    {"proc_name",      T_OBJECT, OFF(proc_name),      RO},
+    {"proc_blurb",     T_OBJECT, OFF(proc_blurb),     RO},
+    {"proc_help",      T_OBJECT, OFF(proc_help),      RO},
+    {"proc_author",    T_OBJECT, OFF(proc_author),    RO},
+    {"proc_copyright", T_OBJECT, OFF(proc_copyright), RO},
+    {"proc_date",      T_OBJECT, OFF(proc_date),      RO},
+    {"proc_type",      T_OBJECT, OFF(proc_type),      RO},
+    {"nparams",        T_INT,    OFF(nparams),        RO},
+    {"nreturn_vals",   T_INT,    OFF(nreturn_vals),   RO},
+    {"params",         T_OBJECT, OFF(py_params),      RO},
+    {"return_vals",    T_OBJECT, OFF(py_return_vals), RO},
+    {NULL}  /* Sentinel */
+};
+#undef OFF
+
+static PyObject *
+pf_repr(PyGimpPDBFunction *self)
+{
+    return PyString_FromFormat("<pdb function '%s'>",
+			       PyString_AsString(self->proc_name));
+}
+
+static PyObject *
+pf_call(PyGimpPDBFunction *self, PyObject *args, PyObject *kwargs)
+{
+    GimpParam *params, *ret;
+    int nret;
+    PyObject *t = NULL, *r;
+    GimpRunMode run_mode = GIMP_RUN_NONINTERACTIVE;
+
+#if PG_DEBUG > 0
+    g_printerr("--- %s --- ", PyString_AsString(self->proc_name));
+#endif
+
+    if (kwargs) {
+        Py_ssize_t len, pos;
+        PyObject *key, *val;
+
+        len = PyDict_Size(kwargs);
+
+        if (len == 1) {
+            pos = 0;
+            PyDict_Next(kwargs, &pos, &key, &val);
+
+            if (!PyString_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keyword argument name is not a string");
+                return NULL;
+            }
+
+            if (strcmp(PyString_AsString(key), "run_mode") != 0) {
+                PyErr_SetString(PyExc_TypeError,
+                                "only 'run_mode' keyword argument accepted");
+                return NULL;
+            }
+
+            if (pyg_enum_get_value(GIMP_TYPE_RUN_MODE, val, (gpointer)&run_mode))
+                return NULL;
+        } else if (len != 0) {
+            PyErr_SetString(PyExc_TypeError,
+                            "expecting at most one keyword argument");
+            return NULL;
+        }
+    }
+
+    if (self->nparams > 0 && !strcmp(self->params[0].name, "run-mode")) {
+	params = pygimp_param_from_tuple(args, self->params + 1,
+					 self->nparams - 1);
+
+	if (params == NULL)
+	    return NULL;
+
+	params[0].type = self->params[0].type;
+	params[0].data.d_int32 = run_mode;
+
+#if PG_DEBUG > 1
+	pygimp_param_print(self->nparams, params);
+#endif
+
+	ret = gimp_run_procedure2(self->name, &nret, self->nparams, params);
+    } else {
+	params = pygimp_param_from_tuple(args, self->params, self->nparams);
+
+	if (params == NULL)
+	    return NULL;
+
+#if PG_DEBUG > 1
+	pygimp_param_print(self->nparams, params+1);
+#endif
+
+	ret = gimp_run_procedure2(self->name, &nret, self->nparams, params + 1);
+    }
+
+    gimp_destroy_params(params, self->nparams);
+
+    if (!ret) {
+	PyErr_SetString(pygimp_error, "no status returned");
+#if PG_DEBUG >= 1
+	g_printerr("ret == NULL\n");
+#endif
+	return NULL;
+    }
+
+    switch(ret[0].data.d_status) {
+    case GIMP_PDB_SUCCESS:
+#if PG_DEBUG > 0
+	g_printerr("success\n");
+#endif
+	t = pygimp_param_to_tuple(nret-1, ret+1);
+	gimp_destroy_params(ret, nret);
+
+	if (t == NULL) {
+	    PyErr_SetString(pygimp_error, "could not make return value");
+	    return NULL;
+	}
+	break;
+
+    case GIMP_PDB_EXECUTION_ERROR:
+#if PG_DEBUG > 0
+	g_printerr("execution error\n");
+#endif
+        PyErr_SetString(PyExc_RuntimeError, gimp_get_pdb_error());
+	gimp_destroy_params(ret, nret);
+	return NULL;
+
+    case GIMP_PDB_CALLING_ERROR:
+#if PG_DEBUG > 0
+	g_printerr("calling error\n");
+#endif
+        PyErr_SetString(PyExc_RuntimeError, gimp_get_pdb_error());
+	gimp_destroy_params(ret, nret);
+	return NULL;
+
+    case GIMP_PDB_CANCEL:
+#if PG_DEBUG > 0
+	g_printerr("cancel\n");
+#endif
+        PyErr_SetString(PyExc_RuntimeError, gimp_get_pdb_error());
+	gimp_destroy_params(ret, nret);
+	return NULL;
+
+    default:
+#if PG_DEBUG > 0
+	g_printerr("unknown - %i (type %i)\n",
+                   ret[0].data.d_status, ret[0].type);
+#endif
+	PyErr_SetString(pygimp_error, "unknown return code");
+	return NULL;
+    }
+
+    if (PyTuple_Size(t) == 1) {
+	r = PyTuple_GetItem(t, 0);
+	Py_INCREF(r);
+	Py_DECREF(t);
+	return r;
+    }
+
+    if (PyTuple_Size(t) == 0) {
+	r = Py_None;
+	Py_INCREF(r);
+	Py_DECREF(t);
+	return r;
+    }
+
+    return t;
+}
+
+
+PyTypeObject PyGimpPDBFunction_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.PDBFunction",                 /* tp_name */
+    sizeof(PyGimpPDBFunction),          /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)pf_dealloc,             /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)pf_repr,                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)pf_call,               /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    0,					/* tp_methods */
+    pf_members,				/* tp_members */
+    0,					/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)0,	                /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+PyObject *
+pygimp_pdb_function_new(const char *name, const char *blurb, const char *help,
+			const char *author, const char *copyright,
+			const char *date, GimpPDBProcType proc_type,
+			int n_params, int n_return_vals,
+			GimpParamDef *params, GimpParamDef *return_vals)
+{
+    PyGimpPDBFunction *self;
+    int i;
+
+    self = PyObject_NEW(PyGimpPDBFunction, &PyGimpPDBFunction_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    self->name = g_strdup(name);
+    self->proc_name = PyString_FromString(name ? name : "");
+    self->proc_blurb = PyString_FromString(blurb ? blurb : "");
+    self->proc_help = PyString_FromString(help ? help : "");
+    self->proc_author = PyString_FromString(author ? author : "");
+    self->proc_copyright = PyString_FromString(copyright ? copyright : "");
+    self->proc_date = PyString_FromString(date ? date : "");
+    self->proc_type = PyInt_FromLong(proc_type);
+    self->nparams = n_params;
+    self->nreturn_vals = n_return_vals;
+    self->params = params;
+    self->return_vals = return_vals;
+
+    self->py_params = PyTuple_New(n_params);
+    for (i = 0; i < n_params; i++)
+	PyTuple_SetItem(self->py_params, i,
+			Py_BuildValue("(iss)",
+				      params[i].type,
+				      params[i].name,
+				      params[i].description));
+
+    self->py_return_vals = PyTuple_New(n_return_vals);
+    for (i = 0; i < n_return_vals; i++)
+	PyTuple_SetItem(self->py_return_vals, i,
+			Py_BuildValue("(iss)",
+				      return_vals[i].type,
+				      return_vals[i].name,
+				      return_vals[i].description));
+
+    return (PyObject *)self;
+}
diff --git a/plug-ins/pygimp/pygimp-tile.c b/plug-ins/pygimp/pygimp-tile.c
new file mode 100644
index 0000000..b4f3722
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-tile.c
@@ -0,0 +1,1046 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#define GIMP_DISABLE_DEPRECATION_WARNINGS
+
+#include "pygimp.h"
+
+#define NO_IMPORT_PYGIMPCOLOR
+#include "pygimpcolor-api.h"
+
+#include <structmember.h>
+
+static PyObject *
+tile_flush(PyGimpTile *self, PyObject *args)
+{
+    if (!PyArg_ParseTuple(args, ":flush"))
+	return NULL;
+
+    gimp_tile_flush(self->tile);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyMethodDef tile_methods[] = {
+    {"flush",	(PyCFunction)tile_flush,	METH_VARARGS},
+    {NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+PyObject *
+pygimp_tile_new(GimpTile *t, PyGimpDrawable *drw)
+{
+    PyGimpTile *self;
+
+    self = PyObject_NEW(PyGimpTile, &PyGimpTile_Type);
+
+    if (self == NULL)
+	return NULL;
+
+    gimp_tile_ref(t);
+
+    self->tile = t;
+
+    Py_INCREF(drw);
+    self->drawable = drw;
+
+    return (PyObject *)self;
+}
+
+
+static void
+tile_dealloc(PyGimpTile *self)
+{
+    gimp_tile_unref(self->tile, FALSE);
+
+    Py_DECREF(self->drawable);
+    PyObject_DEL(self);
+}
+
+static PyObject *
+tile_get_uint_field(PyGimpTile *self, void *closure)
+{
+    gint offset = GPOINTER_TO_INT(closure);
+    guint value;
+    gchar *addr;
+
+    addr = (gchar *)self->tile;
+    addr += offset;
+    value = *(guint *)addr;
+
+    return PyInt_FromLong(value);
+}
+
+static PyObject *
+tile_get_dirty(PyGimpTile *self, void *closure)
+{
+    return PyBool_FromLong(self->tile->dirty);
+}
+
+static PyObject *
+tile_get_shadow(PyGimpTile *self, void *closure)
+{
+    return PyBool_FromLong(self->tile->shadow);
+}
+
+static PyObject *
+tile_get_drawable(PyGimpTile *self, void *closure)
+{
+    return pygimp_drawable_new(self->tile->drawable, 0);
+}
+
+
+#define OFF(x) GINT_TO_POINTER(offsetof(GimpTile, x))
+static PyGetSetDef tile_getsets[] = {
+    { "ewidth",   (getter)tile_get_uint_field, 0, NULL, OFF(ewidth) },
+    { "eheight",  (getter)tile_get_uint_field, 0, NULL, OFF(eheight) },
+    { "bpp",      (getter)tile_get_uint_field, 0, NULL, OFF(bpp) },
+    { "tile_num", (getter)tile_get_uint_field, 0, NULL, OFF(tile_num) },
+    { "dirty",    (getter)tile_get_dirty, 0, NULL },
+    { "shadow",   (getter)tile_get_shadow, 0, NULL },
+    { "drawable", (getter)tile_get_drawable, 0, NULL },
+    { NULL, (getter)0, (setter)0 }
+};
+#undef OFF
+
+static PyObject *
+tile_repr(PyGimpTile *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->tile->drawable->drawable_id);
+
+    if (self->tile->shadow)
+	s = PyString_FromFormat("<gimp.Tile for drawable '%s' (shadow)>", name);
+    else
+	s = PyString_FromFormat("<gimp.Tile for drawable '%s'>", name);
+
+    g_free(name);
+
+    return s;
+}
+
+static Py_ssize_t
+tile_length(PyObject *self)
+{
+    return ((PyGimpTile*)self)->tile->ewidth * ((PyGimpTile*)self)->tile->eheight;
+}
+
+static PyObject *
+tile_subscript(PyGimpTile *self, PyObject *sub)
+{
+    GimpTile *tile = self->tile;
+    int bpp = tile->bpp;
+    long x, y;
+
+    if (PyInt_Check(sub)) {
+	x = PyInt_AsLong(sub);
+
+	if (x < 0 || x >= tile->ewidth * tile->eheight) {
+	    PyErr_SetString(PyExc_IndexError, "index out of range");
+	    return NULL;
+	}
+
+	return PyString_FromStringAndSize
+            ((char *)tile->data + bpp * x, bpp);
+    }
+
+    if (PyTuple_Check(sub)) {
+	if (!PyArg_ParseTuple(sub, "ll", &x, &y))
+	    return NULL;
+
+	if (x < 0 || y < 0 || x >= tile->ewidth || y>=tile->eheight) {
+	    PyErr_SetString(PyExc_IndexError, "index out of range");
+	    return NULL;
+	}
+
+	return PyString_FromStringAndSize
+            ((char *)tile->data + bpp * (x + y * tile->ewidth), bpp);
+    }
+
+    PyErr_SetString(PyExc_TypeError, "tile subscript not int or 2-tuple");
+    return NULL;
+}
+
+static int
+tile_ass_sub(PyGimpTile *self, PyObject *v, PyObject *w)
+{
+    GimpTile *tile = self->tile;
+    int bpp = tile->bpp, i;
+    long x, y;
+    guchar *pix, *data;
+
+    if (w == NULL) {
+	PyErr_SetString(PyExc_TypeError,
+			"can not delete pixels in tile");
+	return -1;
+    }
+
+    if (!PyString_Check(w) && PyString_Size(w) == bpp) {
+	PyErr_SetString(PyExc_TypeError, "invalid subscript");
+	return -1;
+    }
+
+    pix = (guchar *)PyString_AsString(w);
+
+    if (PyInt_Check(v)) {
+	x = PyInt_AsLong(v);
+
+	if (x < 0 || x >= tile->ewidth * tile->eheight) {
+	    PyErr_SetString(PyExc_IndexError, "index out of range");
+	    return -1;
+	}
+
+	data = tile->data + x * bpp;
+
+	for (i = 0; i < bpp; i++)
+	    data[i] = pix[i];
+
+	tile->dirty = TRUE;
+
+	return 0;
+    }
+
+    if (PyTuple_Check(v)) {
+	if (!PyArg_ParseTuple(v, "ll", &x, &y))
+	    return -1;
+
+	if (x < 0 || y < 0 || x >= tile->ewidth || y>=tile->eheight) {
+	    PyErr_SetString(PyExc_IndexError, "index out of range");
+	    return -1;
+	}
+
+	data = tile->data + bpp * (x + y * tile->ewidth);
+
+	for (i = 0; i < bpp; i++)
+	    data[i] = pix[i];
+
+	tile->dirty = TRUE;
+
+	return 0;
+    }
+
+    PyErr_SetString(PyExc_TypeError, "tile subscript not int or 2-tuple");
+    return -1;
+}
+
+static PyMappingMethods tile_as_mapping = {
+    tile_length, /*length*/
+    (binaryfunc)tile_subscript, /*subscript*/
+    (objobjargproc)tile_ass_sub, /*ass_sub*/
+};
+
+PyTypeObject PyGimpTile_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Tile",                        /* tp_name */
+    sizeof(PyGimpTile),                 /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)tile_dealloc,           /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)tile_repr,                /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    &tile_as_mapping,                   /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    tile_methods,			/* tp_methods */
+    0,					/* tp_members */
+    tile_getsets,			/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)0,                        /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+/* End of code for Tile objects */
+/* -------------------------------------------------------- */
+
+
+static PyObject *
+pr_resize(PyGimpPixelRgn *self, PyObject *args)
+{
+    int x, y, w, h;
+
+    if (!PyArg_ParseTuple(args, "iiii:resize", &x, &y, &w, &h))
+	return NULL;
+
+    gimp_pixel_rgn_resize(&(self->pr), x, y, w, h);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+
+static PyMethodDef pr_methods[] = {
+    {"resize",	(PyCFunction)pr_resize,	METH_VARARGS},
+
+    {NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+PyObject *
+pygimp_pixel_rgn_new(PyGimpDrawable *drawable, int x, int y,
+		     int width, int height, int dirty, int shadow)
+{
+    PyGimpPixelRgn *self;
+    int drw_width;
+    int drw_height;
+
+    self = PyObject_NEW(PyGimpPixelRgn, &PyGimpPixelRgn_Type);
+
+    if (self == NULL || drawable == NULL)
+        return NULL;
+
+    drw_width = gimp_drawable_width(drawable->ID);
+    drw_height = gimp_drawable_height(drawable->ID);
+
+    if(x < 0) x = 0;
+    if(y < 0) y = 0;
+    if(width < 0) width = drw_width - x;
+    if(height < 0) height = drw_height - y;
+    if(x >= drw_width) x = drw_width - 1;
+    if(y >= drw_height) y = drw_height - 1;
+    if(x + width > drw_width) width = drw_width - x;
+    if(y + height > drw_height) height = drw_height - y;
+
+    gimp_pixel_rgn_init(&(self->pr), drawable->drawable, x, y, width, height,
+			dirty, shadow);
+
+    self->drawable = drawable;
+    Py_INCREF(drawable);
+
+    return (PyObject *)self;
+}
+
+
+static void
+pr_dealloc(PyGimpPixelRgn *self)
+{
+    Py_DECREF(self->drawable);
+    PyObject_DEL(self);
+}
+
+/* Code to access pr objects as mappings */
+
+static Py_ssize_t
+pr_length(PyObject *self)
+{
+    PyErr_SetString(pygimp_error, "Can't get size of pixel region");
+    return -1;
+}
+
+static PyObject *
+pr_subscript(PyGimpPixelRgn *self, PyObject *key)
+{
+    GimpPixelRgn *pr = &(self->pr);
+    PyObject *x, *y;
+    Py_ssize_t x1, y1, x2, y2, xs, ys;
+    PyObject *ret;
+
+    if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) {
+        PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTuple(key, "OO", &x, &y))
+        return NULL;
+
+    if (PyInt_Check(x)) {
+        x1 = PyInt_AsSsize_t(x);
+
+        if (x1 < pr->x || x1 >= pr->x + pr->w) {
+            PyErr_SetString(PyExc_IndexError, "x subscript out of range");
+            return NULL;
+        }
+
+        if (PyInt_Check(y)) {
+            y1 = PyInt_AsSsize_t(y);
+
+            if (y1 < pr->y || y1 >= pr->y + pr->h) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return NULL;
+            }
+
+            ret = PyString_FromStringAndSize(NULL, pr->bpp);
+            gimp_pixel_rgn_get_pixel(pr, (guchar*)PyString_AS_STRING(ret),
+                                     x1, y1);
+
+        } else if (PySlice_Check(y)) {
+            if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h,
+                                   &y1, &y2, &ys) ||
+                y1 >= y2 || ys != 1) {
+                PyErr_SetString(PyExc_IndexError, "invalid y slice");
+                return NULL;
+            }
+
+            if(y1 == 0)
+                y1 = pr->y;
+
+            if(y1 < pr->y || y2 < pr->y) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return NULL;
+            }
+
+            ret = PyString_FromStringAndSize(NULL, pr->bpp * (y2 - y1));
+            gimp_pixel_rgn_get_col(pr, (guchar*)PyString_AS_STRING(ret),
+                                   x1, y1, y2-y1);
+	    }
+        else {
+            PyErr_SetString(PyExc_TypeError, "invalid y subscript");
+            return NULL;
+        }
+    } else if (PySlice_Check(x)) {
+        if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w,
+                               &x1, &x2, &xs) ||
+            x1 >= x2 || xs != 1) {
+            PyErr_SetString(PyExc_IndexError, "invalid x slice");
+            return NULL;
+        }
+        if (x1 == 0)
+            x1 = pr->x;
+        if(x1 < pr->x || x2 < pr->x) {
+            PyErr_SetString(PyExc_IndexError, "x subscript out of range");
+            return NULL;
+        }
+
+        if (PyInt_Check(y)) {
+            y1 = PyInt_AsSsize_t(y);
+            if (y1 < pr->y || y1 >= pr->y + pr->h) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return NULL;
+            }
+            ret = PyString_FromStringAndSize(NULL, pr->bpp * (x2 - x1));
+            gimp_pixel_rgn_get_row(pr, (guchar*)PyString_AS_STRING(ret),
+                                   x1, y1, x2 - x1);
+
+        } else if (PySlice_Check(y)) {
+            if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h,
+                                   &y1, &y2, &ys) ||
+                y1 >= y2 || ys != 1) {
+                PyErr_SetString(PyExc_IndexError, "invalid y slice");
+                return NULL;
+            }
+
+            if(y1 == 0)
+                y1 = pr->y;
+            if(y1 < pr->y || y2 < pr->y) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return NULL;
+            }
+
+            ret = PyString_FromStringAndSize(NULL,
+                                             pr->bpp * (x2 - x1) * (y2 - y1));
+            gimp_pixel_rgn_get_rect(pr, (guchar*)PyString_AS_STRING(ret),
+                                    x1, y1, x2 - x1, y2 - y1);
+	    }
+        else {
+            PyErr_SetString(PyExc_TypeError, "invalid y subscript");
+            return NULL;
+        }
+
+    } else {
+        PyErr_SetString(PyExc_TypeError, "invalid x subscript");
+        return NULL;
+    }
+    return ret;
+}
+
+static int
+pr_ass_sub(PyGimpPixelRgn *self, PyObject *v, PyObject *w)
+{
+    GimpPixelRgn *pr = &(self->pr);
+    PyObject *x, *y;
+    const guchar *buf;
+    Py_ssize_t len, x1, x2, xs, y1, y2, ys;
+
+    if (w == NULL) {
+        PyErr_SetString(PyExc_TypeError, "can't delete subscripts");
+        return -1;
+    }
+
+    if (!PyString_Check(w)) {
+        PyErr_SetString(PyExc_TypeError, "must assign string to subscript");
+        return -1;
+    }
+
+    if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) {
+        PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
+        return -1;
+    }
+
+    if (!PyArg_ParseTuple(v, "OO", &x, &y))
+        return -1;
+
+    buf = (const guchar *)PyString_AsString(w);
+    len = PyString_Size(w);
+    if (!buf || len > INT_MAX) {
+        return -1;
+    }
+
+    if (PyInt_Check(x)) {
+        x1 = PyInt_AsSsize_t(x);
+        if (x1 < pr->x || x1 >= pr->x + pr->w) {
+            PyErr_SetString(PyExc_IndexError, "x subscript out of range");
+            return -1;
+        }
+
+        if (PyInt_Check(y)) {
+            y1 = PyInt_AsSsize_t(y);
+
+            if (y1 < pr->y || y1 >= pr->y + pr->h) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return -1;
+            }
+
+            if (len != pr->bpp) {
+                PyErr_SetString(PyExc_TypeError, "string is wrong length");
+                return -1;
+            }
+            gimp_pixel_rgn_set_pixel(pr, buf, x1, y1);
+
+        } else if (PySlice_Check(y)) {
+            if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
+                                   &y1, &y2, &ys) ||
+                y1 >= y2 || ys != 1) {
+                PyErr_SetString(PyExc_IndexError, "invalid y slice");
+                return -1;
+            }
+            if (y1 == 0)
+                y1 = pr->y;
+
+            if(y1 < pr->y || y2 < pr->y) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return -1;
+            }
+            if (len != pr->bpp * (y2 - y1)) {
+                PyErr_SetString(PyExc_TypeError, "string is wrong length");
+                return -1;
+            }
+            gimp_pixel_rgn_set_col(pr, buf, x1, y1, y2 - y1);
+
+        } else {
+            PyErr_SetString(PyExc_IndexError,"invalid y subscript");
+            return -1;
+        }
+    } else if (PySlice_Check(x)) {
+        if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w,
+                               &x1, &x2, &xs) ||
+	        x1 >= x2 || xs != 1) {
+            PyErr_SetString(PyExc_IndexError, "invalid x slice");
+	        return -1;
+        }
+        if(x1 == 0)
+            x1 = pr->x;
+
+        if(x1 < pr->x || x2 < pr->x) {
+            PyErr_SetString(PyExc_IndexError, "x subscript out of range");
+            return -1;
+        }
+
+        if (PyInt_Check(y)) {
+            y1 = PyInt_AsSsize_t(y);
+
+            if (y1 < pr->y || y1 >= pr->y + pr->h) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return -1;
+            }
+
+            if (len != pr->bpp * (x2 - x1)) {
+                PyErr_SetString(PyExc_TypeError, "string is wrong length");
+                return -1;
+            }
+            gimp_pixel_rgn_set_row(pr, buf, x1, y1, x2 - x1);
+
+        } else if (PySlice_Check(y)) {
+            if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
+                                   &y1, &y2, &ys) ||
+                y1 >= y2 || ys != 1) {
+                PyErr_SetString(PyExc_IndexError, "invalid y slice");
+                return -1;
+            }
+            if (y1 == 0)
+                y1 = pr->y;
+
+            if(y1 < pr->y || y2 < pr->y) {
+                PyErr_SetString(PyExc_IndexError, "y subscript out of range");
+                return -1;
+            }
+            if (len != pr->bpp * (x2 - x1) * (y2 - y1)) {
+                PyErr_SetString(PyExc_TypeError, "string is wrong length");
+                return -1;
+            }
+            gimp_pixel_rgn_set_rect(pr, buf, x1, y1, x2 - x1, y2 - y1);
+
+        } else {
+            PyErr_SetString(PyExc_IndexError,"invalid y subscript");
+            return -1;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError, "invalid x subscript");
+        return -1;
+    }
+    return 0;
+}
+
+static PyMappingMethods pr_as_mapping = {
+    pr_length,		/*mp_length*/
+    (binaryfunc)pr_subscript,		/*mp_subscript*/
+    (objobjargproc)pr_ass_sub,	/*mp_ass_subscript*/
+};
+
+/* -------------------------------------------------------- */
+
+static PyObject *
+pr_get_drawable(PyGimpPixelRgn *self, void *closure)
+{
+    return pygimp_drawable_new(self->pr.drawable, 0);
+}
+
+static PyObject *
+pr_get_uint_field(PyGimpPixelRgn *self, void *closure)
+{
+    gint offset = GPOINTER_TO_INT(closure);
+    guint value;
+    gchar *addr;
+
+    addr = (gchar *)&self->pr;
+    addr += offset;
+    value = *(guint *)addr;
+
+    return PyInt_FromLong(value);
+}
+
+static PyObject *
+pr_get_dirty(PyGimpPixelRgn *self, void *closure)
+{
+    return PyBool_FromLong(self->pr.dirty);
+}
+
+static PyObject *
+pr_get_shadow(PyGimpPixelRgn *self, void *closure)
+{
+    return PyBool_FromLong(self->pr.shadow);
+}
+
+#define OFF(x) GINT_TO_POINTER(offsetof(GimpPixelRgn, x))
+static PyGetSetDef pr_getsets[] = {
+    { "drawable", (getter)pr_get_drawable, 0, NULL },
+    { "bpp", (getter)pr_get_uint_field, 0, NULL, OFF(bpp) },
+    { "rowstride", (getter)pr_get_uint_field, 0, NULL, OFF(rowstride) },
+    { "x", (getter)pr_get_uint_field, 0, NULL, OFF(x) },
+    { "y", (getter)pr_get_uint_field, 0, NULL, OFF(y) },
+    { "w", (getter)pr_get_uint_field, 0, NULL, OFF(w) },
+    { "h", (getter)pr_get_uint_field, 0, NULL, OFF(h) },
+    { "dirty", (getter)pr_get_dirty, 0, NULL },
+    { "shadow", (getter)pr_get_shadow, 0, NULL },
+    { NULL, (getter)0, (setter)0 },
+};
+#undef OFF
+
+static PyObject *
+pr_repr(PyGimpPixelRgn *self)
+{
+    PyObject *s;
+    gchar *name;
+
+    name = gimp_item_get_name(self->drawable->drawable->drawable_id);
+    s = PyString_FromFormat("<gimp.PixelRgn for drawable '%s'>", name);
+    g_free(name);
+
+    return s;
+}
+
+PyTypeObject PyGimpPixelRgn_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.PixelRgn",                    /* tp_name */
+    sizeof(PyGimpPixelRgn),             /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)pr_dealloc,             /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)pr_repr,                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    &pr_as_mapping,                     /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,					/* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,	                /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,			/* tp_traverse */
+    (inquiry)0,				/* tp_clear */
+    (richcmpfunc)0,			/* tp_richcompare */
+    0,					/* tp_weaklistoffset */
+    (getiterfunc)0,			/* tp_iter */
+    (iternextfunc)0,			/* tp_iternext */
+    pr_methods,				/* tp_methods */
+    0,					/* tp_members */
+    pr_getsets,				/* tp_getset */
+    (PyTypeObject *)0,			/* tp_base */
+    (PyObject *)0,			/* tp_dict */
+    0,					/* tp_descr_get */
+    0,					/* tp_descr_set */
+    0,					/* tp_dictoffset */
+    (initproc)0,                        /* tp_init */
+    (allocfunc)0,			/* tp_alloc */
+    (newfunc)0,				/* tp_new */
+};
+
+static PyObject *
+pf_get_pixel(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs)
+{
+    int x, y;
+    guchar pixel[4];
+    static char *kwlist[] = { "x", "y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "ii:get_pixel", kwlist,
+                                      &x, &y))
+        return NULL;
+
+    gimp_pixel_fetcher_get_pixel(self->pf, x, y, pixel);
+
+    return PyString_FromStringAndSize((char *)pixel, self->bpp);
+}
+
+static PyObject *
+pf_put_pixel(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs)
+{
+    int x, y, len;
+    guchar *pixel;
+    static char *kwlist[] = { "x", "y", "pixel", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "iis#:put_pixel", kwlist,
+                                      &x, &y, &pixel, &len))
+        return NULL;
+
+    if (len != self->bpp) {
+	PyErr_Format(PyExc_TypeError, "pixel must be %d bpp", self->bpp);
+        return NULL;
+    }
+
+    gimp_pixel_fetcher_put_pixel(self->pf, x, y, pixel);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef pf_methods[] = {
+    {"get_pixel", (PyCFunction)pf_get_pixel, METH_VARARGS | METH_KEYWORDS},
+    {"put_pixel", (PyCFunction)pf_put_pixel, METH_VARARGS | METH_KEYWORDS},
+    {NULL, NULL}
+};
+
+static int
+pf_length(PyGimpPixelFetcher *self)
+{
+    PyErr_SetString(pygimp_error, "Can't get size of pixel fetcher");
+    return -1;
+}
+
+static PyObject *
+pf_subscript(PyGimpPixelFetcher *self, PyObject *key)
+{
+    PyObject *py_x, *py_y;
+    int x, y;
+    guchar pixel[4];
+
+    if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) {
+        PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
+	return NULL;
+    }
+
+    if (!PyArg_ParseTuple(key, "OO", &py_x, &py_y))
+        return NULL;
+
+    if (PyInt_Check(py_x)) {
+        if (PyInt_Check(py_y)) {
+	    x = PyInt_AsLong(py_x);
+            y = PyInt_AsLong(py_y);
+
+            gimp_pixel_fetcher_get_pixel(self->pf, x, y, pixel);
+            return PyString_FromStringAndSize((char *)pixel, self->bpp);
+        } else {
+            PyErr_SetString(PyExc_TypeError, "invalid y subscript");
+            return NULL;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError, "invalid x subscript");
+        return NULL;
+    }
+}
+
+static int
+pf_ass_sub(PyGimpPixelFetcher *self, PyObject *v, PyObject *w)
+{
+    PyObject *py_x, *py_y;
+    int x, y, len;
+    guchar *pixel;
+
+    if (w == NULL) {
+        PyErr_SetString(PyExc_TypeError, "can't delete subscripts");
+        return -1;
+    }
+
+    if (!PyString_Check(w)) {
+        PyErr_SetString(PyExc_TypeError, "must assign string to subscript");
+        return -1;
+    }
+
+    if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) {
+        PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
+        return -1;
+    }
+
+    if (!PyArg_ParseTuple(v, "OO", &py_x, &py_y))
+        return -1;
+
+    pixel = (guchar *)PyString_AsString(w);
+    len = PyString_Size(w);
+
+    if (len != self->bpp) {
+	PyErr_Format(PyExc_TypeError, "pixel must be %d bpp", self->bpp);
+        return -1;
+    }
+
+    if (PyInt_Check(py_x)) {
+        if (PyInt_Check(py_y)) {
+	    x = PyInt_AsLong(py_x);
+            y = PyInt_AsLong(py_y);
+
+            gimp_pixel_fetcher_put_pixel(self->pf, x, y, pixel);
+            return 0;
+        } else {
+            PyErr_SetString(PyExc_TypeError, "invalid y subscript");
+            return -1;
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError, "invalid x subscript");
+        return -1;
+    }
+}
+
+static PyMappingMethods pf_as_mapping = {
+    (lenfunc)pf_length,
+    (binaryfunc)pf_subscript,
+    (objobjargproc)pf_ass_sub,
+};
+
+static PyObject *
+pf_get_bg_color(PyGimpPixelFetcher *self, void *closure)
+{
+    return pygimp_rgb_new(&self->bg_color);
+}
+
+static int
+pf_set_bg_color(PyGimpPixelFetcher *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete bg_color");
+        return -1;
+    }
+
+    if (!pygimp_rgb_from_pyobject(value, &self->bg_color))
+        return -1;
+
+    gimp_pixel_fetcher_set_bg_color(self->pf, &self->bg_color);
+
+    return 0;
+}
+
+static PyObject *
+pf_get_edge_mode(PyGimpPixelFetcher *self, void *closure)
+{
+    return PyInt_FromLong(self->edge_mode);
+}
+
+static int
+pf_set_edge_mode(PyGimpPixelFetcher *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete edge_mode");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    self->edge_mode = PyInt_AsLong(value);
+
+    gimp_pixel_fetcher_set_edge_mode(self->pf, self->edge_mode);
+
+    return 0;
+}
+
+static PyGetSetDef pf_getsets[] = {
+    { "bg_color", (getter)pf_get_bg_color, (setter)pf_set_bg_color },
+    { "edge_mode", (getter)pf_get_edge_mode, (setter)pf_set_edge_mode },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static void
+pf_dealloc(PyGimpPixelFetcher *self)
+{
+    gimp_pixel_fetcher_destroy(self->pf);
+
+    Py_XDECREF(self->drawable);
+
+    PyObject_DEL(self);
+}
+
+static PyObject *
+pf_repr(PyGimpPixelFetcher *self)
+{
+    PyObject *s;
+    char *name;
+
+    name = gimp_item_get_name(self->drawable->drawable->drawable_id);
+
+    if (self->shadow)
+        s = PyString_FromFormat("<gimp.PixelFetcher for drawable '%s' (shadow)>", name);
+    else
+        s = PyString_FromFormat("<gimp.PixelFetcher for drawable '%s'>", name);
+
+    g_free(name);
+
+    return s;
+}
+
+static int
+pf_init(PyGimpPixelFetcher *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpDrawable *drw;
+    gboolean shadow = FALSE;
+    GimpRGB bg_color = { 0.0, 0.0, 0.0, 1.0 };
+    GimpPixelFetcherEdgeMode edge_mode = GIMP_PIXEL_FETCHER_EDGE_NONE;
+    static char *kwlist[] = { "drawable", "shadow", "bg_color", "edge_mode",
+	                      NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!|iO&i:gimp.PixelFetcher.__init__",
+                                     kwlist,
+                                     &PyGimpDrawable_Type, &drw, &shadow,
+                                     pygimp_rgb_from_pyobject, &bg_color,
+                                     &edge_mode))
+        return -1;
+
+    if(!drw->drawable)
+        drw->drawable = gimp_drawable_get(drw->ID);
+
+    self->pf = gimp_pixel_fetcher_new(drw->drawable, shadow);
+
+    Py_INCREF(drw);
+    self->drawable = drw;
+
+    self->shadow = shadow;
+    self->bg_color = bg_color;
+    self->edge_mode = edge_mode;
+
+    self->bpp = gimp_drawable_bpp(drw->drawable->drawable_id);
+
+    gimp_pixel_fetcher_set_bg_color(self->pf, &bg_color);
+    gimp_pixel_fetcher_set_edge_mode(self->pf, edge_mode);
+
+    return 0;
+}
+
+PyTypeObject PyGimpPixelFetcher_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.PixelFetcher",                /* tp_name */
+    sizeof(PyGimpPixelFetcher),         /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)pf_dealloc,             /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)0,                         /* tp_compare */
+    (reprfunc)pf_repr,                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    &pf_as_mapping,                     /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    pf_methods,                         /* tp_methods */
+    0,                                  /* tp_members */
+    pf_getsets,                         /* tp_getset */
+    (PyTypeObject *)0,                  /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)pf_init,                  /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
diff --git a/plug-ins/pygimp/pygimp-util.h b/plug-ins/pygimp/pygimp-util.h
new file mode 100644
index 0000000..9a06432
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-util.h
@@ -0,0 +1,53 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _PYGIMP_UTIL_H_
+#define _PYGIMP_UTIL_H_
+
+#include <Python.h>
+
+#include <glib-object.h>
+
+#include <pygobject.h>
+
+#define pygimp_init_pygobject() G_STMT_START { \
+    PyObject *pygtkmodule = PyImport_ImportModule("pygtk"); \
+    if (pygtkmodule != NULL) { \
+	PyObject *mdict, *require_obj, *require_ver, *require_res; \
+	mdict = PyModule_GetDict(pygtkmodule); \
+	require_obj = PyDict_GetItemString(mdict, "require"); \
+	require_ver = PyString_FromString("2.0"); \
+	require_res = PyObject_CallFunctionObjArgs(require_obj, require_ver, \
+						   NULL); \
+	Py_XDECREF(require_ver); \
+	if (require_res) { \
+	    Py_DECREF(require_res); \
+	    if (PyErr_Occurred()) \
+		return; \
+	} else { \
+	    return; \
+	} \
+    } else { \
+	PyErr_SetString(PyExc_ImportError, \
+	                "could not import pygtk"); \
+	return; \
+    } \
+    init_pygobject(); \
+} G_STMT_END
+
+#endif /* _PYGIMP_UTIL_H_ */
diff --git a/plug-ins/pygimp/pygimp-vectors.c b/plug-ins/pygimp/pygimp-vectors.c
new file mode 100644
index 0000000..7ac400a
--- /dev/null
+++ b/plug-ins/pygimp/pygimp-vectors.c
@@ -0,0 +1,992 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "pygimp.h"
+
+
+static PyObject *vectors_bezier_stroke_new(PyGimpVectors *vectors, int stroke);
+
+
+typedef struct {
+    PyObject_HEAD
+    gint32 vectors_ID;
+    int stroke;
+} PyGimpVectorsStroke;
+
+static PyObject *
+vs_get_length(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double precision;
+    double length;
+
+    static char *kwlist[] = { "precision", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:get_length", kwlist,
+                                     &precision))
+        return NULL;
+
+    length = gimp_vectors_stroke_get_length(self->vectors_ID, self->stroke,
+                                            precision);
+
+    return PyFloat_FromDouble(length);
+}
+
+static PyObject *
+vs_get_point_at_dist(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double dist, precision;
+    double x, y, slope;
+    gboolean valid;
+    PyObject *ret;
+
+    static char *kwlist[] = { "dist", "precision", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "dd:get_point_at_dist", kwlist,
+                                     &dist, &precision))
+        return NULL;
+
+    gimp_vectors_stroke_get_point_at_dist(self->vectors_ID, self->stroke,
+                                          dist, precision,
+                                          &x, &y, &slope, &valid);
+
+    ret = PyTuple_New(4);
+    if (ret == NULL)
+        return NULL;
+
+    PyTuple_SetItem(ret, 0, PyFloat_FromDouble(x));
+    PyTuple_SetItem(ret, 1, PyFloat_FromDouble(y));
+    PyTuple_SetItem(ret, 2, PyFloat_FromDouble(slope));
+    PyTuple_SetItem(ret, 3, PyBool_FromLong(valid));
+
+    return ret;
+}
+
+static PyObject *
+vs_close(PyGimpVectorsStroke *self)
+{
+    gimp_vectors_stroke_close(self->vectors_ID, self->stroke);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+vs_translate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double off_x, off_y;
+
+    static char *kwlist[] = { "off_x", "off_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:translate", kwlist,
+                                     &off_x, &off_y))
+        return NULL;
+
+    gimp_vectors_stroke_translate(self->vectors_ID, self->stroke, off_x, off_y);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vs_scale(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double scale_x, scale_y;
+
+    static char *kwlist[] = { "scale_x", "scale_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:scale", kwlist,
+                                     &scale_x, &scale_y))
+        return NULL;
+
+    gimp_vectors_stroke_scale(self->vectors_ID, self->stroke, scale_x, scale_y);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vs_rotate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double center_x, center_y, angle;
+
+    static char *kwlist[] = { "center_x", "center_y", "angle", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddd:rotate", kwlist,
+                                     &center_x, &center_y, &angle))
+        return NULL;
+
+    gimp_vectors_stroke_rotate(self->vectors_ID, self->stroke, center_x,
+                               center_y, angle);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vs_flip(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    int    flip_type;
+    double axis;
+
+    static char *kwlist[] = { "flip_type", "axis", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "id:flip", kwlist,
+                                     &flip_type, &axis))
+        return NULL;
+
+    gimp_vectors_stroke_flip(self->vectors_ID, self->stroke, flip_type, axis);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vs_flip_free(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double x1,y1,x2,y2;
+
+    static char *kwlist[] = { "x1", "y1", "x2", "y2", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:flip_free", kwlist,
+                                     &x1, &y1, &x2, &y2))
+        return NULL;
+
+    gimp_vectors_stroke_flip_free(self->vectors_ID, self->stroke,
+                                  x1, y1, x2, y2);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+
+static PyObject *
+vs_interpolate(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double precision;
+    double *coords;
+    int i, num_coords;
+    gboolean closed;
+    PyObject *ret, *ret_coords;
+
+    static char *kwlist[] = { "precision", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:interpolate", kwlist,
+                                     &precision))
+        return NULL;
+
+    coords = gimp_vectors_stroke_interpolate(self->vectors_ID, self->stroke,
+                                             precision, &num_coords, &closed);
+
+    ret = PyTuple_New(2);
+    if (ret == NULL)
+        return NULL;
+
+    ret_coords = PyList_New(num_coords);
+    if (ret_coords == NULL) {
+        Py_DECREF(ret);
+        return NULL;
+    }
+
+    for (i = 0; i < num_coords; i++)
+        PyList_SetItem(ret_coords, i, PyFloat_FromDouble(coords[i]));
+
+    PyTuple_SetItem(ret, 0, ret_coords);
+    PyTuple_SetItem(ret, 1, PyBool_FromLong(closed));
+
+    return ret;
+}
+
+static PyMethodDef vs_methods[] = {
+    { "get_length", (PyCFunction)vs_get_length, METH_VARARGS | METH_KEYWORDS },
+    { "get_point_at_dist", (PyCFunction)vs_get_point_at_dist, METH_VARARGS | METH_KEYWORDS },
+    { "close", (PyCFunction)vs_close, METH_NOARGS },
+    { "translate", (PyCFunction)vs_translate, METH_VARARGS | METH_KEYWORDS },
+    { "scale", (PyCFunction)vs_scale, METH_VARARGS | METH_KEYWORDS },
+    { "rotate", (PyCFunction)vs_rotate, METH_VARARGS | METH_KEYWORDS },
+    { "flip", (PyCFunction)vs_flip, METH_VARARGS | METH_KEYWORDS },
+    { "flip_free", (PyCFunction)vs_flip_free, METH_VARARGS | METH_KEYWORDS },
+    { "interpolate", (PyCFunction)vs_interpolate, METH_VARARGS | METH_KEYWORDS },
+    { NULL, NULL, 0 }
+};
+
+static PyObject *
+vs_get_ID(PyGimpVectorsStroke *self, void *closure)
+{
+    return PyInt_FromLong(self->stroke);
+}
+
+static PyObject *
+vs_get_vectors_ID(PyGimpVectorsStroke *self, void *closure)
+{
+    return PyInt_FromLong(self->vectors_ID);
+}
+
+static PyObject *
+vs_get_points(PyGimpVectorsStroke *self, void *closure)
+{
+    double *controlpoints;
+    int i, num_points;
+    gboolean closed;
+    PyObject *ret, *ret_points;
+
+    gimp_vectors_stroke_get_points(self->vectors_ID, self->stroke,
+                                   &num_points, &controlpoints, &closed);
+
+    ret = PyTuple_New(2);
+    if (ret == NULL)
+        return NULL;
+
+    ret_points = PyList_New(num_points);
+    if (ret_points == NULL) {
+        Py_DECREF(ret);
+        return NULL;
+    }
+
+    for (i = 0; i < num_points; i++)
+        PyList_SetItem(ret_points, i, PyFloat_FromDouble(controlpoints[i]));
+
+    PyTuple_SetItem(ret, 0, ret_points);
+    PyTuple_SetItem(ret, 1, PyBool_FromLong(closed));
+
+    return ret;
+}
+
+static PyGetSetDef vs_getsets[] = {
+    { "ID", (getter)vs_get_ID, (setter)0 },
+    { "vectors_ID", (getter)vs_get_vectors_ID, (setter)0 },
+    { "points", (getter)vs_get_points, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static void
+vs_dealloc(PyGimpVectorsStroke *self)
+{
+    PyObject_DEL(self);
+}
+
+static PyObject *
+vs_repr(PyGimpVectorsStroke *self)
+{
+    PyObject *s;
+    char *name;
+
+    name = gimp_item_get_name(self->vectors_ID);
+    s = PyString_FromFormat("<gimp.VectorsStroke %d of gimp.Vectors '%s'>",
+                            self->stroke, name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+vs_cmp(PyGimpVectorsStroke *self, PyGimpVectorsStroke *other)
+{
+    if (self->vectors_ID == other->vectors_ID) {
+        if (self->stroke == other->stroke)
+            return 0;
+        if (self->stroke > other->stroke)
+            return -1;
+        return 1;
+    }
+    if (self->vectors_ID > other->vectors_ID)
+        return -1;
+    return 1;
+}
+
+PyTypeObject PyGimpVectorsStroke_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.VectorsStroke",               /* tp_name */
+    sizeof(PyGimpVectorsStroke),        /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)vs_dealloc,             /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)vs_cmp,                    /* tp_compare */
+    (reprfunc)vs_repr,                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    vs_methods,                         /* tp_methods */
+    0,                                  /* tp_members */
+    vs_getsets,                         /* tp_getset */
+    (PyTypeObject *)0,                  /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)0,                        /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
+
+
+static PyObject *
+vbs_new_moveto(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+    PyGimpVectors *vectors;
+    double x0, y0;
+    int stroke;
+
+    static char *kwlist[] = { "vectors", "x0", "y0", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!dd:new_moveto", kwlist,
+                                     &PyGimpVectors_Type, &vectors,
+                                     &x0, &y0))
+        return NULL;
+
+    stroke = gimp_vectors_bezier_stroke_new_moveto(vectors->ID, x0, y0);
+
+    return vectors_bezier_stroke_new(vectors, stroke);
+}
+
+static PyObject *
+vbs_new_ellipse(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+    PyGimpVectors *vectors;
+    double x0, y0, radius_x, radius_y, angle;
+    int stroke;
+
+    static char *kwlist[] = { "vectors", "x0", "y0", "radius_x", "radius_y",
+                              "angle", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!ddddd:new_ellipse", kwlist,
+                                     &PyGimpVectors_Type, &vectors,
+                                     &x0, &y0, &radius_x, &radius_y, &angle))
+        return NULL;
+
+    stroke = gimp_vectors_bezier_stroke_new_ellipse(vectors->ID, x0, y0,
+                                                    radius_x, radius_y, angle);
+
+    return vectors_bezier_stroke_new(vectors, stroke);
+}
+
+static PyObject *
+vbs_lineto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0;
+
+    static char *kwlist[] = { "x0", "y0", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "dd:lineto", kwlist,
+                                     &x0, &y0))
+        return NULL;
+
+    gimp_vectors_bezier_stroke_lineto(self->vectors_ID, self->stroke, x0, y0);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vbs_conicto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "dddd:conicto", kwlist,
+                                     &x0, &y0, &x1, &y1))
+        return NULL;
+
+    gimp_vectors_bezier_stroke_conicto(self->vectors_ID, self->stroke,
+                                       x0, y0, x1, y1);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vbs_cubicto(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    double x0, y0, x1, y1, x2, y2;
+
+    static char *kwlist[] = { "x0", "y0", "x1", "y1", "x2", "y2", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "dddddd:cubicto", kwlist,
+                                     &x0, &y0, &x1, &y1, &x2, &y2))
+        return NULL;
+
+    gimp_vectors_bezier_stroke_cubicto(self->vectors_ID, self->stroke,
+                                       x0, y0, x1, y1, x2, y2);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef vbs_methods[] = {
+    { "new_moveto", (PyCFunction)vbs_new_moveto, METH_VARARGS | METH_KEYWORDS | METH_CLASS },
+    { "new_ellipse", (PyCFunction)vbs_new_ellipse, METH_VARARGS | METH_KEYWORDS | METH_CLASS },
+    { "lineto", (PyCFunction)vbs_lineto, METH_VARARGS | METH_KEYWORDS },
+    { "conicto", (PyCFunction)vbs_conicto, METH_VARARGS | METH_KEYWORDS },
+    { "cubicto", (PyCFunction)vbs_cubicto, METH_VARARGS | METH_KEYWORDS },
+    { NULL, NULL, 0 }
+};
+
+static PyObject *
+vbs_repr(PyGimpVectorsStroke *self)
+{
+    PyObject *s;
+    char *name;
+
+    name = gimp_item_get_name(self->vectors_ID);
+    s = PyString_FromFormat("<gimp.VectorsBezierStroke %d of gimp.Vectors '%s'>",
+                            self->stroke, name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+vbs_init(PyGimpVectorsStroke *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpVectors *vectors;
+    double *controlpoints;
+    gboolean closed = FALSE;
+    PyObject *py_controlpoints, *item;
+    int i, num_points;
+
+    static char *kwlist[] = { "vectors", "controlpoints", "closed", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!O|i:gimp.VectorsBezierStroke.__init__",
+                                     kwlist,
+                                     &PyGimpVectors_Type, &vectors,
+                                     &py_controlpoints, &closed))
+        return -1;
+
+    if (!PySequence_Check(py_controlpoints)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "controlpoints must be a sequence");
+        return -1;
+    }
+
+    num_points = PySequence_Length(py_controlpoints);
+    controlpoints = g_new(gdouble, num_points);
+
+    for (i = 0; i < num_points; i++) {
+        item = PySequence_GetItem(py_controlpoints, i);
+
+        if (!PyFloat_Check(item)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "controlpoints must be a sequence of floats");
+            g_free(controlpoints);
+            return -1;
+        }
+
+        controlpoints[i] = PyFloat_AsDouble(item);
+    }
+
+    self->vectors_ID = vectors->ID;
+    self->stroke =
+        gimp_vectors_stroke_new_from_points(self->vectors_ID,
+                                            GIMP_VECTORS_STROKE_TYPE_BEZIER,
+                                            num_points, controlpoints, closed);
+
+    g_free(controlpoints);
+
+    return 0;
+}
+
+PyTypeObject PyGimpVectorsBezierStroke_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.VectorsBezierStroke",         /* tp_name */
+    sizeof(PyGimpVectorsStroke),        /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)vs_dealloc,             /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)vs_cmp,                    /* tp_compare */
+    (reprfunc)vbs_repr,                 /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    vbs_methods,                        /* tp_methods */
+    0,                                  /* tp_members */
+    0,                                  /* tp_getset */
+    &PyGimpVectorsStroke_Type,          /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)vbs_init,                 /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
+
+static PyObject *
+vectors_bezier_stroke_new(PyGimpVectors *vectors, int stroke)
+{
+    PyGimpVectorsStroke *self;
+
+    self = PyObject_NEW(PyGimpVectorsStroke, &PyGimpVectorsBezierStroke_Type);
+
+    if (self == NULL)
+        return NULL;
+
+    self->vectors_ID = vectors->ID;
+    self->stroke = stroke;
+
+    return (PyObject *)self;
+}
+
+
+static PyObject *
+vectors_remove_stroke(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
+{
+    int stroke_id ;
+    /* PyGimpVectorsStroke *stroke; */
+    PyObject *stroke = NULL;
+
+    static char *kwlist[] = { "stroke", NULL };
+
+    PyArg_ParseTupleAndKeywords(args, kwargs, "O:remove_stroke", kwlist, &stroke);
+
+    if (PyInt_Check(stroke))
+        stroke_id = PyInt_AsLong(stroke);
+    else if (PyObject_IsInstance(stroke, (PyObject *) &PyGimpVectorsStroke_Type))
+        stroke_id = ((PyGimpVectorsStroke *) stroke)->stroke;
+    else  {
+        PyErr_SetString(PyExc_TypeError, "stroke must be a gimp.VectorsBezierStroke object or an Integer");
+        return NULL;
+    }
+
+    gimp_vectors_remove_stroke(self->ID, stroke_id);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vectors_to_selection(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
+{
+    GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
+    gboolean antialias = TRUE, feather = FALSE;
+    double feather_radius_x = 0.0, feather_radius_y = 0.0;
+
+    static char *kwlist[] = { "operation", "antialias", "feather",
+                              "feather_radius_x", "feather_radius_y", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "|iiidd:to_selection", kwlist,
+                                     &operation, &antialias, &feather,
+                                     &feather_radius_x, &feather_radius_y))
+        return NULL;
+
+    gimp_context_push();
+    gimp_context_set_antialias(antialias);
+    gimp_context_set_feather(feather);
+    gimp_context_set_feather_radius(feather_radius_x, feather_radius_y);
+    gimp_image_select_item(gimp_item_get_image(self->ID), operation, self->ID);
+    gimp_context_pop();
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vectors_parasite_find(PyGimpVectors *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_find", &name))
+        return NULL;
+
+    return pygimp_parasite_new(gimp_item_get_parasite(self->ID, name));
+}
+
+static PyObject *
+vectors_parasite_attach(PyGimpVectors *self, PyObject *args)
+{
+    PyGimpParasite *parasite;
+
+    if (!PyArg_ParseTuple(args, "O!:parasite_attach", &PyGimpParasite_Type,
+                          &parasite))
+        return NULL;
+
+    if (!gimp_item_attach_parasite(self->ID, parasite->para)) {
+        PyErr_Format(pygimp_error,
+                     "could not attach parasite '%s' to vectors (ID %d)",
+                     parasite->para->name, self->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vectors_parasite_detach(PyGimpVectors *self, PyObject *args)
+{
+    char *name;
+
+    if (!PyArg_ParseTuple(args, "s:parasite_detach", &name))
+        return NULL;
+
+    if (!gimp_item_detach_parasite(self->ID, name)) {
+        PyErr_Format(pygimp_error,
+                     "could not detach parasite '%s' from vectors (ID %d)",
+                     name, self->ID);
+        return NULL;
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+vectors_parasite_list(PyGimpVectors *self)
+{
+    gint num_parasites;
+    gchar **parasites;
+    PyObject *ret;
+    gint i;
+
+    parasites = gimp_item_get_parasite_list(self->ID, &num_parasites);
+
+    ret = PyTuple_New(num_parasites);
+
+    for (i = 0; i < num_parasites; i++)
+        PyTuple_SetItem(ret, i, PyString_FromString(parasites[i]));
+
+    g_strfreev(parasites);
+    return ret;
+}
+
+static PyMethodDef vectors_methods[] = {
+    { "remove_stroke",
+      (PyCFunction)vectors_remove_stroke,
+      METH_VARARGS | METH_KEYWORDS },
+    { "to_selection",
+      (PyCFunction)vectors_to_selection,
+      METH_VARARGS | METH_KEYWORDS },
+    { "parasite_find",
+      (PyCFunction)vectors_parasite_find,
+      METH_VARARGS },
+    { "parasite_attach",
+      (PyCFunction)vectors_parasite_attach,
+      METH_VARARGS },
+    { "parasite_detach",
+      (PyCFunction)vectors_parasite_detach,
+      METH_VARARGS },
+    { "parasite_list",
+      (PyCFunction)vectors_parasite_list,
+      METH_NOARGS },
+    { NULL, NULL, 0 }
+};
+
+static PyObject *
+vectors_get_image(PyGimpVectors *self, void *closure)
+{
+    return pygimp_image_new(gimp_item_get_image(self->ID));
+}
+
+static PyObject *
+vectors_get_ID(PyGimpVectors *self, void *closure)
+{
+    return PyInt_FromLong(self->ID);
+}
+
+static PyObject *
+vectors_get_name(PyGimpVectors *self, void *closure)
+{
+    return PyString_FromString(gimp_item_get_name(self->ID));
+}
+
+static int
+vectors_set_name(PyGimpVectors *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete name");
+        return -1;
+    }
+
+    if (!PyString_Check(value) && !PyUnicode_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_name(self->ID, PyString_AsString(value));
+
+    return 0;
+}
+
+static PyObject *
+vectors_get_visible(PyGimpVectors *self, void *closure)
+{
+    return PyBool_FromLong(gimp_item_get_visible(self->ID));
+}
+
+static int
+vectors_set_visible(PyGimpVectors *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete visible");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_visible(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+vectors_get_linked(PyGimpVectors *self, void *closure)
+{
+    return PyBool_FromLong(gimp_item_get_linked(self->ID));
+}
+
+static int
+vectors_set_linked(PyGimpVectors *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete linked");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_linked(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+vectors_get_tattoo(PyGimpVectors *self, void *closure)
+{
+    return PyInt_FromLong(gimp_item_get_tattoo(self->ID));
+}
+
+static int
+vectors_set_tattoo(PyGimpVectors *self, PyObject *value, void *closure)
+{
+    if (value == NULL) {
+        PyErr_SetString(PyExc_TypeError, "cannot delete tattoo");
+        return -1;
+    }
+
+    if (!PyInt_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "type mismatch");
+        return -1;
+    }
+
+    gimp_item_set_tattoo(self->ID, PyInt_AsLong(value));
+
+    return 0;
+}
+
+static PyObject *
+vectors_get_strokes(PyGimpVectors *self, void *closure)
+{
+    int *strokes;
+    int i, num_strokes;
+    PyObject *ret;
+
+    strokes = gimp_vectors_get_strokes(self->ID, &num_strokes);
+
+    ret = PyList_New(num_strokes);
+    if (ret == NULL)
+        return NULL;
+
+    for (i = 0; i < num_strokes; i++)
+        PyList_SetItem(ret, i, vectors_bezier_stroke_new(self, strokes[i]));
+
+    g_free(strokes);
+
+    return ret;
+}
+
+static PyGetSetDef vectors_getsets[] = {
+    { "ID", (getter)vectors_get_ID, (setter)0 },
+    { "image", (getter)vectors_get_image, (setter)0 },
+    { "name", (getter)vectors_get_name, (setter)vectors_set_name },
+    { "visible", (getter)vectors_get_visible, (setter)vectors_set_visible },
+    { "linked", (getter)vectors_get_linked, (setter)vectors_set_linked },
+    { "tattoo", (getter)vectors_get_tattoo, (setter)vectors_set_tattoo },
+    { "strokes", (getter)vectors_get_strokes, (setter)0 },
+    { NULL, (getter)0, (setter)0 }
+};
+
+static void
+vectors_dealloc(PyGimpVectors *self)
+{
+    PyObject_DEL(self);
+}
+
+static PyObject *
+vectors_repr(PyGimpVectors *self)
+{
+    PyObject *s;
+    char *name;
+
+    name = gimp_item_get_name(self->ID);
+    s = PyString_FromFormat("<gimp.Vectors '%s'>", name ? name : "(null)");
+    g_free(name);
+
+    return s;
+}
+
+static int
+vectors_cmp(PyGimpVectors *self, PyGimpVectors *other)
+{
+    if (self->ID == other->ID)
+        return 0;
+    if (self->ID > other->ID)
+        return -1;
+    return 1;
+}
+
+static int
+vectors_init(PyGimpVectors *self, PyObject *args, PyObject *kwargs)
+{
+    PyGimpImage *img;
+    char *name;
+
+    static char *kwlist[] = { "image", "name", NULL };
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+                                     "O!s:gimp.Vectors.__init__",
+                                     kwlist,
+                                     &PyGimpImage_Type, &img, &name))
+        return -1;
+
+    self->ID = gimp_vectors_new(img->ID, name);
+
+    if (self->ID < 0) {
+        PyErr_Format(pygimp_error,
+                     "could not create vectors '%s' on image (ID %d)",
+                     name, img->ID);
+        return -1;
+    }
+
+    return 0;
+}
+
+PyTypeObject PyGimpVectors_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                  /* ob_size */
+    "gimp.Vectors",                     /* tp_name */
+    sizeof(PyGimpVectors),              /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    /* methods */
+    (destructor)vectors_dealloc,        /* tp_dealloc */
+    (printfunc)0,                       /* tp_print */
+    (getattrfunc)0,                     /* tp_getattr */
+    (setattrfunc)0,                     /* tp_setattr */
+    (cmpfunc)vectors_cmp,               /* tp_compare */
+    (reprfunc)vectors_repr,             /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    (hashfunc)0,                        /* tp_hash */
+    (ternaryfunc)0,                     /* tp_call */
+    (reprfunc)0,                        /* tp_str */
+    (getattrofunc)0,                    /* tp_getattro */
+    (setattrofunc)0,                    /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
+    NULL, /* Documentation string */
+    (traverseproc)0,                    /* tp_traverse */
+    (inquiry)0,                         /* tp_clear */
+    (richcmpfunc)0,                     /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    (getiterfunc)0,                     /* tp_iter */
+    (iternextfunc)0,                    /* tp_iternext */
+    vectors_methods,                    /* tp_methods */
+    0,                                  /* tp_members */
+    vectors_getsets,                    /* tp_getset */
+    &PyGimpItem_Type,                   /* tp_base */
+    (PyObject *)0,                      /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0,                                  /* tp_dictoffset */
+    (initproc)vectors_init,             /* tp_init */
+    (allocfunc)0,                       /* tp_alloc */
+    (newfunc)0,                         /* tp_new */
+};
+
+PyObject *
+pygimp_vectors_new(gint32 ID)
+{
+    PyGimpVectors *self;
+
+    if (!gimp_item_is_valid(ID)) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    self = PyObject_NEW(PyGimpVectors, &PyGimpVectors_Type);
+
+    if (self == NULL)
+        return NULL;
+
+    self->ID = ID;
+
+    return (PyObject *)self;
+}
diff --git a/plug-ins/pygimp/pygimp.h b/plug-ins/pygimp/pygimp.h
new file mode 100644
index 0000000..c7d927b
--- /dev/null
+++ b/plug-ins/pygimp/pygimp.h
@@ -0,0 +1,139 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 1997-2002  James Henstridge <james@daa.com.au>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _PYGIMP_H_
+#define _PYGIMP_H_
+
+#include <Python.h>
+
+#include <libgimp/gimp.h>
+
+#define _INSIDE_PYGIMP_
+#include "pygimp-api.h"
+
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#define PyInt_AsSsize_t(o) PyInt_AsLong(o)
+#endif
+
+G_BEGIN_DECLS
+
+extern PyObject *pygimp_error;
+
+PyObject *pygimp_param_to_tuple(int nparams, const GimpParam *params);
+GimpParam *pygimp_param_from_tuple(PyObject *args, const GimpParamDef *ptype,
+                                   int nparams);
+
+
+extern PyTypeObject PyGimpPDB_Type;
+#define pygimp_pdb_check(v) (PyObject_TypeCheck(v, &PyGimpPDB_Type))
+PyObject *pygimp_pdb_new(void);
+
+extern PyTypeObject PyGimpPDBFunction_Type;
+#define pygimp_pdb_function_check(v) (PyObject_TypeCheck(v, &PyGimpPDBFunction_Type))
+PyObject *pygimp_pdb_function_new(const char *name, const char *blurb,
+                                  const char *help, const char *author,
+                                  const char *copyright, const char *date,
+                                  GimpPDBProcType proc_type,
+                                  int n_params, int n_return_vals,
+                                  GimpParamDef *params,
+                                  GimpParamDef *return_vals);
+
+extern PyTypeObject PyGimpImage_Type;
+#define pygimp_image_check(v) (PyObject_TypeCheck(v, &PyGimpImage_Type))
+PyObject *pygimp_image_new(gint32 ID);
+
+extern PyTypeObject PyGimpDisplay_Type;
+#define pygimp_display_check(v) (PyObject_TypeCheck(v, &PyGimpDisplay_Type))
+PyObject *pygimp_display_new(gint32 ID);
+
+extern PyTypeObject PyGimpItem_Type;
+#define pygimp_item_check(v) (PyObject_TypeCheck(v, &PyGimpItem_Type))
+PyObject *pygimp_item_new(gint32 ID);
+
+extern PyTypeObject PyGimpDrawable_Type;
+#define pygimp_drawable_check(v) (PyObject_TypeCheck(v, &PyGimpDrawable_Type))
+PyObject *pygimp_drawable_new(GimpDrawable *drawable, gint32 ID);
+
+extern PyTypeObject PyGimpLayer_Type;
+#define pygimp_layer_check(v) (PyObject_TypeCheck(v, &PyGimpLayer_Type))
+PyObject *pygimp_layer_new(gint32 ID);
+
+extern PyTypeObject PyGimpGroupLayer_Type;
+#define pygimp_layer__group_check(v) (PyObject_TypeCheck(v, &PyGimpGroupLayer_Type))
+PyObject *pygimp_group_layer_new(gint32 ID);
+
+extern PyTypeObject PyGimpChannel_Type;
+#define pygimp_channel_check(v) (PyObject_TypeCheck(v, &PyGimpChannel_Type))
+PyObject *pygimp_channel_new(gint32 ID);
+
+typedef struct {
+    PyObject_HEAD
+    GimpTile *tile;
+    PyGimpDrawable *drawable; /* we keep a reference to the drawable */
+} PyGimpTile;
+
+extern PyTypeObject PyGimpTile_Type;
+#define pygimp_tile_check(v) (PyObject_TypeCheck(v, &PyGimpTile_Type))
+PyObject *pygimp_tile_new(GimpTile *tile, PyGimpDrawable *drw);
+
+typedef struct {
+    PyObject_HEAD
+    GimpPixelRgn pr;
+    PyGimpDrawable *drawable; /* keep the drawable around */
+} PyGimpPixelRgn;
+
+extern PyTypeObject PyGimpPixelRgn_Type;
+#define pygimp_pixel_rgn_check(v) (PyObject_TypeCheck(v, &PyGimpPixelRgn_Type))
+PyObject *pygimp_pixel_rgn_new(PyGimpDrawable *drw, int x, int y,
+                               int w, int h, int dirty, int shadow);
+
+typedef struct {
+    PyObject_HEAD
+    GimpParasite *para;
+} PyGimpParasite;
+
+extern PyTypeObject PyGimpParasite_Type;
+#define pygimp_parasite_check(v) (PyObject_TypeCheck(v, &PyGimpParasite_Type))
+PyObject *pygimp_parasite_new(GimpParasite *para);
+
+extern PyTypeObject PyGimpVectors_Type;
+#define pygimp_vectors_check(v) (PyObject_TypeCheck(v, &PyGimpVectors_Type))
+PyObject *pygimp_vectors_new(gint32 vectors_ID);
+
+extern PyTypeObject PyGimpVectorsStroke_Type;
+extern PyTypeObject PyGimpVectorsBezierStroke_Type;
+
+typedef struct {
+    PyObject_HEAD
+    GimpPixelFetcher *pf;
+    PyGimpDrawable *drawable; /* keep the drawable around */
+    gboolean shadow;
+    GimpRGB bg_color;
+    GimpPixelFetcherEdgeMode edge_mode;
+    int bpp;
+} PyGimpPixelFetcher;
+
+extern PyTypeObject PyGimpPixelFetcher_Type;
+#define pygimp_pixel_fetcher_check(v) (PyObject_TypeCheck(v, &PyGimpPixelFetcher_Type))
+
+G_END_DECLS
+
+#endif
diff --git a/plug-ins/pygimp/pygimpcolor-api.h b/plug-ins/pygimp/pygimpcolor-api.h
new file mode 100644
index 0000000..b741538
--- /dev/null
+++ b/plug-ins/pygimp/pygimpcolor-api.h
@@ -0,0 +1,84 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2005-2006  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _PYGIMPCOLOR_API_H_
+#define _PYGIMPCOLOR_API_H_
+
+#include <Python.h>
+
+#include <libgimpcolor/gimpcolor.h>
+
+struct _PyGimpColor_Functions {
+    PyTypeObject *RGB_Type;
+    PyObject *(* rgb_new)(const GimpRGB *rgb);
+    PyTypeObject *HSV_Type;
+    PyObject *(* hsv_new)(const GimpHSV *hsv);
+    PyTypeObject *HSL_Type;
+    PyObject *(* hsl_new)(const GimpHSL *hsl);
+    PyTypeObject *CMYK_Type;
+    PyObject *(* cmyk_new)(const GimpCMYK *cmyk);
+    int (* rgb_from_pyobject)(PyObject *object, GimpRGB *color);
+};
+
+#ifndef _INSIDE_PYGIMPCOLOR_
+
+#if defined(NO_IMPORT) || defined(NO_IMPORT_PYGIMPCOLOR)
+extern struct _PyGimpColor_Functions *_PyGimpColor_API;
+#else
+struct _PyGimpColor_Functions *_PyGimpColor_API;
+#endif
+
+#define PyGimpRGB_Type (_PyGimpColor_API->RGB_Type)
+#define PyGimpHSV_Type (_PyGimpColor_API->HSV_Type)
+#define PyGimpHSL_Type (_PyGimpColor_API->HSL_Type)
+#define PyGimpCMYK_Type (_PyGimpColor_API->CMYK_Type)
+
+#define pygimp_rgb_check(v) (pyg_boxed_check((v), GIMP_TYPE_RGB))
+#define pygimp_hsv_check(v) (pyg_boxed_check((v), GIMP_TYPE_HSV))
+#define pygimp_hsl_check(v) (pyg_boxed_check((v), GIMP_TYPE_HSL))
+#define pygimp_cmyk_check(v) (pyg_boxed_check((v), GIMP_TYPE_CMYK))
+
+#define pygimp_rgb_new (_PyGimpColor_API->rgb_new)
+#define pygimp_hsv_new (_PyGimpColor_API->hsv_new)
+#define pygimp_hsl_new (_PyGimpColor_API->hsl_new)
+#define pygimp_cmyk_new (_PyGimpColor_API->cmyk_new)
+
+#define pygimp_rgb_from_pyobject (_PyGimpColor_API->rgb_from_pyobject)
+
+#define init_pygimpcolor() G_STMT_START { \
+    PyObject *gimpcolormodule = PyImport_ImportModule("gimpcolor"); \
+    if (gimpcolormodule != NULL) { \
+	PyObject *mdict = PyModule_GetDict(gimpcolormodule); \
+	PyObject *cobject = PyDict_GetItemString(mdict, "_PyGimpColor_API"); \
+	if (PyCObject_Check(cobject)) \
+	    _PyGimpColor_API = PyCObject_AsVoidPtr(cobject); \
+	else { \
+	    PyErr_SetString(PyExc_RuntimeError, \
+		            "could not find _PyGimpColor_API object"); \
+	    return; \
+	} \
+    } else { \
+	PyErr_SetString(PyExc_ImportError, \
+	                "could not import gimpcolor"); \
+	return; \
+    } \
+} G_STMT_END
+
+#endif /* ! _INSIDE_PYGIMPCOLOR_ */
+
+#endif /* _PYGIMPCOLOR_API_H_ */
diff --git a/plug-ins/pygimp/pygimpcolor.h b/plug-ins/pygimp/pygimpcolor.h
new file mode 100644
index 0000000..2e98329
--- /dev/null
+++ b/plug-ins/pygimp/pygimpcolor.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Gimp-Python - allows the writing of Gimp plugins in Python.
+ * Copyright (C) 2003  Manish Singh <yosh@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef _PYGIMPCOLOR_H_
+#define _PYGIMPCOLOR_H_
+
+#include <Python.h>
+
+#include <pygobject.h>
+
+#include <libgimp/gimp.h>
+
+G_BEGIN_DECLS
+
+extern PyTypeObject PyGimpRGB_Type;
+#define pygimp_rgb_check(v) (pyg_boxed_check((v), GIMP_TYPE_RGB))
+PyObject *pygimp_rgb_new(const GimpRGB *rgb);
+
+extern PyTypeObject PyGimpHSV_Type;
+#define pygimp_hsv_check(v) (pyg_boxed_check((v), GIMP_TYPE_HSV))
+PyObject *pygimp_hsv_new(const GimpHSV *hsv);
+
+extern PyTypeObject PyGimpHSL_Type;
+#define pygimp_hsl_check(v) (pyg_boxed_check((v), GIMP_TYPE_HSL))
+PyObject *pygimp_hsl_new(const GimpHSL *hsl);
+
+extern PyTypeObject PyGimpCMYK_Type;
+#define pygimp_cmyk_check(v) (pyg_boxed_check((v), GIMP_TYPE_CMYK))
+PyObject *pygimp_cmyk_new(const GimpCMYK *cmyk);
+
+int pygimp_rgb_from_pyobject(PyObject *object, GimpRGB *color);
+
+G_END_DECLS
+
+#endif