#
# Gtkinter: Wrapper for the gtk module.  This one gives an object oriented
#           feel for the library.  Just type "from Gtkinter import *"
#
# Author: James Henstridge <james@daa.com.au>
#
# TODO
# 1. document some of this (maybe all of it)
# 2. fix up GtkImage (no one has needed it yet so it is low priority)

# The _obj argument in each constructor is used to create a Gtkinter object
# that coresponds to an already created GTK Object.  It should be possible
# to call any of the Gtkinter object constructors something like this:
# GtkContainer(_obj=gtk_obj) where gtk_obj is an already created GtkObject.
#
# To make the use of this system easier, you can use the _obj2inst function
# to create a Gtkinter object of the correct type from a GtkObject.  This
# is the function the new() command uses.

from GTK import *
import GDK    # make the GDK constants available
import _gtk, _gtkbase
import sys, os

# this sets up i18n input stuff
_gtkbase.gtk_set_locale()

# initialise GTK (only if it can find the display -- this avoids segfaults)
if '--display' in sys.argv or os.environ.has_key('DISPLAY'):
	_gtkbase.gtk_init()
	# this makes the _gtk module aware of the types and funcs in _gtkbase
	_gtk.pygtk_init()
else:
	print 'No display information -- gtk_init not called'
del sys, os

class GtkObject:
	get_type = _gtkbase.gtk_object_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def set(self, dict):
		_filtprops(dict)
		_gtkbase.gtk_object_set(self._o, dict)
	def __getitem__(self, key):
		ret = _gtkbase.gtk_object_get(self._o, key)
		if type(ret) == _gtkbase.GtkObjectType:
			return _obj2inst(ret)
		else:
			return ret
	def __setitem__(self, key, v):
		if hasattr(v, '_o') and type(v._o) == _gtkbase.GtkObjectType:
			v = v._o
		_gtkbase.gtk_object_set(self._o, {key: v});
	def __cmp__(self, other):
	        if hasattr(other, '_o'):
			return cmp(self._o, other._o)
		else:
			return cmp(id(self), id(other))
	def flags(self, mask=None):
		if mask:
			return _gtkbase.GTK_OBJECT_FLAGS(self._o) & mask
		else:
			return _gtkbase.GTK_OBJECT_FLAGS(self._o)
	def set_flags(self, flags):
		_gtkbase.GTK_OBJECT_SET_FLAGS(self._o, flags)
	def unset_flags(self, flags):
		_gtkbase.GTK_OBJECT_UNSET_FLAGS(self._o, flags)
	def set_data(self, key, value):
		_gtkbase.gtk_object_set_data(self._o, key, value)
	def get_data(self, key):
		return _gtkbase.gtk_object_get_data(self._o, key)
	def remove_data(self, key):
		_gtkbase.gtk_object_remove_data(self._o)
	class __cnv:
		def __init__(self, func):
			self.func = func
		def __call__(self, *args):
			a = list(args)
			for i in range(len(args)):
				if type(args[i]) == _gtkbase.GtkObjectType:
					a[i] = _obj2inst(args[i])
			a = tuple(a)
			ret = apply(self.func, a)
			if hasattr(ret, '_o'): ret = ret._o
			return ret
	def connect(self, name, f, *extra):
		callback = self.__cnv(f)
		return _gtkbase.gtk_signal_connect(self._o, name,
						   callback.__call__, extra)
	signal_connect = connect
	def connect_after(self, name, f, *extra):
		callback = self.__cnv(f)
		return _gtkbase.gtk_signal_connect_after(self._o, name,
						     callback.__call__, extra)
	signal_connect_after = connect_after
	def disconnect(self, id):
		_gtkbase.gtk_signal_disconnect(self._o, id)
	def signal_handler_block(self, id):
		_gtkbase.gtk_signal_handler_block(self._o, id)
	def signal_handler_unblock(self, id):
		_gtkbase.gtk_signal_handler_unblock(self._o, id)
	def signal_handlers_destroy(self):
		_gtkbase.gtk_signal_handlers_destroy(self._o)
	def emit(self, signal, *args):
		params = []
		for i in args:
			if hasattr(i, '_o'): params.append(i._o)
			elif hasattr(i, '_ag'): params.append(i._ag)
			else: params.append(i)
		return _gtkbase.gtk_signal_emitv_by_name(self._o,signal,params)
	def emit_stop_by_name(self, sig):
		_gtkbase.gtk_signal_emit_stop_by_name(self._o, sig)
	def destroy(self, _obj=None):
		_gtkbase.gtk_object_destroy(self._o)

class GtkData(GtkObject):
	get_type = _gtk.gtk_data_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return

class GtkAdjustment(GtkData):
	get_type = _gtk.gtk_adjustment_get_type
	def __init__(self, value=0, lower=0, upper=0, step_incr=0, page_incr=0,
			page_size=0, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_adjustment_new(value, lower, upper,
					  step_incr, page_incr, page_size)
	def __getattr__(self, attr):
		attrs = {
		'lower': _gtk.gtk_adjustment_get_lower,
		'upper': _gtk.gtk_adjustment_get_upper,
		'value': _gtk.gtk_adjustment_get_value,
		'step_increment': _gtk.gtk_adjustment_get_step_increment,
		'page_increment': _gtk.gtk_adjustment_get_page_increment,
		'page_size': _gtk.gtk_adjustment_get_page_size
		}
		if attr in attrs.keys():
			return attrs[attr](self._o)
		raise AttributeError, attr
	def set_value(self, value):
		_gtk.gtk_adjustment_set_value(self._o, value)
	def clamp_page(self, lower, upper):
		_gtk.gtk_adjustment_clamp_page(self._o, lower, upper)
	def changed(self, obj=None):
		_gtk.gtk_adjustment_changed(self._o)
	def value_changed(self, obj=None):
		_gtk.gtk_adjustment_value_changed(self._o)

class GtkTooltips(GtkData):
	get_type = _gtk.gtk_tooltips_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_tooltips_new()
	def enable(self):
		_gtk.gtk_tooltips_enable(self._o)
	def disable(self, obj=None):
		_gtk.gtk_tooltips_disable(self._o)
	def set_delay(self, delay):
		_gtk.gtk_tooltips_set_delay(self._o, delay)
	def set_tip(self, w, tip, tip_private):
		_gtk.gtk_tooltips_set_tip(self._o, w._o, tip, tip_private)
	def set_tips(self, w, tip):
		print "GtkTooltip.set_tips deprecated -- use set_tip instead"
		self.set_tip(w, tip, tip)
	def set_colors(self, back, fore):
		_gtk.gtk_tooltips_set_colors(self._o, back, fore)
	def force_window(self):
		_gtk.gtk_tooltips_force_window(self._o)

class GtkItemFactory(GtkObject):
	get_type = _gtk.gtk_item_factory_get_type
	def __init__(self, type=_gtk.gtk_menu_bar_get_type(), path='',
		     accel_group=None, _obj=None):
		if _obj: self._o = _obj; return
		if hasattr(type, 'get_type'): type = type.get_type()
		self._o = _gtk.gtk_item_factory_new(type,path,accel_group._ag)
	parse_rc = _gtk.gtk_item_factory_parse_rc
	parse_rc_string = _gtk.gtk_item_factory_parse_rc_string
	def get_widget(self, path):
		return _obj2inst(_gtk.gtk_item_factory_get_widget(self._o,
								  path))
	def get_widget_by_action(self, action):
		return _obj2inst(_gtk.gtk_item_factory_get_widget_by_action(
			self._o, action))
	class __wrap_cb:
		def __init__(self, cb):
			self.cb = cb
		def __call__(self, action, widget):
			self.cb(action, _obj2inst(widget))
	def create_items(self, items):
		def map_func((path,accel,cb,action,type), wrap=self.__wrap_cb):
			if cb:
				return (path,accel,wrap(cb).__call__,action,
					type)
			else:
				return (path,accel,None,action,type)
		items = map(map_func, items)
		_gtk.gtk_item_factory_create_items(self._o, items)
	def delete_item(self, path):
		_gtk.gtk_item_factory_delete_item(self._o, path)
	def popup(self, x, y, button, time):
		_gtk.gtk_item_factory_popup(self._o, x, y, button, time)

class GtkWidget(GtkObject):
	get_type = _gtkbase.gtk_widget_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	# extra parameter is so that these funcs can be used as signal funcs
	def activate(self, obj=None):
		_gtkbase.gtk_widget_activate(self._o)
	def add_accelerator(self, signal, group, key, mods, flags):
		_gtkbase.gtk_widget_add_accelerator(self._o, signal, group._ag,
						key, mods, flags)
	def basic(self, obj=None):
		_gtkbase.gtk_widget_basic(self._o)
	def destroy(self, obj=None):
		_gtkbase.gtk_widget_destroy(self._o)
	def dnd_drag_add(self, obj=None):
		_gtkbase.gtk_widget_dnd_add(self._o)
	def dnd_drag_set(self, enable, types):
		_gtkbase.gtk_widget_dnd_drag_set(self._o, enable, types)
	def dnd_drop_set(self, enable, types, destructive):
		_gtkbase.gtk_widget_dnd_drop_set(self._o, enable, types,
					     destructive)
	def dnd_data_set(self, event, data):
		_gtkbase.gtk_widget_dnd_data_set(self._o, event, data)
	def draw(self, rect):
		_gtkbase.gtk_widget_draw(self._o, rect)
	def draw_children(self, obj=None):
		_gtkbase.gtk_widget_draw_children(self._o)
	def draw_default(self, obj=None):
		_gtkbase.gtk_widget_draw_default(self._o)
	def draw_focus(self, obj=None):
		_gtkbase.gtk_widget_draw_focus(self._o)
	def ensure_style(self):
		_gtkbase.gtk_widget_ensure_style(self._o)
	def event(self, event):
		_gtkbase.gtk_widget_event
	def freeze_accelerators(self):
		_gtkbase.gtk_widget_freeze_accelerators(self._o)
	def get_ancestor(self, type):
		return _obj2inst(_gtkbase.gtk_widget_get_ancestor(self._o, type))
	def get_events(self):
		return _gtkbase.gtk_widget_get_events(self._o)
	def get_extension_events(self):
		return _gtkbase.gtk_widget_get_extension_events(self._o)
	def get_name(self):
		return _gtkbase.gtk_widget_get_name(self._o)
	def get_parent_window(self):
		return _gtkbase.gtk_widget_get_parent_window(self._o)
	def get_pointer(self):
		return _gtkbase.gtk_widget_get_pointer(self._o)
	def get_style(self):
		return _gtkbase.gtk_widget_get_style(self._o)
	def get_toplevel(self):
		return _obj2inst(_gtkbase.gtk_widget_get_toplevel(self._o))
	def get_window(self):
		return _gtkbase.gtk_widget_get_window(self._o)
	def grab_focus(self, obj=None):
		_gtkbase.gtk_widget_grab_focus(self._o)
	def grab_default(self, obj=None):
		_gtkbase.gtk_widget_grab_default(self._o)
	def hide(self, obj=None):
		_gtkbase.gtk_widget_hide(self._o)
	def hide_all(self, obj=None):
		_gtkbase.gtk_widget_hide_all(self._o)
	def hide_on_delete(self, obj=None):
		return _gtkbase.gtk_widget_hide_on_delete(self._o)
	def intersect(self, rect):
		return _gtkbase.gtk_widget_intersect(self._o, rect)
	def is_ancestor(self, a):
		return _gtkbase.gtk_widget_is_ancestor(self._o, a._o)
	def is_child(self, c):
		return _gtkbase.gtk_widget_is_child(self._o, c._o)
	def map(self, obj=None):
		_gtkbase.gtk_widget_map(self._o)
	def popup(self, x, y):
		_gtkbase.gtk_widget_popup(self._o, x, y)
	def queue_draw(self, obj=None):
		_gtkbase.gtk_widget_queue_draw(self._o)
	def queue_resize(self, obj=None):
		_gtkbase.gtk_widget_queue_resize(self._o)
	def realize(self, obj=None):
		_gtkbase.gtk_widget_realize(self._o)
	def remove_accelerator(self, group, key, mods):
		_gtkbase.gtk_widget_remove_accelerator(self._o, group._ag,
						   key, mods)
	def remove_accelerators(self, signal, visible_only):
		_gtkbase.gtk_widget_remove_accelerators(self._o, signal,
						    visible_only)
	def reparent(self, new_parent):
		_gtkbase.gtk_widget_reparent(self._o, new_parent._o)
	def reset_rc_styles(self):
		_gtkbase.gtk_widget_reset_rc_styles(self._o)
	def restore_default_style(self):
		_gtkbase.gtk_widget_restore_default_style(self._o)
	def set_events(self, events):
		_gtkbase.gtk_widget_set_events(self._o, events)
	def set_extension_events(self, exevents):
		_gtkbase.gtk_widget_set_extension_events(self._o, exevents)
	def set_name(self, name):
		_gtkbase.gtk_widget_set_name(self._o, name)
	def set_parent(self, parent):
		_gtkbase.gtk_widget_set_parent(self._o, parent._o)
	def set_parent_window(self, parent):
		_gtkbase.gtk_widget_set_parent_window(self._o, parent)
	def set_sensitive(self, s):
		_gtkbase.gtk_widget_set_sensitive(self._o, s)
	def set_state(self, s):
		_gtkbase.gtk_widget_set_state(self._o, s)
	def set_style(self, style):
		_gtkbase.gtk_widget_set_style(self._o, style)
	def set_rc_style(self):
		_gtkbase.gtk_widget_set_rc_style(self._o)
	def set_uposition(self, x, y):
		_gtkbase.gtk_widget_set_uposition(self._o, x, y)
	def set_usize(self, w, h):
		_gtkbase.gtk_widget_set_usize(self._o, w, h)
	def shape_combine_mask(self, mask, ofs_x, ofs_y):
		if hasattr(mask, '_o'):
			tmp, mask = mask.get()
	        _gtkbase.gtk_widget_shape_combine_mask(self._o, mask, ofs_x, ofs_y)
	def show(self, obj=None):
		_gtkbase.gtk_widget_show(self._o)
	def show_all(self, obj=None):
		_gtkbase.gtk_widget_show_all(self._o)
	def show_now(self, obj=None):
	        _gtkbase.gtk_widget_show_now(self._o)
	def size_allocate(self, a):
		_gtkbase.gtk_widget_size_allocate(self._o, a)
	def size_request(self):
		return _gtkbase.gtk_widget_size_request(self._o)
	def thaw_accelerators(self):
		_gtkbase.gtk_widget_thaw_accelerators(self._o)
	def unmap(self, obj=None):
		_gtkbase.gtk_widget_unmap(self._o)
	def unparent(self):
		_gtkbase.gtk_widget_unparent(self._o)
	def unrealize(self, obj=None):
		_gtkbase.gtk_widget_unrealize(self._o)
	
class GtkContainer(GtkWidget):
	get_type = _gtkbase.gtk_container_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def add(self, child, **args):
		if args == {}:
			_gtkbase.gtk_container_add(self._o, child._o)
		else:
			_gtkbase.gtk_container_add(self._o, child._o, args)
	def border_width(self, bw):
		_gtkbase.gtk_container_border_width(self._o, bw)
	def check_resize(self):
		_gtkbase.gtk_container_check_resize(self._o)
	def child_set(self, child, **args):
		_gtkbase.gtk_container_child_set(self._o, child._o, args)
	def child_get(self, child, arg):
		return _gtkbase.gtk_container_child_get(self._o, child._o, arg)
	def children(self):
		l =  _gtkbase.gtk_container_children(self._o)
		return map(_obj2inst, l)
	def child_type(self):
		return _gtkbase.gtk_container_child_type(self._o)
	def focus(self, d):
		_gtkbase.gtk_container_focus(self._o, d)
	def foreach(self, f):
		for child in self.children():
			f(child)
	def register_toplevel(self):
		_gtkbase.gtk_container_register_toplevel(self._o)
	def remove(self, child):
		_gtkbase.gtk_container_remove(self._o, child._o)
	def resize_children(self):
		_gtkbase.gtk_container_resize_children(self._o)
	def set_focus_child(self, child):
		_gtkbase.gtk_container_set_focus_child(self._o, child._o)
	def set_focus_vadjustment(self, adj):
		_gtkbase.gtk_container_set_focus_vadjustment(self._o, adj._o)
	def set_focus_hadjustment(self, adj):
		_gtkbase.gtk_container_set_focus_hadjustment(self._o, adj._o)
	def set_resize_mode(self, mode):
		_gtkbase.gtk_container_set_resize_mode(self._o, mode)
	def unregister_toplevel(self):
		_gtkbase.gtk_container_unregister_toplevel(self._o)

class GtkBin(GtkContainer):
	get_type = _gtk.gtk_bin_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return

class GtkAlignment(GtkBin):
	get_type = _gtk.gtk_alignment_get_type
	def __init__(self, xa=0, ya=0, xs=0, ys=0, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_alignment_new(xa, ya, xs, ys)
	def set(self, xa, ya, xs, ys):
		_gtk.gtk_alignment_set(self._o, xa, ya, xs, ys)

class GtkButton(GtkBin):
	get_type = _gtk.gtk_button_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_button_new()
		else:
			self._o = _gtk.gtk_button_new_with_label(label)
	def pressed(self, obj=None):
		_gtk.gtk_button_pressed(self._o)
	def released(self, obj=None):
		_gtk.gtk_button_released(self._o)
	def clicked(self, obj=None):
		_gtk.gtk_button_clicked(self._o)
	def enter(self, obj=None):
		_gtk.gtk_button_enter(self._o)
	def leave(self, obj=None):
		_gtk.gtk_button_leave(self._o)
	def set_relief(self, style):
		_gtk.gtk_button_set_relief(self._o, style)
	def get_relief(self):
		return _gtk.gtk_button_get_relief(self._o)

class GtkOptionMenu(GtkButton):
	get_type = _gtk.gtk_option_menu_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_option_menu_new()
	def get_menu(self):
		return _obj2inst(_gtk.gtk_option_menu_get_menu(self._o))
	def set_menu(self, menu):
		_gtk.gtk_option_menu_set_menu(self._o, menu._o)
	def remove_menu(self):
		_gtk.gtk_option_menu_remove_menu(self._o)
	def set_history(self, index):
		_gtk.gtk_option_menu_set_history(self._o, index)

class GtkToggleButton(GtkButton):
	get_type = _gtk.gtk_toggle_button_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_toggle_button_new()
		else:
			self._o = _gtk.gtk_toggle_button_new_with_label(label)
	def __getattr__(self, attr):
	    attrs = {
		    'active': _gtk.gtk_toggle_button_get_active
	    }
	    if attrs.has_key(attr):
		    return attrs[attr](self._o)
	    raise AttributeError, attr
	def set_mode(self, di):
		_gtk.gtk_toggle_button_set_mode(self._o, di)
	def set_state(self, state):
		_gtk.gtk_toggle_button_set_state(self._o, state)
	def toggled(self, obj):
		_gtk.gtk_toggle_button_toggled(self._o)

class GtkCheckButton(GtkToggleButton):
	get_type = _gtk.gtk_check_button_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_check_button_new()
		else:
			self._o = _gtk.gtk_check_button_new_with_label(label)

class GtkRadioButton(GtkCheckButton):
	get_type = _gtk.gtk_radio_button_get_type
	def __init__(self, group=None, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			if group == None:
				self._o = _gtk.gtk_radio_button_new()
			else:
				self._o = \
					_gtk.gtk_radio_button_new_from_widget(
						group._o)
		else:
			if group == None:
				self._o = _gtk.gtk_radio_button_new_with_label(
					None, label)
			else:
				self._o = _gtk.gtk_radio_button_new_with_label_from_widget(group._o, label)

class GtkFrame(GtkBin):
	get_type = _gtk.gtk_frame_get_type
	def __init__(self, label="", _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_frame_new(label)
	def set_label(self, label):
		_gtk.gtk_frame_set_label(self._o, label)
	def set_label_align(self, x, y):
		_gtk.gtk_frame_set_label_align(self._o, x, y)
	def set_shadow_type(self, tp=SHADOW_ETCHED_IN):
		_gtk.gtk_frame_set_shadow_type(self._o, tp)

class GtkAspectFrame(GtkFrame):
	get_type = _gtk.gtk_aspect_frame_get_type
	def __init__(self, xa=0, ya=0, ratio=1, obey_child=1, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_aspect_frame_new(xa, ya, ratio, obey_child)
	def set(self, xa, ya, ratio, obey_child):
		_gtk.gtk_aspect_frame_set(self._o, xa, ya, ratio, obey_child)

class GtkEventBox(GtkBin):
	get_type = _gtk.gtk_event_box_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_event_box_new()

class GtkHandleBox(GtkBin):
	get_type = _gtk.gtk_handle_box_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_handle_box_new()

class GtkItem(GtkBin):
	get_type = _gtk.gtk_item_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def select(self, obj=None):
		_gtk.gtk_item_select(self._o)
	def deselect(self, obj=None):
		_gtk.gtk_item_deselect(self._o)
	def toggle(self, obj=None):
		_gtk.gtk_item_toggle(self._o)

class GtkMenuItem(GtkItem):
	get_type = _gtk.gtk_menu_item_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_menu_item_new()
		else:
			self._o = _gtk.gtk_menu_item_new_with_label(label)
	def set_submenu(self, sub):
		_gtk.gtk_menu_item_set_submenu(self._o, sub._o)
	def set_placement(self, placement):
		_gtk.gtk_menu_item_set_placement(self._o, placement)
	def configure(self, show_toggle, show_sub):
		_gtk.gtk_menu_item_configure(self._o, show_toggle. show_sub)
	def select(self, obj=None):
		_gtk.gtk_menu_item_select(self._o)
	def deselect(self, obj=None):
		_gtk.gtk_menu_item_deselect(self._o)
	def activate(self, obj=None):
		_gtk.gtk_menu_item_activate(self._o)
	def remove_submenu(self):
		_gtk.gtk_menu_item_remove_submenu(self._o)
	def right_justify(self, obj=None):
		_gtk.gtk_menu_item_right_justify(self._o)
		
class GtkCheckMenuItem(GtkMenuItem):
	get_type = _gtk.gtk_check_menu_item_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_check_menu_item_new()
		else:
			self._o =_gtk.gtk_check_menu_item_new_with_label(label)
	def __getattr__(self, attr):
		attrs = {
			'active': _gtk.gtk_check_menu_item_get_active
		}
		if attrs.has_key(attr):
			return attrs[attr](self._o)
		raise AttributeError, attr
	def set_show_toggle(self, always):
		_gtk.gtk_check_menu_item_set_show_toggle(self._o, always)
	def set_state(self, state):
		_gtk.gtk_check_menu_item_set_state(self._o, state)
	def toggled(self, obj=None):
		_gtk.gtk_check_menu_item_toggled(self._o)

class GtkRadioMenuItem(GtkCheckMenuItem):
	get_type = _gtk.gtk_radio_menu_item_get_type
	def __init__(self, group=None, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			if group == None:
				self._o = _gtk.gtk_radio_menu_item_new()
			else:
				self._o =_gtk.gtk_radio_menu_item_new(group._o)
		else:
			if group == None:
				self._o=_gtk.gtk_radio_menu_item_new_with_label(
					None, label)
			else:
				self._o=_gtk.gtk_radio_menu_item_new_with_label(
					group._o, label)

class GtkTearoffMenuItem(GtkMenuItem):
	get_type = _gtk.gtk_tearoff_menu_item_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_tearoff_menu_item_new()

class GtkListItem(GtkItem):
	get_type = _gtk.gtk_list_item_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_list_item_new()
		else:
			self._o = _gtk.gtk_list_item_new_with_label(label)
	def select(self, obj=None):
		_gtk.gtk_list_item_select(self._o)
	def deselect(self, obj=None):
		_gtk.gtk_list_item_deselect(self._o)

class GtkTreeItem(GtkItem):
	get_type = _gtk.gtk_tree_item_get_type
	def __init__(self, label=None, _obj=None):
		if _obj: self._o = _obj; return
		if label == None:
			self._o = _gtk.gtk_tree_item_new()
		else:
			self._o = _gtk.gtk_tree_item_new_with_label(label)
	def set_subtree(self, subtree):
		_gtk.gtk_tree_item_set_subtree(self._o, subtree._o)
	def select(self, obj=None):
		_gtk.gtk_tree_item_select(self._o)
	def deselect(self, obj=None):
		_gtk.gtk_tree_item_deselect(self._o)
	def expand(self, obj=None):
		_gtk.gtk_tree_item_expand(self._o)
	def collapse(self, obj=None):
		_gtk.gtk_tree_item_collapse(self._o)
	def remove_subtree(self):
		_gtk.gtk_tree_item_remove_subtree(self._o)

class GtkViewport(GtkBin):
	get_type = _gtk.gtk_viewport_get_type
	def __init__(self, ha=None, va=None, _obj=None):
		if _obj: self._o = _obj; return
		if ha or va:
			self._o = _gtk.gtk_viewport_new(ha._o, va._o)
		else:
			self._o = _gtk.gtk_viewport_new()
	def get_hadjustment(self):
		return _obj2inst(_gtk.gtk_viewport_get_hadjustment(self._o))
	def get_vdjustment(self):
		return _obj2inst(_gtk.gtk_viewport_get_vadjustment(self._o))
	def set_hadjustment(self, ha):
		_gtk.gtk_viewport_set_hadjustment(self._o, ha._o)
	def set_vadjustment(self, va):
		_gtk.gtk_viewport_set_vadjustment(self._o, va._o)
	def set_shadow_type(self, tp=SHADOW_ETCHED_IN):
		_gtk.gtk_viewport_set_shadow_type(self._o, tp)

class GtkWindow(GtkBin):
	get_type = _gtkbase.gtk_window_get_type
	def __init__(self, type=WINDOW_TOPLEVEL, title=None, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtkbase.gtk_window_new(type)
		if title is not None:
			self.set_title(title)
	def activate_focus(self, obj=None):
		_gtkbase.gtk_window_activate_focus(self._o)
	def activate_default(self, obj=None):
		_gtkbase.gtk_window_activate_default(self._o)
	def set_title(self, title):
		_gtkbase.gtk_window_set_title(self._o, title)
	def set_focus(self, focus):
		_gtkbase.gtk_window_set_focus(self._o, focus._o)
	def set_default(self, defaultw):
		_gtkbase.gtk_window_set_default(self._o, defaultw._o)
	def set_policy(self, as, ag, autos):
		_gtkbase.gtk_window_set_policy(self._o, as, ag, autos)
	def add_accel_group(self, group):
		_gtkbase.gtk_window_add_accel_group(self._o, group._ag)
	def remove_accel_group(self, group):
		_gtkbase.gtk_window_remove_accel_group(self._o, group._ag)
	def position(self, pos):
		_gtkbase.gtk_window_position(self._o, pos)
	def set_wmclass(self, wmc_name, wmc_class):
		_gtkbase.gtk_window_set_wmclass(self._o, wmc_name, wmc_class)
	def set_icon(self, pixmap, mask=None):
		if not mask and hasattr(pixmap, '_o'):
			pixmap, mask = pixmap.get()
		_gtkbase.gtk_window_set_icon(self._o, pixmap, mask)
	def set_icon_name(self, name):
		_gtkbase.gtk_window_set_icon_name(self._o, name)
	def set_modal(self, modal):
		_gtkbase.gtk_window_set_modal(slef._o, modal)

class GtkColorSelectionDialog(GtkWindow):
	get_type = _gtk.gtk_color_selection_dialog_get_type
	def __init__(self, name="", _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_color_selection_dialog_new(name)
	def __getattr__(self, attr):
		attrs = {
			'colorsel':_gtk.gtk_color_selection_dialog_get_colorsel,
			'main_vbox':_gtk.gtk_color_selection_dialog_get_main_vbox,
			'ok_button': _gtk.gtk_color_selection_dialog_get_ok_button,
			'reset_button': _gtk.gtk_color_selection_dialog_get_reset_button,
			'cancel_button': _gtk.gtk_color_selection_dialog_get_cancel_button,
			'help_button': _gtk.gtk_color_selection_dialog_get_help_button
		}
		if attrs.has_key(attr):
			return _obj2inst(attrs[attr](self._o))
		raise AttributeError, attr

class GtkDialog(GtkWindow):
	get_type = _gtk.gtk_dialog_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_dialog_new()
	def __getattr__(self, attr):
		attrs = {
			'vbox': _gtk.gtk_dialog_get_vbox,
			'action_area': _gtk.gtk_dialog_get_action_area
		}
		if attrs.has_key(attr):
			return _obj2inst(attrs[attr](self._o))
		raise AttributeError, attr

class GtkFileSelection(GtkWindow):
	get_type = _gtk.gtk_file_selection_get_type
	def __init__(self, title='', _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_file_selection_new(title)

	def set_filename(self, filename):
		_gtk.gtk_file_selection_set_filename(self._o, filename)
	def get_filename(self):
		return _gtk.gtk_file_selection_get_filename(self._o)
	def __getattr__(self, attr):
		attrs = {
		'cancel_button':   _gtk.gtk_file_selection_get_cancel_button,
		'dir_list':        _gtk.gtk_file_selection_get_dir_list,
		'file_list':       _gtk.gtk_file_selection_get_file_list,
		'help_button':     _gtk.gtk_file_selection_get_help_button,
		'main_vbox':       _gtk.gtk_file_selection_get_main_vbox,
		'ok_button':       _gtk.gtk_file_selection_get_ok_button,
		'selection_entry': _gtk.gtk_file_selection_get_selection_entry,
		'selection_text':  _gtk.gtk_file_selection_get_selection_text
		}
		if not attrs.has_key(attr): raise AttributeError, attr
		return _obj2inst(attrs[attr](self._o))
	def show_fileop_buttons(self):
		_gtk.gtk_file_selection_show_fileop_buttons(self._o)
	def hide_fileop_buttons(self):
		_gtk.gtk_file_selection_hide_fileop_buttons(self._o)

class GtkInputDialog(GtkWindow):
	get_type = _gtk.gtk_input_dialog_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_input_dialog_new()

class GtkFontSelectionDialog(GtkWindow):
	get_type = _gtk.gtk_font_selection_dialog_get_type
	def __init__(self, title=None, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_font_selection_dialog_new(title)
	def __getattr__(self, attr):
		attrs = {
		"fontsel": _gtk.gtk_font_selection_dialog_get_fontsel,
		"main_vbox": _gtk.gtk_font_selection_dialog_get_main_vbox,
		"action_area": _gtk.gtk_font_selection_dialog_get_action_area,
		"ok_button": _gtk.gtk_font_selection_dialog_get_ok_button,
		"apply_button":_gtk.gtk_font_selection_dialog_get_apply_button,
		"cancel_button":
		        _gtk.gtk_font_selection_dialog_get_cancel_button
		}
		if not attrs.has_key(attr): raise AttributeError, attr
		return _obj2inst(attrs[attr](self._o))
	def get_font_name(self):
		return _gtk.gtk_font_selection_dialog_get_font_name(self._o)
	def get_font(self):
		return _gtk.gtk_font_selection_dialog_get_font(self._o)
	def set_font_name(self, name):
		return _gtk.gtk_font_selection_dialog_set_font_name(self._o,
								    name)
	def get_preview_text(self):
		return _gtk.gtk_font_selection_dialog_get_preview_text(self._o)
	def set_preview_text(self, text):
		_gtk.gtk_font_selection_dialog_set_preview_text(self._o, text)

class GtkBox(GtkContainer):
	get_type = _gtk.gtk_box_get_type
	def __init__(self, _obj=None):
		if nonint: return
	def pack_start(self, child, expand=TRUE, fill=TRUE, padding=0):
		_gtk.gtk_box_pack_start(self._o, child._o, expand,fill,padding)
	def pack_end(self, child, expand=TRUE, fill=TRUE, padding=0):
		_gtk.gtk_box_pack_end(self._o, child._o, expand,fill,padding)
	def reorder_child(self, child, pos):
		_gtk.gtk_box_reorder_child(self._o, child._o, pos)
	def set_homogeneous(self, homogeneous):
		_gtk.gtk_box_set_homogeneous(self._o, homogeneous)
	def set_spacing(self, spacing):
		_gtk.gtk_box_set_spacing(self._o, spacing)
	def query_child_packing(self, child):
		return _gtk.gtk_box_query_child_packing(self._o, child._o)
	def set_child_packing(self, child, expand, fill, padding, pack_type):
		_gtk.gtk_box_set_child_packing(self._o, child._o, expand, fill,
					       padding, pack_type)
	def reorder_child(self, child, pos):
		_gtk.gtk_box_reorder_child(self._o, child._o, pos)

class GtkHBox(GtkBox):
	get_type = _gtk.gtk_hbox_get_type
	def __init__(self, homogeneous=0, spacing=0, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_hbox_new(homogeneous, spacing)

class GtkCombo(GtkHBox):
	get_type = _gtk.gtk_combo_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_combo_new()
	def disable_activate(self, obj=None):
		_gtk.gtk_combo_disable_activate(self._o)
	def set_use_arrows(self, val):
		_gtk.gtk_combo_set_use_arrows(self._o, val)
	def set_use_arrows_always(self, val):
		_gtk.gtk_combo_set_use_arrows_always(self._o, val)
	def set_case_sensitive(self, val):
		_gtk.gtk_combo_set_case_sensitive(self._o, val)
	def set_item_string(self, item, val):
		_gtk.gtk_combo_set_item_string(self._o, item._o, val)
	def set_value_in_list(self, val, ok_if_empty):
		_gtk.gtk_combo_set_value_in_list(self._o, val, ok_if_empty)
	def set_popdown_strings(self, strings):
		_gtk.gtk_combo_set_popdown_strings(self._o, strings)
	def __getattr__(self, attr):
		attrs = {
			'entry': _gtk.gtk_combo_get_entry,
			'list':  _gtk.gtk_combo_get_list
	        }
		if attrs.has_key(attr):
			return _obj2inst(attrs[attr](self._o))
		raise AttributeError, attr

class GtkStatusbar(GtkHBox):
	get_type = _gtk.gtk_statusbar_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_statusbar_new()
	def get_context_id(self, desc):
		return _gtk.gtk_statusbar_get_context_id(self._o, desc)
	def pop(self, cid):
		_gtk.gtk_statusbar_pop(self._o, cid)
	def push(self, cid, text):
		return _gtk.gtk_statusbar_push(self._o, cid, text)
	def remove(self, cid, msg_id):
		_gtk.gtk_statusbar_remove(self._o, cid, msg_id)

class GtkVBox(GtkBox):
	get_type = _gtk.gtk_vbox_get_type
	def __init__(self, homogeneous=0, spacing=0, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_vbox_new(homogeneous, spacing)

class GtkColorSelection(GtkVBox):
	get_type = _gtk.gtk_color_selection_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_color_selection_new()
	def set_update_policy(self, p):
		_gtk.gtk_color_selection_set_update_policy(self._o, p)
	def set_opacity(self, use_opacity):
		_gtk.gtk_color_selection_set_opacity(self._o, use_opacity)
	def set_color(self, c):
		_gtk.gtk_color_selection_set_color(self._o, c)
	def get_color(self):
		return _gtk.gtk_color_selection_get_color(self._o)

class GtkGammaCurve(GtkVBox):
	get_type = _gtk.gtk_gamma_curve_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_gamma_curve_new()

class GtkButtonBox(GtkBox):
	get_type = _gtk.gtk_button_box_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def get_child_size_default(self):
		return _gtk.gtk_button_box_get_child_size_default()
	def get_child_ipadding_default(self):
		return _gtk.gtk_button_box_get_child_ipadding_default()
	def set_child_size_default(self, mw, mh):
		_gtk.gtk_button_box_set_child_size_default(mw, mh)
	def set_child_ipadding_default(self, ix, iy):
		_gtk.gtk_button_box_set_child_ipadding_default(ix, iy)
	def get_spacing(self):
		return _gtk.gtk_button_box_get_spacing(self._o)
	def get_layout(self):
		return _gtk.gtk_button_box_get_layout(self._o)
	def get_child_size(self):
		return _gtk.gtk_button_box_get_child_size(self._o)
	def get_child_ipadding(self):
		return _gtk.gtk_button_box_get_child_ipadding(self._o)
	def set_spacing(self, spacing):
		_gtk.gtk_button_box_set_spacing(self._o, spacing)
	def set_layout(self, layout):
		_gtk.gtk_button_box_set_layout(self._o, layout)
	def set_child_size(self, mw, mh):
		_gtk.gtk_button_box_set_child_size(self._o, mw, mh)
	def set_child_ipadding(self, ix, iy):
		_gtk.gtk_button_box_set_child_ipadding(self._o, ix, iy)

class GtkHButtonBox(GtkButtonBox):
	get_type = _gtk.gtk_hbutton_box_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_hbutton_box_new()
	def get_spacing_default(self):
		return _gtk.gtk_hbutton_box_get_spacing_default()
	def get_layout_default(self):
		return _gtk.gtk_hbutton_box_get_layout_default()
	def set_spacing_default(self, spacing):
		_gtk.gtk_hbutton_box_set_spacing_default(spacing)
	def set_layout_default(self, layout):
		_gtk.gtk_hbutton_box_set_layout_default(layout)

class GtkVButtonBox(GtkButtonBox):
	get_type = _gtk.gtk_vbutton_box_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_vbutton_box_new()
	def get_spacing_default(self):
		return _gtk.gtk_vbutton_box_get_spacing_default()
	def get_layout_default(self):
		return _gtk.gtk_vbutton_box_get_layout_default()
	def set_spacing_default(self, spacing):
		_gtk.gtk_vbutton_box_set_spacing_default(spacing)
	def set_layout_default(self, layout):
		_gtk.gtk_vbutton_box_set_layout_default(layout)

class GtkCList(GtkContainer):
	get_type = _gtk.gtk_clist_get_type
	def __init__(self, cols=1, titles=None, _obj=None):
		if _obj: self._o = _obj; return
		if titles == None:
			self._o = _gtk.gtk_clist_new(cols)
		else:
			self._o = _gtk.gtk_clist_new_with_titles(cols, titles)
	def __getattr__(self, attr):
		attrs = {
			'selection':_gtk.gtk_clist_get_selection,
		}
		if attrs.has_key(attr):
			return attrs[attr](self._o)
		else:
			raise AttributeError, attr
	def append(self, values):
		return _gtk.gtk_clist_append(self._o, values)
	def clear(self, obj=None):
		_gtk.gtk_clist_clear(self._o)
	def column_title_active(self, col):
		_gtk.gtk_clist_column_title_active(self._o, col)
	def column_title_passive(self, col):
		_gtk.gtk_clist_column_title_passive(self._o, col)
	def column_titles_active(self, obj=None):
		_gtk.gtk_clist_column_titles_active(self._o)
	def column_titles_hide(self, obj=None):
		_gtk.gtk_clist_column_titles_hide(self._o)
	def column_titles_passive(self, obj=None):
		_gtk.gtk_clist_column_titles_passive(self._o)
	def column_titles_show(self, obj=None):
		_gtk.gtk_clist_column_titles_show(self._o)
	def find_row_from_data(self, data):
		return _gtk.gtk_clist_find_row_from_data(self._o, data)
	def freeze(self, obj=None):
		_gtk.gtk_clist_freeze(self._o)
	def get_cell_type(self, r, c):
		return _gtk.gtk_clist_get_cell_type(self._o, r, c)
	def get_row_data(self, row):
		return _gtk.gtk_clist_get_row_data(self._o, row)
	def get_text(self, r, c):
		return _gtk.gtk_clist_get_text(self._o, r, c)
	def get_pixmap(self, r, c):
		return _gtk.gtk_clist_get_pixmap(self._o, r, c)
	def get_pixtext(self, r, c):
		return _gtk.gtk_clist_get_pixtext(self._o, r, c)
	def get_selectable(self, row):
		return _gtk.gtk_clist_get_selectable(self._o, row)
	def get_selection_info(self, x, y):
		return _gtk.gtk_clist_get_selection_info(self._o, x, y)
	def insert(self, row, values):
		return _gtk.gtk_clist_insert(self._o, row, values)
	def moveto(self, row=-1, col=-1, row_align=0.5, col_align=0.5):
		_gtk.gtk_clist_moveto(self._o, row, col, row_align, col_align)
	def remove(self, row):
		_gtk.gtk_clist_remove(self._o, row)
	def select_all(self):
		_gtk.gtk_clist_select_all(self._o)
	def select_row(self, row, col):
		_gtk.gtk_clist_select_row(self._o, row, col)
	def set_auto_sort(self, auto_sort):
		_gtk.gtk_clist_set_auto_sort(self._o, auto_sort)
	def set_background(self, row, colour):
		_gtk.gtk_clist_set_background(self._o, row, colour)
	def set_border(self, border):
		_gtk.gtk_clist_set_border(self._o, border)
	def set_column_title(self, col, title):
		_gtk.gtk_clist_set_column_title(self._o, col, title)
	def set_column_widget(self, col, w):
		_gtk.gtk_clist_set_column_widget(self._o, col, w._o)
	def set_column_justification(self, col, just):
		_gtk.gtk_clist_set_column_justification(self._o, col, just)
	def set_column_width(self, col, width):
		_gtk.gtk_clist_set_column_width(self._o, col, width)
	def set_foreground(self, row, colour):
		_gtk.gtk_clist_set_foreground(self._o, row, colour)
	def set_policy(self, vsp, hsp):
		_gtk.gtk_clist_set_policy(self._o, vsp, hsp)
	def set_row_data(self, row, data):
		_gtk.gtk_clist_set_row_data(self._o, row, data)
	def set_row_height(self, height):
		_gtk.gtk_clist_set_row_height(self._o, height)
	def set_shift(self, row, col, v, h):
		_gtk.gtk_clist_set_shift(self._o, row, col, v, h)
	def set_selectable(self, row, selectable):
		_gtk.gtk_clist_set_selectable(self._o, row, selectable)
	def set_selection_mode(self, mode):
		_gtk.gtk_clist_set_selection_mode(self._o, mode)
	def set_sort_column(self, col):
		_gtk.gtk_clist_set_sort_column(self._o, col)
	def set_sort_type(self, sort_type):
		_gtk.gtk_clist_set_sort_type(self._o, sort_type)
	def set_text(self, r, c, text):
		_gtk.gtk_clist_set_text(self._o, r, c, text)
	def set_pixmap(self, r, c, pixmap, mask=None):
		if not mask and hasattr(pixmap, '_o'):
			pixmap, mask = pixmap.get()
		_gtk.gtk_clist_set_pixmap(self._o, r, c, pixmap, mask)
	def set_pixtext(self, r, c, text, spacing, pixmap, mask=None):
		if not mask and hasattr(pixmap, '_o'):
			pixmap, mask = pixmap.get()
		_gtk.gtk_clist_set_pixtext(self._o, r, c, text, spacing,
					   pixmap, mask)
	def sort(self):
		_gtk.gtk_clist_sort(self._o)
	def swap_rows(self, row1, row2):
		_gtk.gtk_clist_swap_rows(self._o, row1, row2)
	def thaw(self):
		_gtk.gtk_clist_thaw(self._o)
	def undo_selection(self):
		_gtk.gtk_clist_undo_selection(self._o)
	def unselect_all(self):
		_gtk.gtk_clist_unselect_all(self._o)
	def unselect_row(self, row, col):
		_gtk.gtk_clist_unselect_row(self._o, row, col)

class GtkFixed(GtkContainer):
	get_type = _gtk.gtk_fixed_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_fixed_new()
	def put(self, child, x, y):
		_gtk.gtk_fixed_put(self._o, child._o, x, y)
	def move(self, child, x, y):
		_gtk.gtk_fixed_move(self._o, child._o, x, y)

class GtkList(GtkContainer):
	get_type = _gtk.gtk_list_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_list_new()
	def get_selection(self):
		l = _gtk.gtk_list_get_selection(self._o)
		return map(_obj2inst, l)
	def insert_items(self, items, pos):
		_gtk.gtk_list_insert_items(self._o, items, pos)
	def append_items(self, items):
		items = map(lambda i: i._o, items)
		_gtk.gtk_list_append_items(self._o, items)
	def prepend_items(self, items):
		items = map(lambda i: i._o, items)
		_gtk.gtk_list_prepend_items(self._o, items)
	def remove_items(self, items):
		items = map(lambda i: i._o, items)
		_gtk.gtk_list_remove_items(self._o, items)
	def clear_items(self, start, end):
		_gtk.gtk_list_clear_items(self._o, start, end)
	def select_item(self, item):
		_gtk.gtk_list_select_item(self._o, item._o)
	def unselect_item(self, item):
		_gtk.gtk_list_unselect_item(self._o, item._o)
	def select_child(self, child):
		_gtk.gtk_list_select_child(self._o, child._o)
	def unselect_child(self, child):
		_gtk.gtk_list_unselect_child(self._o, child._o)
	def child_position(self, child):
		return _gtk.gtk_list_child_position(self._o, child._o)
	def set_selection_mode(self, mode):
		_gtk.gtk_list_set_selection_mode(self._o, mode)
	def extend_selection(self, scroll_type, pos, auto):
		_gtk.gtk_list_extend_selection(self._o, scroll_type, pos, auto)
	def start_selection(self):
		_gtk.gtk_list_start_selection(self._o)
	def end_selection(self):
		_gtk.gtk_list_end_selection(self._o)
	def select_all(self):
		_gtk.gtk_list_select_all(self._o)
	def unselect_all(self):
		_gtk.gtk_list_unselect_all(self._o)
	def scroll_horizontal(self, scroll_type, pos):
		_gtk.gtk_list_scroll_horizontal(self._o, scroll_type, pos)
	def scroll_vertical(self, scroll_type, pos):
		_gtk.gtk_list_scroll_vertical(self._o, scroll_type, pos)
	def toggle_add_mode(self):
		_gtk.gtk_list_toggle_add_mode(self._o)
	def toggle_focus_row(self):
		_gtk.gtk_list_toggle_focus_row(self._o)
	def toggle_row(self, item):
		_gtk.gtk_list_toggle_row(self._o, item._o)
	def undo_selection(self):
		_gtk.gtk_list_undo_selection(self._o)
	def end_drag_selection(self):
		_gtk.gtk_list_end_drag_selection(self._o)

class GtkMenuShell(GtkContainer):
	get_type = _gtk.gtk_menu_shell_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def append(self, child):
		_gtk.gtk_menu_shell_append(self._o, child._o)
	def prepend(self, child):
		_gtk.gtk_menu_shell_prepend(self._o, child._o)
	def insert(self, child, pos):
		_gtk.gtk_menu_shell_insert(self._o, child._o, pos)
	def deactivate(self, obj=None):
		_gtk.gtk_menu_shell_deactivate(self._o)
	def select_item(self, item):
		_gtk.gtk_menu_shell_select_item(self._o, item._o)
	def activate_item(self, item, force_deactivate):
		_gtk.gtk_menu_shell_activate_item(self._o, item._o,
						  force_deactivate)

class GtkMenuBar(GtkMenuShell):
	get_type = _gtk.gtk_menu_bar_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_menu_bar_new()
	def append(self, child):
		_gtk.gtk_menu_bar_append(self._o, child._o)
	def prepend(self, child):
		_gtk.gtk_menu_bar_prepend(self._o, child._o)
	def insert(self, child, pos):
		_gtk.gtk_menu_bar_insert(self._o, child._o, pos)

class GtkMenu(GtkMenuShell):
	get_type = _gtk.gtk_menu_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_menu_new()
	def append(self, child):
		_gtk.gtk_menu_append(self._o, child._o)
	def prepend(self, child):
		_gtk.gtk_menu_prepend(self._o, child._o)
	def insert(self, child, pos):
		_gtk.gtk_menu_insert(self._o, child._o, pos)
	def popup(self, pms, pmi, func, button, time):
		_gtk.gtk_menu_popup(self._o, pms._o, pmi._o, func,button,time)
	def reposition(self):
		_gtk.gtk_menu_reposition(self._o)
	def popdown(self, obj=None):
		_gtk.gtk_menu_popdown(self._o)
	def get_active(self):
		return _obj2inst(_gtk.gtk_menu_get_active(self._o))
	def get_attach_widget(self):
		return _obj2inst(_gtk.gtk_menu_get_attach_widget(self._o))
	def detach(self):
		_gtk.gtk_menu_detach(self._o)
	def set_active(self, index):
		_gtk.gtk_menu_set_active(self._o, index)
	def set_accel_group(self, group):
		_gtk.gtk_menu_set_accel_group(self._o, group._ag)
	def set_tearoff_state(self, torn_off):
		_gtk.gtk_menu_set_tearoff_state(self._o, torn_off)

class GtkNotebook(GtkContainer):
	get_type = _gtk.gtk_notebook_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_notebook_new()
	def append_page(self, child, tab):
		_gtk.gtk_notebook_append_page(self._o, child._o, tab._o)
	def append_page_menu(self, child, tab, ml):
		_gtk.gtk_notebook_append_page_menu(self._o, child._o, tab._o,
						   ml._o)
	def prepend_page(self, child, tab):
		_gtk.gtk_notebook_prepend_page(self._o, child._o, tab._o)
	def prepend_page_menu(self, child, tab, ml):
		_gtk.gtk_notebook_prepend_page_menu(self._o, child._o, tab._o,
						    ml._o)
	def insert_page(self, child, tab, pos):
		_gtk.gtk_notebook_insert_page(self._o, child._o, tab._o, pos)
	def insert_page_menu(self, child, tab, ml, pos):
		_gtk.gtk_notebook_insert_page_menu(self._o, child._o, tab._o,
						   ml._o, pos)
	def remove_page(self, pos):
		_gtk.gtk_notebook_remove_page(self._o, pos)
	def current_page(self):
		return _gtk.gtk_notebook_current_page(self._o)
	def page_num(self, child):
		return _gtk.gtk_notebook_page_num(self._o, child._o)
	def set_page(self, pos):
		_gtk.gtk_notebook_set_page(self._o, pos)
	def next_page(self, obj=None):
		_gtk.gtk_notebook_next_page(self._o)
	def prev_page(self, obj=None):
		_gtk.gtk_notebook_prev_page(self._o)
	def reorder_child(self, child, pos):
		_gtk.gtk_notebook_reorder_child(self._o, child._o, pos)
	def set_tab_border(self, border):
		_gtk.gtk_notebook_set_tab_border(self._o, border)
	def set_tab_pos(self, pos):
		_gtk.gtk_notebook_set_tab_pos(self._o, pos)
	def set_scrollable(self, scrollable):
		_gtk.gtk_notebook_set_scrollable(self._o, scrollable)
	def set_show_tabs(self, show):
		_gtk.gtk_notebook_set_show_tabs(self._o, show)
	def set_show_border(self, show):
		_gtk.gtk_notebook_set_show_border(self._o, show)
	def popup_enable(self, obj=None):
		_gtk.gtk_notebook_popup_enable(self._o)
	def popup_disable(self, obj=None):
		_gtk.gtk_notebook_popup_disable(self._o)

class GtkFontSelection(GtkNotebook):
	get_type = _gtk.gtk_font_selection_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_font_selection_new()
	def get_font_name(self):
		return _gtk.gtk_font_selection_get_font_name(self._o)
	def get_font(self):
		return _gtk.gtk_font_selection_get_font(self._o)
	def set_font_name(self, name):
		return _gtk.gtk_font_selection_set_font_name(self._o, name)
	def get_preview_text(self):
		return _gtk.gtk_font_selection_get_preview_text(self._o)
	def set_preview_text(self, text):
		_gtk.gtk_font_selection_set_preview_text(self._o, text)

class GtkPacker(GtkContainer):
	get_type = _gtk.gtk_packer_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_packer_new()
	def add_defaults(self, child, side, anchor, options):
		_gtk.gtk_packer_add_defaults(self._o, child._o, side, anchor,
					     options)
	def add(self, child, side, anchor, options, border_width, pad_x,
		pad_y, i_pad_x, i_pad_y):
		_gtk.gtk_packer_add(self._o, child._o, side, anchor, options,
				    border_width, pad_x, pad_y, i_pad_x,
				    i_pad_y)
	def configure(self, child, side, anchor, options, border_width, pad_x,
		      pad_y, i_pad_x, i_pad_y):
		_gtk.gtk_packer_configure(self._o, child._o, side, anchor,
					  options, border_width, pad_x, pad_y,
					  i_pad_x, i_pad_y)
	def reorder_child(self, child, pos):
		_gtk.gtk_packer_reorder_child(self._o, child._o, pos)
	def set_spacing(self, spacing):
		_gtk.gtk_packer_set_spacing(self._o, spacing)
	def set_default_pad(self, pad_x, pad_y):
		_gtk.gtk_packer_set_default_pad(self._o, pad_x, pad_y)
	def set_default_ipad(self, i_pad_x, i_pad_y):
		_gtk.gtk_packer_set_default_ipad(self._o, i_pad_x, i_pad_y)

class GtkPaned(GtkContainer):
	get_type = _gtk.gtk_paned_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def add1(self, child):
		_gtk.gtk_paned_add1(self._o, child._o)
	def add2(self, child):
		_gtk.gtk_paned_add2(self._o, child._o)
	def handle_size(self, size):
		_gtk.gtk_paned_handle_size(self._o, size)
	def gutter_size(self, size):
		_gtk.gtk_paned_gutter_size(self._o, size)

class GtkHPaned(GtkPaned):
	get_type = _gtk.gtk_hpaned_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_hpaned_new()

class GtkVPaned(GtkPaned):
	get_type = _gtk.gtk_vpaned_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_vpaned_new()

class GtkScrolledWindow(GtkViewport):
	get_type = _gtk.gtk_scrolled_window_get_type
	def __init__(self, hadj=None, vadj=None, _obj=None):
		if _obj: self._o = _obj; return
		if not (vadj or hadj):
			self._o = _gtk.gtk_scrolled_window_new()
		else:
			self._o = _gtk.gtk_scrolled_window_new(hadj._o, vadj._o)
	def get_hadjustment(self):
		return _obj2inst(_gtk.gtk_scrolled_window_get_hadjustment(
			self._o))
	def get_vadjustment(self):
		return _obj2inst(_gtk.gtk_scrolled_window_get_vadjustment(
			self._o))
	def set_policy(self, hp, vp):
		_gtk.gtk_scrolled_window_set_policy(self._o, hp, vp)

class GtkTable(GtkContainer):
	get_type = _gtk.gtk_table_get_type
	def __init__(self, rows=1, cols=1, homogeneous=0, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_table_new(rows, cols, homogeneous)
	def attach(self, child, la, ra, ta, ba, xoptions=EXPAND|FILL,
			yoptions=EXPAND|FILL, xpadding=0, ypadding=0):
		_gtk.gtk_table_attach(self._o, child._o, la,ra,ta,ba,
			xoptions,yoptions, xpadding,ypadding)
	def set_row_spacing(self, row, s):
		_gtk.gtk_table_set_row_spacing(self._o, row, s)
	def set_col_spacing(self, col, s):
		_gtk.gtk_table_set_col_spacing(self._o, col, s)
	def set_row_spacings(self, s):
		_gtk.gtk_table_set_row_spacings(self._o, s)
	def set_col_spacings(self, s):
		_gtk.gtk_table_set_col_spacings(self._o, s)
	def set_homogeneous(self, homogeneous):
	        _gtk.gtk_table_set_homogeneous(self._o, homogeneous)

class GtkTree(GtkContainer):
	get_type = _gtk.gtk_tree_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_tree_new()
	def get_selection(self):
		return map(_obj2inst, _gtk.gtk_tree_get_selection(self._o))
	def append(self, child):
		_gtk.gtk_tree_append(self._o, child._o)
	def prepend(self, child):
		_gtk.gtk_tree_prepend(self._o, child._o)
	def insert(self, child, pos):
		_gtk.gtk_tree_insert(self._o, child._o, pos)
	def remove_item(self, child):
		# fix this when the function starts existing
		#_gtk.gtk_tree_remove_item(self._o, child._o)
		self.remove_items([child])
	def remove_items(self, children):
		children = map(lambda x: x._o, children)
		_gtk.gtk_tree_remove_items(self._o, children)
	def clear_items(self, start, end):
		_gtk.gtk_tree_clear_items(self._o, start, end)
	def select_item(self, item):
		_gtk.gtk_tree_select_item(self._o, item)
	def unselect_item(self, item):
		_gtk.gtk_tree_unselect_item(self._o, item)
	def select_child(self, child):
		_gtk.gtk_tree_select_child(self._o, child._o)
	def unselect_child(self, child):
		_gtk.gtk_tree_unselect_child(self._o, child._o)
	def child_position(self, child):
		return _gtk.gtk_tree_child_position(self._o, child._o)
	def set_selection_mode(self, mode):
		_gtk.gtk_tree_set_selection_mode(self._o, mode)
	def set_view_mode(self, mode):
		_gtk.gtk_tree_set_view_mode(self._o, mode)
	def set_view_lines(self, flag):
		_gtk.gtk_tree_set_view_lines(self._o, flag)

class GtkToolbar(GtkContainer):
	get_type = _gtk.gtk_toolbar_get_type
	def __init__(self, orientation=ORIENTATION_HORIZONTAL,
		     style=TOOLBAR_ICONS, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_toolbar_new(orientation, style)
        def append_item(self, text, tooltip, tp, icon, callback):
		_gtk.gtk_toolbar_append_item(self._o, text, tooltip, tp,
					     icon._o, callback)
	def append_space(self):
		_gtk.gtk_toolbar_append_space(self._o)
	def append_widget(self, w, tooltip, tp):
		_gtk.gtk_toolbar_append_widget(self._o, w._o, tooltip, tp)
	def insert_item(self, text, tooltip, tp, icon, callback, pos):
		_gtk.gtk_toolbar_insert_item(self._o, text, tooltip, tp,
					     icon._o, callback, pos)
	def insert_space(self, pos):
		_gtk.gtk_toolbar_insert_space(self._o, pos)
	def insert_widget(self, w, tooltip, tp, pos):
		_gtk.gtk_toolbar_insert_widget(self._o, w._o, tooltip, tp, pos)
	def prepend_item(self, text, tooltip, tp, icon, callback):
		_gtk.gtk_toolbar_prepend_item(self._o, text, tooltip, tp,
					      icon._o, callback)
	def prepend_space(self):
		_gtk.gtk_toolbar_prepend_space(self._o)
	def prepend_widget(self, w, tooltip, tp):
		_gtk.gtk_toolbar_prepend_widget(self._o, w._o, tooltip, tp)
       	def set_orientation(self, orientation):
		_gtk.gtk_toolbar_set_orientation(self._o, orientation)
	def set_style(self, style):
		_gtk.gtk_toolbar_set_style(self._o, style)
	def set_space_size(self, size):
		_gtk.gtk_toolbar_set_space_size(self._o, size)
	def set_tooltips(self, enable):
		_gtk.gtk_toolbar_set_tooltips(self._o, enable)
	def set_button_relief(self, relief):
		_gtk.gtk_toolbar_set_button_relief(self._o, relief)
	def get_button_relief(self):
		return _gtk.gtk_toolbar_get_button_relief(self._o)

class GtkDrawingArea(GtkWidget):
	get_type = _gtk.gtk_drawing_area_get_type
	def __init__(self, _obj=None):
		self.__win = None
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_drawing_area_new()
	def size(self, w, h):
		_gtk.gtk_drawing_area_size(self._o, w, h)
	def __cache_win(self):
		self.realize()
		self.__win = self.get_window()
	def draw_point(self, gc, x, y):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_point(self.__win, gc, x, y)
	def draw_line(self, gc, x1, y1, x2, y2):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_line(self.__win, gc, x1, y1, x2, y2)
	def draw_rectangle(self, gc, fill, x, y, width, height):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_rectangle(self.__win, gc, fill, x, y,
					width, height)
	def draw_arc(self, gc, x, y, width, height, angle1, angle2):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_arc(self.__win, gc, x, y, width, height, angle1,
				  angle2)
	def draw_polygon(self, gc, fill, points):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_polygon(self.__win, gc, fill, points)
	def draw_string(self, font, gc, x, y, string):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_string(self.__win, font, gc, x, y, string)
	def draw_text(self, font, gc, x, y, text):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_text(self.__win, font, gc, x, y, text)
	def draw_pixmap(self, gc, src, xsrc,ysrc, xdest,ydest, width,height):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_pixmap(self.__win, gc, src, xsrc,ysrc,
				     xdest,ydest, width,height)
	def draw_points(self, gc, points):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_points(self.__win, gc, points)
	def draw_segments(self, gc, segs):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_segments(self.__win, gc, segs)
	def draw_lines(self, gc, points):
		if not self.__win: self.__cache_win()
		_gtk.gdk_draw_lines(self.__win, gc, points)

class GtkCurve(GtkDrawingArea):
	get_type = _gtk.gtk_curve_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_curve_new()
	def reset(self):
		_gtk.gtk_curve_reset(self._o)
	def get_vector(self, size=-1):
		return _gtk.gtk_curve_get_vector(self._o, size)
	def set_vector(self, vector):
		_gtk.gtk_curve_set_vector(self._o, vector)
	def set_gamma(self, g):
		_gtk.gtk_curve_set_gamma(self._o, g)
	def set_range(self, minx,maxx, miny,maxy):
		_gtk.gtk_curve_set_range(self._o, minx,maxx, miny,maxy)
	def set_curve_type(self, tp):
		_gtk.gtk_curve_set_curve_type(self._o, tp)

class GtkEditable(GtkWidget):
	get_type = _gtk.gtk_editable_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def select_region(self, start, end):
		_gtk.gtk_editable_select_region(self._o, start, end)
	def insert_text(self, new_text):
		return _gtk.gtk_editable_insert_text(self._o, new_text)
	def delete_text(self, start, end):
		_gtk.gtk_editable_delete_text(self._o, start, end)
	def get_chars(self, start, end):
		return _gtk.gtk_editable_get_chars(self._o, start, end)
	def cut_clipboard(self):
		_gtk.gtk_editable_cut_clipboard(self._o)
	def copy_clipboard(self):
		_gtk.gtk_editable_copy_clipboard(self._o)
	def paste_clipboard(self):
		_gtk.gtk_editable_paste_clipboard(self._o)
	def claim_selection(self, claim, time):
		_gtk.gtk_editable_claim_selection(self._o, claim, time)
	def delete_selection(self):
		_gtk.gtk_editable_delete_selection(self._o)
	def changed(self):
		_gtk.gtk_editable_changed(self._o)
	def set_position(self, pos):
		_gtk.gtk_editable_set_position(self._o, pos)
	def get_position(self):
		return _gtk.gtk_editable_get_position(self._o)
	def set_editable(self, is_editable):
		_gtk.gtk_editable_set_editable(self._o, is_editable)

class GtkEntry(GtkEditable):
	get_type = _gtk.gtk_entry_get_type
	def __init__(self, maxlen=-1, _obj=None):
		if _obj: self._o = _obj; return
		if maxlen == -1:
			self._o = _gtk.gtk_entry_new()
		else:
			self._o = _gtk.gtk_entry_new_with_max_length(maxlen)
	def set_text(self, text):
		_gtk.gtk_entry_set_text(self._o, text)
	def append_text(self, text):
		_gtk.gtk_entry_append_text(self._o, text)
	def prepend_text(self, text):
		_gtk.gtk_entry_prepend_text(self._o, text)
	def set_position(self, pos):
		_gtk.gtk_entry_set_position(self._o, pos)
	def get_text(self):
		return _gtk.gtk_entry_get_text(self._o)
	def select_region(self, start, stop):
		_gtk.gtk_entry_select_region(self._o, start, stop)
	def set_visibility(self, visible):
		_gtk.gtk_entry_set_visibility(self._o, visible)
	def set_editable(self, editable):
		_gtk.gtk_entry_set_editable(self._o, editable)
	def set_max_length(self, max):
		_gtk.gtk_entry_set_max_length(self._o, max)

class GtkSpinButton(GtkEntry):
	get_type = _gtk.gtk_spin_button_get_type
	def __init__(self, adj=None, climb_rate=1, digits=1, _obj=None):
		if _obj: self._o = _obj; return
		if adj:
			self._o = _gtk.gtk_spin_button_new(adj._o, climb_rate,
							   digits)
		else:
			self._o = _gtk.gtk_spin_button_new_no_adj(climb_rate,
								  digits)
	def set_adjustment(self, adj):
		_gtk.gtk_spin_button_set_adjustment(self._o, adj._o)
	def get_adjustment(self):
		return _obj2inst(_gtk.gtk_spin_button_get_adjustment(sel._o))
	def set_digits(self, digits):
		_gtk.gtk_spin_button_set_digits(self._o, digits)
	def get_value_as_float(self):
		return _gtk.gtk_spin_button_get_value_as_float(self._o)
	def get_value_as_int(self):
		return _gtk.gtk_spin_button_get_value_as_int(self._o)
	get_value = get_value_as_float
	def set_value(self, val):
		_gtk.gtk_spin_button_set_value(self._o, val)
	def set_update_policy(self, pol):
		_gtk.gtk_spin_button_set_update_policy(self._o, pol)
	def set_numeric(self, numeric):
		_gtk.gtk_spin_button_set_numeric(self._o, numeric)
	def spin(self, direction, step):
		_gtk.gtk_spin_button_spin(self._o, direction, step)
	def set_wrap(self, wrap):
	        _gtk.gtk_spin_button_set_wrap(self._o, wrap)
	def set_shadow_type(self, shadow_type):
		_gtk.gtk_spin_button_set_shadow_type(self._o, shadow_type)
	def set_snap_to_ticks(self, snap):
		_gtk.gtk_spin_button_set_snap_to_ticks(self._o, snap)

class GtkText(GtkEditable):
	get_type = _gtk.gtk_text_get_type
	def __init__(self, hadj=None, vadj=None, _obj=None):
		if _obj: self._o = _obj; return
		if not (hadj or vadj):
			self._o = _gtk.gtk_text_new()
		else:
			self._o = _gtk.gtk_text_new(hadj._o, vadj._o)
	def set_editable(self, editable):
		_gtk.gtk_text_set_editable(self._o, editable)
	def set_word_wrap(self, word_wrap):
		_gtk.gtk_text_set_word_wrap(self._o, word_wrap)
	def set_adjustments(self, hadj, vadj):
		_gtk.gtk_text_set_adjustments(self._o, hadj._o, vadj._o)
	def get_hadjustment(self):
		return _obj2inst(_gtk.gtk_text_get_hadjustment(self._o))
	def get_vadjustment(self):
		return _obj2inst(_gtk.gtk_text_get_vadjustment(self._o))
	def set_point(self, point):
		_gtk.gtk_text_set_point(self._o, point)
	def get_point(self):
		return _gtk.gtk_text_get_point(self._o)
	def get_length(self):
		return _gtk.gtk_text_get_length(self._o)
	def freeze(self, obj=None):
		_gtk.gtk_text_freeze(self._o)
	def thaw(self, obj=None):
		_gtk.gtk_text_thaw(self._o)
	def insert(self, font, fg, bg, string):
		_gtk.gtk_text_insert(self._o, font, fg, bg, string,
				     len(string))
	def insert_defaults(self, chars):
		_gtk.gtk_text_insert_defaults(self._o, chars)
	def backward_delete(self, nchars):
		_gtk.gtk_text_backward_delete(self._o, nchars)
	def forward_delete(self, nchars):
		_gtk.gtk_text_forward_delete(self._o, nchars)

class GtkMisc(GtkWidget):
	get_type = _gtk.gtk_misc_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def set_alignment(self, xa, ya):
		_gtk.gtk_misc_set_alignment(self._o, xa, ya)
	def set_padding(self, xp, yp):
		_gtk.gtk_misc_set_padding(self._o, xp, yp)

class GtkArrow(GtkMisc):
	get_type = _gtk.gtk_arrow_get_type
	def __init__(self, at=ARROW_RIGHT, st=SHADOW_OUT, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_arrow_new(at, st)
	def set(self, at, st):
		_gtk.gtk_arrow_set(self._o, at, st)

class GtkImage(GtkMisc):
	get_type = _gtk.gtk_image_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	# XXX should have __init__, set, get

class GtkPixmap(GtkMisc):
	get_type = _gtk.gtk_pixmap_get_type
	def __init__(self, parent_or_pixmap=None, xpm_or_mask=None, bg=None,
		     _obj=None):
		# This function can be called with two argument models:
		# The old model:
		#  GtkPixmap(parent_win, xpm_file, bg_colour)
		# or the one closer to the C version:
		#  GtkPixmap(pixmap, mask)
		if _obj: self._o = _obj; return
		if type(xpm_or_mask) == type(''):
			pix, mask = create_pixmap_from_xpm(parent_or_pixmap,
							   bg, xpm_or_mask)
			self._o = _gtk.gtk_pixmap_new(pix, mask)
		else:
			self._o = _gtk.gtk_pixmap_new(parent_or_pixmap,
						      xpm_or_mask)
	def get(self):
		return _gtk.gtk_pixmap_get(self._o)
	def set(self, pixmap, mask):
		_gtk.gtk_pixmap_set(self._o, pixmap, mask)

class GtkLabel(GtkMisc):
	get_type = _gtk.gtk_label_get_type
	def __init__(self, label="", _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_label_new(label)
	def set(self, str):
		_gtk.gtk_label_set(self._o, str)
	def set_justify(self, jtype):
		_gtk.gtk_label_set_justify(self._o, jtype)
	def set_pattern(self, pattern):
		_gtk.gtk_label_set_pattern(self._o, pattern)
	def get(self):
		return _gtk.gtk_label_get(self._o)
	def parse_uline(self, string):
		return _gtk.gtk_label_parse_uline(self._o, string)

class GtkAccelLabel(GtkLabel):
	get_type = _gtk.gtk_accel_label_get_type
	def __init__(self, string=None, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_accel_label_new(string)
	def accelerator_width(self):
		return _gtk.gtk_accel_label_width(self._o)
	def set_accel_widget(self, widget):
		_gtk.gtk_accel_label_set_accel_widget(self._o, widget._o)
	def refetch(self):
		_gtk.gtk_accel_label_refetch(self._o)

class GtkTipsQuery(GtkLabel):
	get_type = _gtk.gtk_tips_query_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_tips_query_new()
	def start_query(self, obj=None):
		_gtk.gtk_tips_query_start_query(self._o)
	def stop_query(self, obj=None):
		_gtk.gtk_tips_query_stop_query(self._o)
	def set_caller(self, caller):
		_gtk.gtk_tips_query_set_caller(self._o, caller._o)
	def set_labels(self, inactive, no_tip):
		_gtk.gtk_tips_query_set_labels(self._o, inactive, no_tip)

class GtkPreview(GtkWidget):
	get_type = _gtk.gtk_preview_get_type
	def __init__(self, type=PREVIEW_COLOR, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_preview_new(type)
	def size(self, w, h):
		_gtk.gtk_preview_size(self._o, w, h)
	def put(self, win, gc, srcx, srcy, dstx, dsty, width, height):
		_gtk.gtk_preview_put(self._o, win, gc, srcx, srcy,
				     dstx, dsty, width, height)
	def draw_row(self, data, x, y, w=None):
		_gtk.gtk_preview_draw_row(self._o, data, x, y, w or len(data))
	def set_expand(self, expand):
		_gtk.gtk_preview_set_expand(self._o, expand)
	def set_gamma(self, gamma):
		_gtk.gtk_preview_set_gamma(self._o, gamma)
	def set_color_cube(self, nr, ng, nb, ngrey):
		_gtk.gtk_preview_set_color_cube(self._o, nr,ng,nb, ngrey)
	def set_install_cmap(self, install):
		_gtk.gtk_preview_set_install_cmap(install)
	def set_reserved(self, reserved):
		_gtk.gtk_preview_set_reserved(reserved)
	def set_dither(self, dither):
		_gtk.gtk_preview_set_dither(self._o, dither)

class GtkProgress(GtkWidget):
	get_type = _gtk.gtk_progress_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def set_show_text(self, show_text):
		_gtk.gtk_progress_set_show_text(self._o, show_text)
	def set_text_alignment(self, x_align, y_align):
		_gtk.gtk_progress_set_text_alignment(self._o, x_align,
						     y_align)
	def set_format_string(self, format):
		_gtk.gtk_progress_set_format_string(self._o, format)
	def set_adjustment(self, adj):
		_gtk.gtk_progress_set_adjustment(self._o, adj._o)
	def reconfigure(self, value, min, max):
		_gtk.gtk_progress_reconfigure(self._o, value, min, max)
	def set_percentage(self, pcnt):
		_gtk.gtk_progress_set_percentage(self._o, pcnt)
	def set_value(self, value):
		_gtk.gtk_progress_set_value(self._o, value)
	def get_value(self):
		return _gtk.gtk_progress_get_value(self._o)
	def set_activity_mode(self, activity_mode):
		_gtk.gtk_progress_set_activity_mode(self._o, activity_mode)
	def get_current_text(self):
		return _gtk.gtk_progress_get_current_text(self._o)
	def get_text_from_value(self, value):
		return _gtk.gtk_progress_get_text_from_value(self._o, value)
	def get_current_percentage(self):
		return _gtk.gtk_progress_get_percentage(self._o)
	def get_percentage_from_value(self, value):
		return _gtk.gtk_progress_get_percentage_from_value(self._o,
								   value)

class GtkProgressBar(GtkProgress):
	get_type = _gtk.gtk_progress_bar_get_type
	def __init__(self, adjustment=None, _obj=None):
		if _obj: self._o = _obj; return
		if adjustment:
			self._o = _gtk.gtk_progress_bar_new_with_adjustment(
				adjustment._o)
		else:
			self._o = _gtk.gtk_progress_bar_new()
	def set_bar_style(self, style):
		_gtk.gtk_progress_bar_set_bar_style(self._o, style)
	def set_discrete_blocks(self, blocks):
		_gtk.gtk_progress_bar_set_discrete_blocks(self._o, blocks)
	def set_activity_step(self, step):
		_gtk.gtk_progress_bar_set_activity_step(self._o, step)
	def set_activity_blocks(self, blocks):
		_gtk.gtk_progress_bar_set_activity_blocks(self._o, blocks)
	def set_orientation(self, orient):
		_gtk.gtk_progress_bar_set_orientation(self._o, orient)
	def update(self, pcnt):
		_gtk.gtk_progress_bar_update(self._o, pcnt)

class GtkRange(GtkWidget):
	get_type = _gtk.gtk_range_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def get_adjustment(self):
		return _obj2inst(_gtk.gtk_range_get_adjustment(self._o))
	def set_update_policy(self, pol):
		_gtk.gtk_range_set_update_policy(self._o, pol)
	def set_adjustment(self, adj):
		_gtk.gtk_range_set_adjustment(self._o, adj._o)
	def draw_background(self, obj=None):
		_gtk.gtk_range_draw_background(self._o)
	def draw_trough(self, obj=None):
		_gtk.gtk_range_draw_trough(self._o)
	def draw_step_forw(self, obj=None):
		_gtk.gtk_range_draw_step_forw(self._o)
	def draw_step_back(self, obj=None):
		_gtk.gtk_range_draw_step_back(self._o)

class GtkScale(GtkRange):
	get_type = _gtk.gtk_scale_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def set_digits(self, digits):
		_gtk.gtk_scale_set_digits(self._o, digits)
	def set_draw_value(self, draw_value):
		_gtk.gtk_scale_set_draw_value(self._o, draw_value)
	def set_value_pos(self, pos):
		_gtk.gtk_scale_set_value_pos(self._o, pos)
	def value_width(self):
		return _gtk.gtk_scale_value_width(self._o)
	def draw_value(self, obj=None):
		_gtk.gtk_scale_draw_value(self._o)

class GtkHScale(GtkScale):
	get_type = _gtk.gtk_hscale_get_type
	def __init__(self, adj=None, _obj=None):
		if _obj: self._o = _obj; return
		if adj:
			self._o = _gtk.gtk_hscale_new(adj._o)
		else:
			self._o = _gtk.gtk_hscale_new()

class GtkVScale(GtkScale):
	get_type = _gtk.gtk_vscale_get_type
	def __init__(self, adj=None, _obj=None):
		if _obj: self._o = _obj; return
		if adj:
			self._o = _gtk.gtk_vscale_new(adj._o)
		else:
			self._o = _gtk.gtk_vscale_new()

class GtkScrollbar(GtkRange):
	get_type = _gtk.gtk_scrollbar_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return

class GtkHScrollbar(GtkScrollbar):
	get_type = _gtk.gtk_hscrollbar_get_type
	def __init__(self, adj=None, _obj=None):
		if _obj: self._o = _obj; return
		if adj:
			self._o = _gtk.gtk_hscrollbar_new(adj._o)
		else:
			self._o = _gtk.gtk_hscrollbar_new()

class GtkVScrollbar(GtkScrollbar):
	get_type = _gtk.gtk_vscrollbar_get_type
	def __init__(self, adj=None, _obj=None):
		if _obj: self._o = _obj; return
		if adj:
			self._o = _gtk.gtk_vscrollbar_new(adj._o)
		else:
			self._o = _gtk.gtk_vscrollbar_new()

class GtkRuler(GtkWidget):
	get_type = _gtk.gtk_ruler_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
	def set_metric(self, metric):
		_gtk.gtk_ruler_set_metric(self._o, metric)
	def set_range(self, lo, up, pos, max):
		_gtk.gtk_ruler_set_range(self._o, lo, up, pos, max)
	def draw_ticks(self, obj=None):
		_gtk.gtk_ruler_draw_ticks(self._o)
	def draw_pos(self, obj=None):
		_gtk.gtk_ruler_draw_pos(self._o)

class GtkHRuler(GtkRuler):
	get_type = _gtk.gtk_hruler_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_hruler_new()

class GtkVRuler(GtkRuler):
	get_type = _gtk.gtk_vruler_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_vruler_new()

class GtkSeparator(GtkWidget):
	get_type = _gtk.gtk_separator_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return

class GtkHSeparator(GtkSeparator):
	get_type = _gtk.gtk_hseparator_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_hseparator_new()

class GtkVSeparator(GtkSeparator):
	get_type = _gtk.gtk_vseparator_get_type
	def __init__(self, _obj=None):
		if _obj: self._o = _obj; return
		self._o = _gtk.gtk_vseparator_new()


_name2cls = {}
_supported = map(lambda x: eval(x), filter(lambda x: x[:3] == 'Gtk', dir()))
for m in _supported:
	_name2cls[m.__name__] = m
del m

class GtkAccelGroup:
	def __init__(self, _obj=None):
		if _obj: self._ag = _obj; return
		self._ag = _gtkbase.gtk_accel_group_new()
	def activate(self, key, mods):
		_gtkbase.gtk_accel_group_activate(self._ag, key, mods)
	def attach(self, obj):
		_gtkbase.gtk_accel_group_attach(self._ag, obj._o)
	def detach(self, obj):
		_gtkbase.gtk_accel_group_detach(self._ag, obj._o)
	def lock(self):
		_gtkbase.gtk_accel_group_lock(self._ag)
	def unlock(self):
		_gtkbase.gtk_accel_group_unlock(self._ag)
	def lock_entry(self, key, mods):
		_gtkbase.gtk_accel_group_lock_entry(self._ag, key, mods)
	def unlock_entry(self, key, mods):
		_gtkbase.gtk_accel_group_unlock_entry(self._ag, key, mods)
	def add(self, key, mods, flags, obj, signal):
		_gtkbase.gtk_accel_group_add(self._ag, key, mods, flags,
					 obj._o, signal)
	def remove(self, key, mods, obj):
		_gtkbase.gtk_accel_group_remove(self._ag, key, mods, obj._o)

def _obj2inst(obj):
	objname = _gtkbase.gtk_type_name(_gtkbase.GTK_OBJECT_TYPE(obj))
	if _name2cls.has_key(objname):
		return _name2cls[objname](_obj=obj)
	# if I don't know what the object is, guess
	elif _gtk.GTK_CHECK_TYPE(obj, GtkBox.get_type()):
		return GtkBox(_obj=obj)
	elif _gtk.GTK_CHECK_TYPE(obj, GtkBin.get_type()):
		return GtkBin(_obj=obj)
	elif _gtk.GTK_CHECK_TYPE(obj, GtkWindow.get_type()):
		return GtkWindow(_obj=obj)
	elif _gtk.GTK_CHECK_TYPE(obj, GtkContainer.get_type()):
		return GtkContainer(_obj=obj)
	elif _gtk.GTK_CHECK_TYPE(obj, GtkWidget.get_type()):
		return GtkWidget(_obj=obj)
	else:
		return GtkObject(_obj=obj)

def _filtprops(props):
	for k in props.keys():
		v = props[k]
		if hasattr(v, '_o') and type(v._o) == _gtkbase.GtkObjectType:
			props[k] = v._o

def new(tp, **props):
	if type(tp) == type(GtkObject):
		tp = tp.get_type()
	elif type(tp) == type('forty-two'): 
		tp = _name2cls[tp].get_type()
	elif type(tp) != type(0):
		raise TypeError, "unknow type argument: " + tp
	_filtprops(props)
	return _obj2inst(_gtkbase.gtk_object_new(tp, props))

# flow control
def mainloop():
	_gtkbase.gtk_main()
def mainquit(*args):
	_gtkbase.gtk_main_quit()
def mainiteration(block=TRUE):
	return _gtkbase.gtk_main_iteration(block)
def events_pending():
	return _gtkbase.gtk_events_pending()

# idle/quit/timeout handlers
def idle_add(callback):
	return _gtkbase.gtk_idle_add(callback)
def idle_add_priority(priority, callback):
	return _gtkbase.gtk_idle_add_priority(priority, callback)
def idle_remove(tag):
	_gtkbase.gtk_idle_remove(tag)
def quit_add(mainlevel, callback):
        return _gtkbase.gtk_quit_add(mainlevel, callback)
def quit_add_destroy(mainlevel, object):
	_gtkbase.gtk_quit_add_destroy(mainlevel, object._o)
def quit_remove(tag):
	_gtkbase.gtk_quit_remove(tag)
def timeout_add(timeout, callback):
	return _gtkbase.gtk_timeout_add(timeout, callback)
def timeout_remove(tag):
	_gtkbase.gtk_timeout_remove(tag)

# input (file handle) handler
def input_add(source, condition, callback):
	if hasattr(source, 'fileno'):
		# handle python file handles
		def wrapper(source, condition, real_s=source,real_cb=callback):
			real_cb(real_s, condition)
		return _gtkbase.gtk_input_add(source.fileno(), condition, wrapper)
	else:
		return _gtkbase.gtk_input_add(source, condition, callback)
def input_remove(tag):
	_gtkbase.gtk_input_remove(tag)

# these functions govern modality
def grab_add(wid):
	_gtkbase.gtk_grab_add(wid._o)
def grab_remove(wid):
	_gtkbase.gtk_grab_remove(wid._o)

# RC parsing
def rc_parse(fname):
	_gtkbase.gtk_rc_parse(fname)
def rc_parse_string(string):
	_gtkbase.gtk_rc_parse_string(string)

# font loading
def load_font(font):
	return _gtk.gdk_font_load(font)
def load_fontset(fontset):
	return _gtk.gdk_fontset_load(fontset)

# colour allocation
def colour_alloc(parent, red, green=None, blue=None):
	if hasattr(parent, '_o'): cmap = parent.get_window().colormap
	elif hasattr(parent, 'colormap'): cmap = parent.colormap
	else: cmap = parent
	if type(red) == type(''):
		return cmap.alloc(red)
	# red assumed to be an int
	if green == None and blue == None:
		green, blue = divmod(red, 256)
		red, green  = divmod(green, 256)
		red = red % 256

		red   = (red   + 1) * 256 - 1
		green = (green + 1) * 256 - 1
		blue  = (blue  + 1) * 256 - 1
	return cmap.alloc(red, green, blue)
# This one's for the Americans...
color_alloc = colour_alloc

# pixmap loading
def create_pixmap_from_xpm(window, bg, xpm):
	if hasattr(window, '_o'):
		window.realize()
		window = window.get_window()
	return _gtk.gdk_pixmap_create_from_xpm(window, bg, xpm)
def create_pixmap(window, width, height, depth=-1):
	if (hasattr(window, '_o')):
	        window.realize()
		window = window.get_window()
	return _gtk.gdk_pixmap_new(window, width, height, depth)

# drawing functions...
def draw_point(drawable, gc, x, y):
	_gtk.gdk_draw_point(drawable, gc, x, y)
def draw_line(drawable, gc, x1, y1, x2, y2):
	_gtk.gdk_draw_line(drawable, gc, x1, y1, x2, y2)
def draw_rectangle(drawable, gc, fill, x, y, width, height):
	_gtk.gdk_draw_rectangle(drawable, gc, fill, x, y,
				width, height)
def draw_arc(drawable, gc, x, y, width, height, angle1, angle2):
	_gtk.gdk_draw_arc(drawable, gc, x, y, width, height, angle1,
			  angle2)
def draw_polygon(drawable, gc, fill, points):
	_gtk.gdk_draw_polygon(drawable, gc, fill, points)
def draw_string(drawable, font, gc, x, y, string):
	_gtk.gdk_draw_string(drawable, font, gc, x, y, string)
def draw_text(drawable, font, gc, x, y, text):
	_gtk.gdk_draw_text(drawable, font, gc, x, y, text)
def draw_pixmap(drawable, gc, src, xsrc,ysrc, xdest,ydest, width,height):
	_gtk.gdk_draw_pixmap(drawable, gc, src, xsrc,ysrc,
			     xdest,ydest, width,height)
def draw_points(drawable, gc, points):
	_gtk.gdk_draw_points(drawable, gc, points)
def draw_segments(drawable, gc, segs):
	_gtk.gdk_draw_segments(drawable, gc, segs)
def draw_lines(drawable, gc, points):
	_gtk.gdk_draw_lines(drawable, gc, points)