R/gtkFuncs.R

In RGtk2: R Bindings for Gtk 2.8.0 and Above

gtkObjectFlags <-
function(object)
{
  checkPtrType(object, "GtkObject")

  w <- .RGtkCall("S_GTK_OBJECT_FLAGS", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkWidgetSetFlags <-
function(wid, flags)
{
  checkPtrType(wid, "GtkWidget")
  

  w <- .RGtkCall("S_GTK_WIDGET_SET_FLAGS", wid, flags, PACKAGE = "RGtk2")

  return(w)
} 


gtkWidgetUnsetFlags <-
function(wid, flags)
{
  checkPtrType(wid, "GtkWidget")
  

  w <- .RGtkCall("S_GTK_WIDGET_UNSET_FLAGS", wid, flags, PACKAGE = "RGtk2")

  return(w)
} 


gtkWidgetIsSensitive <-
function(wid)
{
  checkPtrType(wid, "GtkWidget")

  w <- .RGtkCall("S_GTK_WIDGET_IS_SENSITIVE", wid, PACKAGE = "RGtk2")

  return(w)
} 


gtkWidgetState <-
function(wid)
{
  checkPtrType(wid, "GtkWidget")

  w <- .RGtkCall("S_GTK_WIDGET_STATE", wid, PACKAGE = "RGtk2")

  return(w)
} 


gtkWidgetSavedState <-
function(wid)
{
  checkPtrType(wid, "GtkWidget")

  w <- .RGtkCall("S_GTK_WIDGET_SAVED_STATE", wid, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeRow <-
function(node)
{
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_GTK_CTREE_ROW", node, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_about_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_about_dialog_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkAboutDialogGetName <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("getProgramName", "RGtk2")

  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetName <-
function(object, name = NULL)
{
  if(getOption("depwarn"))
    .Deprecated("setProgramName", "RGtk2")

  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( name )) name <- as.character(name)

  w <- .RGtkCall("S_gtk_about_dialog_set_name", object, name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetVersion <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_version", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetVersion <-
function(object, version = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( version )) version <- as.character(version)

  w <- .RGtkCall("S_gtk_about_dialog_set_version", object, version, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetCopyright <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_copyright", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetCopyright <-
function(object, copyright = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( copyright )) copyright <- as.character(copyright)

  w <- .RGtkCall("S_gtk_about_dialog_set_copyright", object, copyright, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetComments <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_comments", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetComments <-
function(object, comments = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( comments )) comments <- as.character(comments)

  w <- .RGtkCall("S_gtk_about_dialog_set_comments", object, comments, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetLicense <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_license", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetLicense <-
function(object, license = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( license )) license <- as.character(license)

  w <- .RGtkCall("S_gtk_about_dialog_set_license", object, license, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetWrapLicense <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_wrap_license", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetWrapLicense <-
function(object, wrap.license)
{
  checkPtrType(object, "GtkAboutDialog")
  wrap.license <- as.logical(wrap.license)

  w <- .RGtkCall("S_gtk_about_dialog_set_wrap_license", object, wrap.license, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetWebsite <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_website", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetWebsite <-
function(object, website = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( website )) website <- as.character(website)

  w <- .RGtkCall("S_gtk_about_dialog_set_website", object, website, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetWebsiteLabel <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_website_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetWebsiteLabel <-
function(object, website.label = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( website.label )) website.label <- as.character(website.label)

  w <- .RGtkCall("S_gtk_about_dialog_set_website_label", object, website.label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetAuthors <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_authors", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetAuthors <-
function(object, authors)
{
  checkPtrType(object, "GtkAboutDialog")
  authors <- as.list(as.character(authors))

  w <- .RGtkCall("S_gtk_about_dialog_set_authors", object, authors, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetDocumenters <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_documenters", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetDocumenters <-
function(object, documenters)
{
  checkPtrType(object, "GtkAboutDialog")
  documenters <- as.list(as.character(documenters))

  w <- .RGtkCall("S_gtk_about_dialog_set_documenters", object, documenters, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetArtists <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_artists", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetArtists <-
function(object, artists)
{
  checkPtrType(object, "GtkAboutDialog")
  artists <- as.list(as.character(artists))

  w <- .RGtkCall("S_gtk_about_dialog_set_artists", object, artists, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetTranslatorCredits <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_translator_credits", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetTranslatorCredits <-
function(object, translator.credits = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( translator.credits )) translator.credits <- as.character(translator.credits)

  w <- .RGtkCall("S_gtk_about_dialog_set_translator_credits", object, translator.credits, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetLogo <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_logo", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetLogo <-
function(object, logo = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( logo )) checkPtrType(logo, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_about_dialog_set_logo", object, logo, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogGetLogoIconName <-
function(object)
{
  checkPtrType(object, "GtkAboutDialog")

  w <- .RGtkCall("S_gtk_about_dialog_get_logo_icon_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetLogoIconName <-
function(object, icon.name = NULL)
{
  checkPtrType(object, "GtkAboutDialog")
  if (!is.null( icon.name )) icon.name <- as.character(icon.name)

  w <- .RGtkCall("S_gtk_about_dialog_set_logo_icon_name", object, icon.name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAboutDialogSetEmailHook <-
function(func, data = NULL)
{
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_about_dialog_set_email_hook", func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkAboutDialogSetUrlHook <-
function(func, data = NULL)
{
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_about_dialog_set_url_hook", func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_accel_group_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_accel_group_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupLock <-
function(object)
{
  checkPtrType(object, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_accel_group_lock", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelGroupUnlock <-
function(object)
{
  checkPtrType(object, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_accel_group_unlock", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelGroupConnect <-
function(object, accel.key, accel.mods, accel.flags, closure)
{
  checkPtrType(object, "GtkAccelGroup")
  accel.key <- as.numeric(accel.key)
  
  
  closure <- as.GClosure(closure)

  w <- .RGtkCall("S_gtk_accel_group_connect", object, accel.key, accel.mods, accel.flags, closure, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelGroupConnectByPath <-
function(object, accel.path, closure)
{
  checkPtrType(object, "GtkAccelGroup")
  accel.path <- as.character(accel.path)
  closure <- as.GClosure(closure)

  w <- .RGtkCall("S_gtk_accel_group_connect_by_path", object, accel.path, closure, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelGroupDisconnect <-
function(object, closure)
{
  checkPtrType(object, "GtkAccelGroup")
  closure <- as.GClosure(closure)

  w <- .RGtkCall("S_gtk_accel_group_disconnect", object, closure, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupDisconnectKey <-
function(object, accel.key, accel.mods)
{
  checkPtrType(object, "GtkAccelGroup")
  accel.key <- as.numeric(accel.key)
  

  w <- .RGtkCall("S_gtk_accel_group_disconnect_key", object, accel.key, accel.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupActivate <-
function(object, accel.quark, acceleratable, accel.key, accel.mods)
{
  checkPtrType(object, "GtkAccelGroup")
  accel.quark <- as.GQuark(accel.quark)
  checkPtrType(acceleratable, "GObject")
  accel.key <- as.numeric(accel.key)
  

  w <- .RGtkCall("S_gtk_accel_group_activate", object, accel.quark, acceleratable, accel.key, accel.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupsActivate <-
function(object, accel.key, accel.mods)
{
  checkPtrType(object, "GObject")
  accel.key <- as.numeric(accel.key)
  

  w <- .RGtkCall("S_gtk_accel_groups_activate", object, accel.key, accel.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupsFromObject <-
function(object)
{
  checkPtrType(object, "GObject")

  w <- .RGtkCall("S_gtk_accel_groups_from_object", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupFind <-
function(object, find.func, data = NULL)
{
  checkPtrType(object, "GtkAccelGroup")
  find.func <- as.function(find.func)
  

  w <- .RGtkCall("S_gtk_accel_group_find", object, find.func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelGroupFromAccelClosure <-
function(closure)
{
  closure <- as.GClosure(closure)

  w <- .RGtkCall("S_gtk_accel_group_from_accel_closure", closure, PACKAGE = "RGtk2")

  return(w)
} 


gtkAcceleratorValid <-
function(keyval, modifiers)
{
  keyval <- as.numeric(keyval)
  

  w <- .RGtkCall("S_gtk_accelerator_valid", keyval, modifiers, PACKAGE = "RGtk2")

  return(w)
} 


gtkAcceleratorParse <-
function(accelerator)
{
  accelerator <- as.character(accelerator)

  w <- .RGtkCall("S_gtk_accelerator_parse", accelerator, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAcceleratorName <-
function(accelerator.key, accelerator.mods)
{
  accelerator.key <- as.numeric(accelerator.key)
  

  w <- .RGtkCall("S_gtk_accelerator_name", accelerator.key, accelerator.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAcceleratorSetDefaultModMask <-
function(default.mod.mask)
{
  

  w <- .RGtkCall("S_gtk_accelerator_set_default_mod_mask", default.mod.mask, PACKAGE = "RGtk2")

  return(w)
} 


gtkAcceleratorGetDefaultModMask <-
function()
{
  

  w <- .RGtkCall("S_gtk_accelerator_get_default_mod_mask", PACKAGE = "RGtk2")

  return(w)
} 


gtkAcceleratorGetLabel <-
function(accelerator.key, accelerator.mods)
{
  accelerator.key <- as.numeric(accelerator.key)
  

  w <- .RGtkCall("S_gtk_accelerator_get_label", accelerator.key, accelerator.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelLabelGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_accel_label_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelLabelNew <-
function(string = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_accel_label_new", string, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkAccelLabelGetAccelWidget <-
function(object)
{
  checkPtrType(object, "GtkAccelLabel")

  w <- .RGtkCall("S_gtk_accel_label_get_accel_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelLabelGetAccelWidth <-
function(object)
{
  checkPtrType(object, "GtkAccelLabel")

  w <- .RGtkCall("S_gtk_accel_label_get_accel_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelLabelSetAccelWidget <-
function(object, accel.widget)
{
  checkPtrType(object, "GtkAccelLabel")
  checkPtrType(accel.widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_accel_label_set_accel_widget", object, accel.widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelLabelSetAccelClosure <-
function(object, accel.closure)
{
  checkPtrType(object, "GtkAccelLabel")
  accel.closure <- as.GClosure(accel.closure)

  w <- .RGtkCall("S_gtk_accel_label_set_accel_closure", object, accel.closure, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAccelLabelRefetch <-
function(object)
{
  checkPtrType(object, "GtkAccelLabel")

  w <- .RGtkCall("S_gtk_accel_label_refetch", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapAddEntry <-
function(accel.path, accel.key, accel.mods)
{
  accel.path <- as.character(accel.path)
  accel.key <- as.numeric(accel.key)
  

  w <- .RGtkCall("S_gtk_accel_map_add_entry", accel.path, accel.key, accel.mods, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapLookupEntry <-
function(accel.path)
{
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_accel_map_lookup_entry", accel.path, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapChangeEntry <-
function(accel.path, accel.key, accel.mods, replace)
{
  accel.path <- as.character(accel.path)
  accel.key <- as.numeric(accel.key)
  
  replace <- as.logical(replace)

  w <- .RGtkCall("S_gtk_accel_map_change_entry", accel.path, accel.key, accel.mods, replace, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapLoad <-
function(file.name)
{
  file.name <- as.character(file.name)

  w <- .RGtkCall("S_gtk_accel_map_load", file.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapSave <-
function(file.name)
{
  file.name <- as.character(file.name)

  w <- .RGtkCall("S_gtk_accel_map_save", file.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapForeach <-
function(data = NULL, foreach.func)
{
  
  foreach.func <- as.function(foreach.func)

  w <- .RGtkCall("S_gtk_accel_map_foreach", data, foreach.func, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapLoadFd <-
function(fd)
{
  fd <- as.integer(fd)

  w <- .RGtkCall("S_gtk_accel_map_load_fd", fd, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapLoadScanner <-
function(scanner)
{
  checkPtrType(scanner, "GScanner")

  w <- .RGtkCall("S_gtk_accel_map_load_scanner", scanner, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapSaveFd <-
function(fd)
{
  fd <- as.integer(fd)

  w <- .RGtkCall("S_gtk_accel_map_save_fd", fd, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapLockPath <-
function(accel.path)
{
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_accel_map_lock_path", accel.path, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapUnlockPath <-
function(accel.path)
{
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_accel_map_unlock_path", accel.path, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapAddFilter <-
function(filter.pattern)
{
  filter.pattern <- as.character(filter.pattern)

  w <- .RGtkCall("S_gtk_accel_map_add_filter", filter.pattern, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapForeachUnfiltered <-
function(data = NULL, foreach.func)
{
  
  foreach.func <- as.function(foreach.func)

  w <- .RGtkCall("S_gtk_accel_map_foreach_unfiltered", data, foreach.func, PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_accel_map_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccelMapGet <-
function()
{
  

  w <- .RGtkCall("S_gtk_accel_map_get", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccessibleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_accessible_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAccessibleConnectWidgetDestroyed <-
function(object)
{
  checkPtrType(object, "GtkAccessible")

  w <- .RGtkCall("S_gtk_accessible_connect_widget_destroyed", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_action_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkActionNew <-
function(name = NULL, label = NULL, tooltip = NULL, stock.id = NULL)
{
  

  w <- .RGtkCall("S_gtk_action_new", name, label, tooltip, stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGetName <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionIsSensitive <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_is_sensitive", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGetSensitive <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_sensitive", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionIsVisible <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_is_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGetVisible <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionActivate <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_activate", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionCreateIcon <-
function(object, icon.size)
{
  checkPtrType(object, "GtkAction")
  

  w <- .RGtkCall("S_gtk_action_create_icon", object, icon.size, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionCreateMenuItem <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_create_menu_item", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionCreateToolItem <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_create_tool_item", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionConnectProxy <-
function(object, proxy)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkAction")
  checkPtrType(proxy, "GtkWidget")

  w <- .RGtkCall("S_gtk_action_connect_proxy", object, proxy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionDisconnectProxy <-
function(object, proxy)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkAction")
  checkPtrType(proxy, "GtkWidget")

  w <- .RGtkCall("S_gtk_action_disconnect_proxy", object, proxy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGetProxies <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_proxies", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionConnectAccelerator <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_connect_accelerator", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionDisconnectAccelerator <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_disconnect_accelerator", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGetAccelPath <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_accel_path", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGetAccelClosure <-
function(object)
{
  checkPtrType(object, "GtkAction")

  w <- .RGtkCall("S_gtk_action_get_accel_closure", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionBlockActivateFrom <-
function(object, proxy)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkAction")
  checkPtrType(proxy, "GtkWidget")

  w <- .RGtkCall("S_gtk_action_block_activate_from", object, proxy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionUnblockActivateFrom <-
function(object, proxy)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkAction")
  checkPtrType(proxy, "GtkWidget")

  w <- .RGtkCall("S_gtk_action_unblock_activate_from", object, proxy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionSetAccelPath <-
function(object, accel.path)
{
  checkPtrType(object, "GtkAction")
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_action_set_accel_path", object, accel.path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionSetAccelGroup <-
function(object, accel.group)
{
  checkPtrType(object, "GtkAction")
  checkPtrType(accel.group, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_action_set_accel_group", object, accel.group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionSetSensitive <-
function(object, sensitive)
{
  checkPtrType(object, "GtkAction")
  sensitive <- as.logical(sensitive)

  w <- .RGtkCall("S_gtk_action_set_sensitive", object, sensitive, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionSetVisible <-
function(object, visible)
{
  checkPtrType(object, "GtkAction")
  visible <- as.logical(visible)

  w <- .RGtkCall("S_gtk_action_set_visible", object, visible, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_action_group_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupNew <-
function(name = NULL)
{
  

  w <- .RGtkCall("S_gtk_action_group_new", name, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupGetName <-
function(object)
{
  checkPtrType(object, "GtkActionGroup")

  w <- .RGtkCall("S_gtk_action_group_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupGetSensitive <-
function(object)
{
  checkPtrType(object, "GtkActionGroup")

  w <- .RGtkCall("S_gtk_action_group_get_sensitive", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupSetSensitive <-
function(object, sensitive)
{
  checkPtrType(object, "GtkActionGroup")
  sensitive <- as.logical(sensitive)

  w <- .RGtkCall("S_gtk_action_group_set_sensitive", object, sensitive, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupGetVisible <-
function(object)
{
  checkPtrType(object, "GtkActionGroup")

  w <- .RGtkCall("S_gtk_action_group_get_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupSetVisible <-
function(object, visible)
{
  checkPtrType(object, "GtkActionGroup")
  visible <- as.logical(visible)

  w <- .RGtkCall("S_gtk_action_group_set_visible", object, visible, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupGetAction <-
function(object, action.name)
{
  checkPtrType(object, "GtkActionGroup")
  action.name <- as.character(action.name)

  w <- .RGtkCall("S_gtk_action_group_get_action", object, action.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupListActions <-
function(object)
{
  checkPtrType(object, "GtkActionGroup")

  w <- .RGtkCall("S_gtk_action_group_list_actions", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupAddAction <-
function(object, action)
{
  checkPtrType(object, "GtkActionGroup")
  checkPtrType(action, "GtkAction")

  w <- .RGtkCall("S_gtk_action_group_add_action", object, action, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupAddActionWithAccel <-
function(object, action, accelerator = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  checkPtrType(action, "GtkAction")
  if (!is.null( accelerator )) accelerator <- as.character(accelerator)

  w <- .RGtkCall("S_gtk_action_group_add_action_with_accel", object, action, accelerator, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupRemoveAction <-
function(object, action)
{
  checkPtrType(object, "GtkActionGroup")
  checkPtrType(action, "GtkAction")

  w <- .RGtkCall("S_gtk_action_group_remove_action", object, action, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupAddActions <-
function(object, entries, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkActionEntry(x); x })
  

  w <- .RGtkCall("S_gtk_action_group_add_actions", object, entries, user.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupAddToggleActions <-
function(object, entries, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkToggleActionEntry(x); x })
  

  w <- .RGtkCall("S_gtk_action_group_add_toggle_actions", object, entries, user.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupAddRadioActions <-
function(object, entries, value, on.change = NULL, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkRadioActionEntry(x); x })
  value <- as.integer(value)
  if (!is.null( on.change )) on.change <- as.function(on.change)
  

  w <- .RGtkCall("S_gtk_action_group_add_radio_actions", object, entries, value, on.change, user.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupAddActionsFull <-
function(object, entries, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkActionEntry(x); x })
  

  w <- .RGtkCall("S_gtk_action_group_add_actions_full", object, entries, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupAddToggleActionsFull <-
function(object, entries, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkToggleActionEntry(x); x })
  

  w <- .RGtkCall("S_gtk_action_group_add_toggle_actions_full", object, entries, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupAddRadioActionsFull <-
function(object, entries, value, on.change = NULL, user.data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  entries <- lapply(entries, function(x) { x <- as.GtkRadioActionEntry(x); x })
  value <- as.integer(value)
  if (!is.null( on.change )) on.change <- as.function(on.change)
  

  w <- .RGtkCall("S_gtk_action_group_add_radio_actions_full", object, entries, value, on.change, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupSetTranslateFunc <-
function(object, func, data = NULL)
{
  checkPtrType(object, "GtkActionGroup")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_action_group_set_translate_func", object, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkActionGroupSetTranslationDomain <-
function(object, domain)
{
  checkPtrType(object, "GtkActionGroup")
  domain <- as.character(domain)

  w <- .RGtkCall("S_gtk_action_group_set_translation_domain", object, domain, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkActionGroupTranslateString <-
function(object, string)
{
  checkPtrType(object, "GtkActionGroup")
  string <- as.character(string)

  w <- .RGtkCall("S_gtk_action_group_translate_string", object, string, PACKAGE = "RGtk2")

  return(w)
} 


gtkAdjustmentGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_adjustment_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAdjustmentNew <-
function(value = NULL, lower = NULL, upper = NULL, step.incr = NULL, page.incr = NULL, page.size = NULL)
{
  

  w <- .RGtkCall("S_gtk_adjustment_new", value, lower, upper, step.incr, page.incr, page.size, PACKAGE = "RGtk2")

  return(w)
} 


gtkAdjustmentChanged <-
function(object)
{
  checkPtrType(object, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_adjustment_changed", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAdjustmentValueChanged <-
function(object)
{
  checkPtrType(object, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_adjustment_value_changed", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAdjustmentClampPage <-
function(object, lower, upper)
{
  checkPtrType(object, "GtkAdjustment")
  lower <- as.numeric(lower)
  upper <- as.numeric(upper)

  w <- .RGtkCall("S_gtk_adjustment_clamp_page", object, lower, upper, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAdjustmentGetValue <-
function(object)
{
  checkPtrType(object, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_adjustment_get_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkAdjustmentSetValue <-
function(object, value)
{
  checkPtrType(object, "GtkAdjustment")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_adjustment_set_value", object, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAlignmentGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_alignment_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAlignmentNew <-
function(xalign = NULL, yalign = NULL, xscale = NULL, yscale = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_alignment_new", xalign, yalign, xscale, yscale, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkAlignmentSet <-
function(object, xalign, yalign, xscale, yscale)
{
  checkPtrType(object, "GtkAlignment")
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)
  xscale <- as.numeric(xscale)
  yscale <- as.numeric(yscale)

  w <- .RGtkCall("S_gtk_alignment_set", object, xalign, yalign, xscale, yscale, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAlignmentSetPadding <-
function(object, padding.top, padding.bottom, padding.left, padding.right)
{
  checkPtrType(object, "GtkAlignment")
  padding.top <- as.numeric(padding.top)
  padding.bottom <- as.numeric(padding.bottom)
  padding.left <- as.numeric(padding.left)
  padding.right <- as.numeric(padding.right)

  w <- .RGtkCall("S_gtk_alignment_set_padding", object, padding.top, padding.bottom, padding.left, padding.right, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAlignmentGetPadding <-
function(object)
{
  checkPtrType(object, "GtkAlignment")

  w <- .RGtkCall("S_gtk_alignment_get_padding", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkArrowGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_arrow_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkArrowNew <-
function(arrow.type = NULL, shadow.type = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_arrow_new", arrow.type, shadow.type, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkArrowSet <-
function(object, arrow.type, shadow.type)
{
  checkPtrType(object, "GtkArrow")
  
  

  w <- .RGtkCall("S_gtk_arrow_set", object, arrow.type, shadow.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkAspectFrameGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_aspect_frame_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkAspectFrameNew <-
function(label = NULL, xalign = NULL, yalign = NULL, ratio = NULL, obey.child = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_aspect_frame_new", label, xalign, yalign, ratio, obey.child, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkAspectFrameSet <-
function(object, xalign = 0, yalign = 0, ratio = 1, obey.child = 1)
{
  checkPtrType(object, "GtkAspectFrame")
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)
  ratio <- as.numeric(ratio)
  obey.child <- as.logical(obey.child)

  w <- .RGtkCall("S_gtk_aspect_frame_set", object, xalign, yalign, ratio, obey.child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_button_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonBoxGetLayout <-
function(object)
{
  checkPtrType(object, "GtkButtonBox")

  w <- .RGtkCall("S_gtk_button_box_get_layout", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonBoxSetLayout <-
function(object, layout.style)
{
  checkPtrType(object, "GtkButtonBox")
  

  w <- .RGtkCall("S_gtk_button_box_set_layout", object, layout.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxGetChildSecondary <-
function(object, child)
{
  checkPtrType(object, "GtkButtonBox")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_button_box_get_child_secondary", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonBoxSetChildSecondary <-
function(object, child, is.secondary)
{
  checkPtrType(object, "GtkButtonBox")
  checkPtrType(child, "GtkWidget")
  is.secondary <- as.logical(is.secondary)

  w <- .RGtkCall("S_gtk_button_box_set_child_secondary", object, child, is.secondary, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxSetChildSize <-
function(object, min.width, min.height)
{
  if(getOption("depwarn"))
    .Deprecated("style properties child-min-width/-height", "RGtk2")

  checkPtrType(object, "GtkButtonBox")
  min.width <- as.integer(min.width)
  min.height <- as.integer(min.height)

  w <- .RGtkCall("S_gtk_button_box_set_child_size", object, min.width, min.height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxSetChildIpadding <-
function(object, ipad.x, ipad.y)
{
  if(getOption("depwarn"))
    .Deprecated("style properties child-internal-pad-x/-y", "RGtk2")

  checkPtrType(object, "GtkButtonBox")
  ipad.x <- as.integer(ipad.x)
  ipad.y <- as.integer(ipad.y)

  w <- .RGtkCall("S_gtk_button_box_set_child_ipadding", object, ipad.x, ipad.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxGetChildSize <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("style properties child-min-width/-height", "RGtk2")

  checkPtrType(object, "GtkButtonBox")

  w <- .RGtkCall("S_gtk_button_box_get_child_size", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonBoxGetChildIpadding <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("style properties child-internal-pad-x/-y", "RGtk2")

  checkPtrType(object, "GtkButtonBox")

  w <- .RGtkCall("S_gtk_button_box_get_child_ipadding", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBinGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_bin_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkBinGetChild <-
function(object)
{
  checkPtrType(object, "GtkBin")

  w <- .RGtkCall("S_gtk_bin_get_child", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkBoxPackStart <-
function(object, child, expand = TRUE, fill = TRUE, padding = 0)
{
  checkPtrType(object, "GtkBox")
  checkPtrType(child, "GtkWidget")
  expand <- as.logical(expand)
  fill <- as.logical(fill)
  padding <- as.numeric(padding)

  w <- .RGtkCall("S_gtk_box_pack_start", object, child, expand, fill, padding, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxPackEnd <-
function(object, child, expand = TRUE, fill = TRUE, padding = 0)
{
  checkPtrType(object, "GtkBox")
  checkPtrType(child, "GtkWidget")
  expand <- as.logical(expand)
  fill <- as.logical(fill)
  padding <- as.numeric(padding)

  w <- .RGtkCall("S_gtk_box_pack_end", object, child, expand, fill, padding, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxPackStartDefaults <-
function(object, widget)
{
  if(getOption("depwarn"))
    .Deprecated("packStart", "RGtk2")

  checkPtrType(object, "GtkBox")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_box_pack_start_defaults", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxPackEndDefaults <-
function(object, widget)
{
  if(getOption("depwarn"))
    .Deprecated("packEnd", "RGtk2")

  checkPtrType(object, "GtkBox")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_box_pack_end_defaults", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxSetHomogeneous <-
function(object, homogeneous)
{
  checkPtrType(object, "GtkBox")
  homogeneous <- as.logical(homogeneous)

  w <- .RGtkCall("S_gtk_box_set_homogeneous", object, homogeneous, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxGetHomogeneous <-
function(object)
{
  checkPtrType(object, "GtkBox")

  w <- .RGtkCall("S_gtk_box_get_homogeneous", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkBoxSetSpacing <-
function(object, spacing)
{
  checkPtrType(object, "GtkBox")
  spacing <- as.integer(spacing)

  w <- .RGtkCall("S_gtk_box_set_spacing", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxGetSpacing <-
function(object)
{
  checkPtrType(object, "GtkBox")

  w <- .RGtkCall("S_gtk_box_get_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkBoxReorderChild <-
function(object, child, position)
{
  checkPtrType(object, "GtkBox")
  checkPtrType(child, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_box_reorder_child", object, child, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxQueryChildPacking <-
function(object, child)
{
  checkPtrType(object, "GtkBox")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_box_query_child_packing", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBoxSetChildPacking <-
function(object, child, expand, fill, padding, pack.type)
{
  checkPtrType(object, "GtkBox")
  checkPtrType(child, "GtkWidget")
  expand <- as.logical(expand)
  fill <- as.logical(fill)
  padding <- as.numeric(padding)
  

  w <- .RGtkCall("S_gtk_box_set_child_packing", object, child, expand, fill, padding, pack.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_button_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkButtonNewWithLabel <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_button_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkButtonNewFromStock <-
function(stock.id, show = TRUE)
{
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_button_new_from_stock", stock.id, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkButtonNewWithMnemonic <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_button_new_with_mnemonic", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkButtonPressed <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("'button-press-event' signal", "RGtk2")

  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_pressed", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonReleased <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("'button-release-event' signal", "RGtk2")

  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_released", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonClicked <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_clicked", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonEnter <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("'enter-notify-event' signal", "RGtk2")

  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_enter", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonLeave <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("'leave-notify-event' signal", "RGtk2")

  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_leave", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonSetRelief <-
function(object, newstyle)
{
  checkPtrType(object, "GtkButton")
  

  w <- .RGtkCall("S_gtk_button_set_relief", object, newstyle, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetRelief <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_relief", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonSetLabel <-
function(object, label)
{
  checkPtrType(object, "GtkButton")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_button_set_label", object, label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetLabel <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonSetUseUnderline <-
function(object, use.underline)
{
  checkPtrType(object, "GtkButton")
  use.underline <- as.logical(use.underline)

  w <- .RGtkCall("S_gtk_button_set_use_underline", object, use.underline, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetUseUnderline <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_use_underline", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonSetUseStock <-
function(object, use.stock)
{
  checkPtrType(object, "GtkButton")
  use.stock <- as.logical(use.stock)

  w <- .RGtkCall("S_gtk_button_set_use_stock", object, use.stock, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetUseStock <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_use_stock", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonSetFocusOnClick <-
function(object, focus.on.click)
{
  checkPtrType(object, "GtkButton")
  focus.on.click <- as.logical(focus.on.click)

  w <- .RGtkCall("S_gtk_button_set_focus_on_click", object, focus.on.click, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetFocusOnClick <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_focus_on_click", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkButtonSetAlignment <-
function(object, xalign, yalign)
{
  checkPtrType(object, "GtkButton")
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)

  w <- .RGtkCall("S_gtk_button_set_alignment", object, xalign, yalign, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetAlignment <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_alignment", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonSetImage <-
function(object, image)
{
  checkPtrType(object, "GtkButton")
  checkPtrType(image, "GtkWidget")

  w <- .RGtkCall("S_gtk_button_set_image", object, image, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkButtonGetImage <-
function(object)
{
  checkPtrType(object, "GtkButton")

  w <- .RGtkCall("S_gtk_button_get_image", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_calendar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_calendar_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCalendarSelectMonth <-
function(object, month, year)
{
  checkPtrType(object, "GtkCalendar")
  month <- as.numeric(month)
  year <- as.numeric(year)

  w <- .RGtkCall("S_gtk_calendar_select_month", object, month, year, PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarSelectDay <-
function(object, day)
{
  checkPtrType(object, "GtkCalendar")
  day <- as.numeric(day)

  w <- .RGtkCall("S_gtk_calendar_select_day", object, day, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarMarkDay <-
function(object, day)
{
  checkPtrType(object, "GtkCalendar")
  day <- as.numeric(day)

  w <- .RGtkCall("S_gtk_calendar_mark_day", object, day, PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarUnmarkDay <-
function(object, day)
{
  checkPtrType(object, "GtkCalendar")
  day <- as.numeric(day)

  w <- .RGtkCall("S_gtk_calendar_unmark_day", object, day, PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarClearMarks <-
function(object)
{
  checkPtrType(object, "GtkCalendar")

  w <- .RGtkCall("S_gtk_calendar_clear_marks", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarSetDisplayOptions <-
function(object, flags)
{
  checkPtrType(object, "GtkCalendar")
  

  w <- .RGtkCall("S_gtk_calendar_set_display_options", object, flags, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarGetDisplayOptions <-
function(object)
{
  checkPtrType(object, "GtkCalendar")

  w <- .RGtkCall("S_gtk_calendar_get_display_options", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCalendarDisplayOptions <-
function(object, flags)
{
  if(getOption("depwarn"))
    .Deprecated("setDisplayOptions", "RGtk2")

  checkPtrType(object, "GtkCalendar")
  

  w <- .RGtkCall("S_gtk_calendar_display_options", object, flags, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarGetDate <-
function(object)
{
  checkPtrType(object, "GtkCalendar")

  w <- .RGtkCall("S_gtk_calendar_get_date", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarFreeze <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCalendar")

  w <- .RGtkCall("S_gtk_calendar_freeze", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCalendarThaw <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCalendar")

  w <- .RGtkCall("S_gtk_calendar_thaw", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellEditableGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_editable_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellEditableStartEditing <-
function(object, event = NULL)
{
  checkPtrType(object, "GtkCellEditable")
  if (!is.null( event )) checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gtk_cell_editable_start_editing", object, event, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellEditableEditingDone <-
function(object)
{
  checkPtrType(object, "GtkCellEditable")

  w <- .RGtkCall("S_gtk_cell_editable_editing_done", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellEditableRemoveWidget <-
function(object)
{
  checkPtrType(object, "GtkCellEditable")

  w <- .RGtkCall("S_gtk_cell_editable_remove_widget", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_layout_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellLayoutPackStart <-
function(object, cell, expand = TRUE)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")
  expand <- as.logical(expand)

  w <- .RGtkCall("S_gtk_cell_layout_pack_start", object, cell, expand, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutPackEnd <-
function(object, cell, expand = TRUE)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")
  expand <- as.logical(expand)

  w <- .RGtkCall("S_gtk_cell_layout_pack_end", object, cell, expand, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutClear <-
function(object)
{
  checkPtrType(object, "GtkCellLayout")

  w <- .RGtkCall("S_gtk_cell_layout_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutAddAttribute <-
function(object, cell, attribute, column)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")
  attribute <- as.character(attribute)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_cell_layout_add_attribute", object, cell, attribute, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutSetCellDataFunc <-
function(object, cell, func, func.data = NULL)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_cell_layout_set_cell_data_func", object, cell, func, func.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellLayoutClearAttributes <-
function(object, cell)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")

  w <- .RGtkCall("S_gtk_cell_layout_clear_attributes", object, cell, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellLayoutReorder <-
function(object, cell, position)
{
  checkPtrType(object, "GtkCellLayout")
  checkPtrType(cell, "GtkCellRenderer")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_cell_layout_reorder", object, cell, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererGetSize <-
function(object, widget, cell.area = NULL)
{
  checkPtrType(object, "GtkCellRenderer")
  checkPtrType(widget, "GtkWidget")
  if (!is.null( cell.area )) cell.area <- as.GdkRectangle(cell.area)

  w <- .RGtkCall("S_gtk_cell_renderer_get_size", object, widget, cell.area, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererRender <-
function(object, window, widget, background.area, cell.area, expose.area, flags)
{
  checkPtrType(object, "GtkCellRenderer")
  checkPtrType(window, "GdkWindow")
  checkPtrType(widget, "GtkWidget")
  background.area <- as.GdkRectangle(background.area)
  cell.area <- as.GdkRectangle(cell.area)
  expose.area <- as.GdkRectangle(expose.area)
  

  w <- .RGtkCall("S_gtk_cell_renderer_render", object, window, widget, background.area, cell.area, expose.area, flags, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererActivate <-
function(object, event, widget, path, background.area, cell.area, flags)
{
  checkPtrType(object, "GtkCellRenderer")
  checkPtrType(event, "GdkEvent")
  checkPtrType(widget, "GtkWidget")
  path <- as.character(path)
  background.area <- as.GdkRectangle(background.area)
  cell.area <- as.GdkRectangle(cell.area)
  

  w <- .RGtkCall("S_gtk_cell_renderer_activate", object, event, widget, path, background.area, cell.area, flags, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererStartEditing <-
function(object, event, widget, path, background.area, cell.area, flags)
{
  checkPtrType(object, "GtkCellRenderer")
  checkPtrType(event, "GdkEvent")
  checkPtrType(widget, "GtkWidget")
  path <- as.character(path)
  background.area <- as.GdkRectangle(background.area)
  cell.area <- as.GdkRectangle(cell.area)
  

  w <- .RGtkCall("S_gtk_cell_renderer_start_editing", object, event, widget, path, background.area, cell.area, flags, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererSetFixedSize <-
function(object, width, height)
{
  checkPtrType(object, "GtkCellRenderer")
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_cell_renderer_set_fixed_size", object, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererGetFixedSize <-
function(object)
{
  checkPtrType(object, "GtkCellRenderer")

  w <- .RGtkCall("S_gtk_cell_renderer_get_fixed_size", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererEditingCanceled <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("stopEditing", "RGtk2")

  checkPtrType(object, "GtkCellRenderer")

  w <- .RGtkCall("S_gtk_cell_renderer_editing_canceled", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererStopEditing <-
function(object, canceled)
{
  checkPtrType(object, "GtkCellRenderer")
  canceled <- as.logical(canceled)

  w <- .RGtkCall("S_gtk_cell_renderer_stop_editing", object, canceled, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererComboGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_combo_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererComboNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_combo_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererPixbufGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_pixbuf_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererPixbufNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_pixbuf_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererProgressGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_progress_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererProgressNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_progress_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererTextGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_text_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererTextNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_text_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererTextSetFixedHeightFromFont <-
function(object, number.of.rows)
{
  checkPtrType(object, "GtkCellRendererText")
  number.of.rows <- as.integer(number.of.rows)

  w <- .RGtkCall("S_gtk_cell_renderer_text_set_fixed_height_from_font", object, number.of.rows, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererToggleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererToggleNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererToggleGetRadio <-
function(object)
{
  checkPtrType(object, "GtkCellRendererToggle")

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_get_radio", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererToggleSetRadio <-
function(object, radio)
{
  checkPtrType(object, "GtkCellRendererToggle")
  radio <- as.logical(radio)

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_set_radio", object, radio, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellRendererToggleGetActive <-
function(object)
{
  checkPtrType(object, "GtkCellRendererToggle")

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_get_active", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellRendererToggleSetActive <-
function(object, setting)
{
  checkPtrType(object, "GtkCellRendererToggle")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_cell_renderer_toggle_set_active", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellViewGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_cell_view_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_cell_view_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCellViewNewWithText <-
function(text)
{
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_cell_view_new_with_text", text, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewNewWithMarkup <-
function(markup)
{
  markup <- as.character(markup)

  w <- .RGtkCall("S_gtk_cell_view_new_with_markup", markup, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewNewWithPixbuf <-
function(pixbuf)
{
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_cell_view_new_with_pixbuf", pixbuf, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewSetModel <-
function(object, model = NULL)
{
  checkPtrType(object, "GtkCellView")
  if (!is.null( model )) checkPtrType(model, "GtkTreeModel")

  w <- .RGtkCall("S_gtk_cell_view_set_model", object, model, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellViewSetDisplayedRow <-
function(object, path = NULL)
{
  checkPtrType(object, "GtkCellView")
  if (!is.null( path )) checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_cell_view_set_displayed_row", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellViewGetDisplayedRow <-
function(object)
{
  checkPtrType(object, "GtkCellView")

  w <- .RGtkCall("S_gtk_cell_view_get_displayed_row", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewGetSizeOfRow <-
function(object, path)
{
  checkPtrType(object, "GtkCellView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_cell_view_get_size_of_row", object, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkCellViewSetBackgroundColor <-
function(object, color)
{
  checkPtrType(object, "GtkCellView")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_cell_view_set_background_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCellViewGetCellRenderers <-
function(object)
{
  checkPtrType(object, "GtkCellView")

  w <- .RGtkCall("S_gtk_cell_view_get_cell_renderers", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardSetCanStore <-
function(object, targets)
{
  checkPtrType(object, "GtkClipboard")
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })

  w <- .RGtkCall("S_gtk_clipboard_set_can_store", object, targets, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardStore <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_store", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_check_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCheckButtonNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_check_button_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckButtonNewWithLabel <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_check_button_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckButtonNewWithMnemonic <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_check_button_new_with_mnemonic", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_check_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCheckMenuItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_check_menu_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckMenuItemNewWithLabel <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_check_menu_item_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckMenuItemNewWithMnemonic <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_check_menu_item_new_with_mnemonic", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCheckMenuItemSetActive <-
function(object, is.active)
{
  checkPtrType(object, "GtkCheckMenuItem")
  is.active <- as.logical(is.active)

  w <- .RGtkCall("S_gtk_check_menu_item_set_active", object, is.active, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckMenuItemGetActive <-
function(object)
{
  checkPtrType(object, "GtkCheckMenuItem")

  w <- .RGtkCall("S_gtk_check_menu_item_get_active", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCheckMenuItemToggled <-
function(object)
{
  checkPtrType(object, "GtkCheckMenuItem")

  w <- .RGtkCall("S_gtk_check_menu_item_toggled", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckMenuItemSetInconsistent <-
function(object, setting)
{
  checkPtrType(object, "GtkCheckMenuItem")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_check_menu_item_set_inconsistent", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckMenuItemGetInconsistent <-
function(object)
{
  checkPtrType(object, "GtkCheckMenuItem")

  w <- .RGtkCall("S_gtk_check_menu_item_get_inconsistent", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCheckMenuItemSetDrawAsRadio <-
function(object, draw.as.radio)
{
  checkPtrType(object, "GtkCheckMenuItem")
  draw.as.radio <- as.logical(draw.as.radio)

  w <- .RGtkCall("S_gtk_check_menu_item_set_draw_as_radio", object, draw.as.radio, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckMenuItemGetDrawAsRadio <-
function(object)
{
  checkPtrType(object, "GtkCheckMenuItem")

  w <- .RGtkCall("S_gtk_check_menu_item_get_draw_as_radio", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCheckMenuItemSetShowToggle <-
function(object, always)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCheckMenuItem")
  always <- as.logical(always)

  w <- .RGtkCall("S_gtk_check_menu_item_set_show_toggle", object, always, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckMenuItemSetState <-
function(object, is.active)
{
  if(getOption("depwarn"))
    .Deprecated("gtkCheckMenuItemSetActive", "RGtk2")

  checkPtrType(object, "GtkCheckMenuItem")
  is.active <- as.logical(is.active)

  w <- .RGtkCall("S_gtk_check_menu_item_set_state", object, is.active, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_clipboard_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardGetForDisplay <-
function(display, selection = "GDK_SELECTION_CLIPBOARD")
{
  checkPtrType(display, "GdkDisplay")
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gtk_clipboard_get_for_display", display, selection, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardGet <-
function(selection = "GDK_SELECTION_CLIPBOARD")
{
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gtk_clipboard_get", selection, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardGetDisplay <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_get_display", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardSetWithData <-
function(object, targets, get.func, user.data = NULL)
{
  checkPtrType(object, "GtkClipboard")
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })
  get.func <- as.function(get.func)
  

  w <- .RGtkCall("S_gtk_clipboard_set_with_data", object, targets, get.func, user.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardGetOwner <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_get_owner", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardClear <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardSetText <-
function(object, text, len = -1)
{
  checkPtrType(object, "GtkClipboard")
  text <- as.character(text)
  len <- as.integer(len)

  w <- .RGtkCall("S_gtk_clipboard_set_text", object, text, len, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardSetImage <-
function(object, pixbuf)
{
  checkPtrType(object, "GtkClipboard")
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_clipboard_set_image", object, pixbuf, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardRequestContents <-
function(object, target, callback, user.data = NULL)
{
  checkPtrType(object, "GtkClipboard")
  target <- as.GdkAtom(target)
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_clipboard_request_contents", object, target, callback, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardRequestImage <-
function(object, callback, user.data = NULL)
{
  checkPtrType(object, "GtkClipboard")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_clipboard_request_image", object, callback, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardRequestText <-
function(object, callback, user.data = NULL)
{
  checkPtrType(object, "GtkClipboard")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_clipboard_request_text", object, callback, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardRequestTargets <-
function(object, callback, user.data = NULL)
{
  checkPtrType(object, "GtkClipboard")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_clipboard_request_targets", object, callback, user.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkClipboardWaitForContents <-
function(object, target)
{
  checkPtrType(object, "GtkClipboard")
  target <- as.GdkAtom(target)

  w <- .RGtkCall("S_gtk_clipboard_wait_for_contents", object, target, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitForImage <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_wait_for_image", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitForText <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_wait_for_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitIsImageAvailable <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_wait_is_image_available", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitIsTextAvailable <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_wait_is_text_available", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitIsTargetAvailable <-
function(object, target)
{
  checkPtrType(object, "GtkClipboard")
  target <- as.GdkAtom(target)

  w <- .RGtkCall("S_gtk_clipboard_wait_is_target_available", object, target, PACKAGE = "RGtk2")

  return(w)
} 


gtkClipboardWaitForTargets <-
function(object)
{
  checkPtrType(object, "GtkClipboard")

  w <- .RGtkCall("S_gtk_clipboard_wait_for_targets", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_clist_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCListNew <-
function(columns = 1, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkListStore/GtkTreeView", "RGtk2")

  columns <- as.integer(columns)

  w <- .RGtkCall("S_gtk_clist_new", columns, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCListNewWithTitles <-
function(columns = 1, titles, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkListStore/GtkTreeView", "RGtk2")

  columns <- as.integer(columns)
  titles <- as.list(as.character(titles))

  w <- .RGtkCall("S_gtk_clist_new_with_titles", columns, titles, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCListSetHadjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkCList")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_clist_set_hadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetVadjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkCList")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_clist_set_vadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetHadjustment <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_get_hadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListGetVadjustment <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_get_vadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetShadowType <-
function(object, type)
{
  checkPtrType(object, "GtkCList")
  

  w <- .RGtkCall("S_gtk_clist_set_shadow_type", object, type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetSelectionMode <-
function(object, mode)
{
  checkPtrType(object, "GtkCList")
  

  w <- .RGtkCall("S_gtk_clist_set_selection_mode", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetReorderable <-
function(object, reorderable)
{
  checkPtrType(object, "GtkCList")
  reorderable <- as.logical(reorderable)

  w <- .RGtkCall("S_gtk_clist_set_reorderable", object, reorderable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetUseDragIcons <-
function(object, use.icons)
{
  checkPtrType(object, "GtkCList")
  use.icons <- as.logical(use.icons)

  w <- .RGtkCall("S_gtk_clist_set_use_drag_icons", object, use.icons, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetButtonActions <-
function(object, button, button.actions)
{
  checkPtrType(object, "GtkCList")
  button <- as.numeric(button)
  button.actions <- as.raw(button.actions)

  w <- .RGtkCall("S_gtk_clist_set_button_actions", object, button, button.actions, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListFreeze <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_freeze", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListThaw <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_thaw", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitlesShow <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_column_titles_show", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitlesHide <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_column_titles_hide", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitleActive <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_column_title_active", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitlePassive <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_column_title_passive", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitlesActive <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_column_titles_active", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnTitlesPassive <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_column_titles_passive", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnTitle <-
function(object, column, title)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  title <- as.character(title)

  w <- .RGtkCall("S_gtk_clist_set_column_title", object, column, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetColumnTitle <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_column_title", object, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetColumnWidget <-
function(object, column, widget)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_clist_set_column_widget", object, column, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetColumnWidget <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_column_widget", object, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetColumnJustification <-
function(object, column, justification)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  

  w <- .RGtkCall("S_gtk_clist_set_column_justification", object, column, justification, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnVisibility <-
function(object, column, visible)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  visible <- as.logical(visible)

  w <- .RGtkCall("S_gtk_clist_set_column_visibility", object, column, visible, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnResizeable <-
function(object, column, resizeable)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  resizeable <- as.logical(resizeable)

  w <- .RGtkCall("S_gtk_clist_set_column_resizeable", object, column, resizeable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnAutoResize <-
function(object, column, auto.resize)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  auto.resize <- as.logical(auto.resize)

  w <- .RGtkCall("S_gtk_clist_set_column_auto_resize", object, column, auto.resize, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListColumnsAutosize <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_columns_autosize", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListOptimalColumnWidth <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_optimal_column_width", object, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetColumnWidth <-
function(object, column, width)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  width <- as.integer(width)

  w <- .RGtkCall("S_gtk_clist_set_column_width", object, column, width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnMinWidth <-
function(object, column, min.width)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  min.width <- as.integer(min.width)

  w <- .RGtkCall("S_gtk_clist_set_column_min_width", object, column, min.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetColumnMaxWidth <-
function(object, column, max.width)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)
  max.width <- as.integer(max.width)

  w <- .RGtkCall("S_gtk_clist_set_column_max_width", object, column, max.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetRowHeight <-
function(object, height)
{
  checkPtrType(object, "GtkCList")
  height <- as.numeric(height)

  w <- .RGtkCall("S_gtk_clist_set_row_height", object, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListMoveto <-
function(object, row, column, row.align, col.align)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  row.align <- as.numeric(row.align)
  col.align <- as.numeric(col.align)

  w <- .RGtkCall("S_gtk_clist_moveto", object, row, column, row.align, col.align, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListRowIsVisible <-
function(object, row)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)

  w <- .RGtkCall("S_gtk_clist_row_is_visible", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListGetCellType <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_cell_type", object, row, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetText <-
function(object, row, column, text)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_clist_set_text", object, row, column, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetText <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_text", object, row, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetPixmap <-
function(object, row, column, pixmap, mask = NULL)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_clist_set_pixmap", object, row, column, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetPixmap <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_pixmap", object, row, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetPixtext <-
function(object, row, column, text, spacing, pixmap, mask)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  text <- as.character(text)
  spacing <- as.raw(spacing)
  checkPtrType(pixmap, "GdkPixmap")
  checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_clist_set_pixtext", object, row, column, text, spacing, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetPixtext <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_pixtext", object, row, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetForeground <-
function(object, row, color)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_clist_set_foreground", object, row, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetBackground <-
function(object, row, color)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_clist_set_background", object, row, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetCellStyle <-
function(object, row, column, style)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  checkPtrType(style, "GtkStyle")

  w <- .RGtkCall("S_gtk_clist_set_cell_style", object, row, column, style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetCellStyle <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_get_cell_style", object, row, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetRowStyle <-
function(object, row, style)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  checkPtrType(style, "GtkStyle")

  w <- .RGtkCall("S_gtk_clist_set_row_style", object, row, style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetRowStyle <-
function(object, row)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)

  w <- .RGtkCall("S_gtk_clist_get_row_style", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSetShift <-
function(object, row, column, vertical, horizontal)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)
  vertical <- as.integer(vertical)
  horizontal <- as.integer(horizontal)

  w <- .RGtkCall("S_gtk_clist_set_shift", object, row, column, vertical, horizontal, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetSelectable <-
function(object, row, selectable)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  selectable <- as.logical(selectable)

  w <- .RGtkCall("S_gtk_clist_set_selectable", object, row, selectable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetSelectable <-
function(object, row)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)

  w <- .RGtkCall("S_gtk_clist_get_selectable", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListPrepend <-
function(object, text)
{
  checkPtrType(object, "GtkCList")
  text <- as.list(as.character(text))

  w <- .RGtkCall("S_gtk_clist_prepend", object, text, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListAppend <-
function(object, text)
{
  checkPtrType(object, "GtkCList")
  text <- as.list(as.character(text))

  w <- .RGtkCall("S_gtk_clist_append", object, text, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListInsert <-
function(object, row, text)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  text <- as.list(as.character(text))

  w <- .RGtkCall("S_gtk_clist_insert", object, row, text, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListRemove <-
function(object, row)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)

  w <- .RGtkCall("S_gtk_clist_remove", object, row, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetRowData <-
function(object, row, data = NULL)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  

  w <- .RGtkCall("S_gtk_clist_set_row_data", object, row, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetRowDataFull <-
function(object, row, data = NULL)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  

  w <- .RGtkCall("S_gtk_clist_set_row_data_full", object, row, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListGetRowData <-
function(object, row)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)

  w <- .RGtkCall("S_gtk_clist_get_row_data", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListFindRowFromData <-
function(object, data)
{
  checkPtrType(object, "GtkCList")
  

  w <- .RGtkCall("S_gtk_clist_find_row_from_data", object, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSelectRow <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_select_row", object, row, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListUnselectRow <-
function(object, row, column)
{
  checkPtrType(object, "GtkCList")
  row <- as.integer(row)
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_unselect_row", object, row, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListUndoSelection <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_undo_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListClear <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListGetSelectionInfo <-
function(object, x, y)
{
  checkPtrType(object, "GtkCList")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_clist_get_selection_info", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gtkCListSelectAll <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_select_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListUnselectAll <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_unselect_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSwapRows <-
function(object, row1, row2)
{
  checkPtrType(object, "GtkCList")
  row1 <- as.integer(row1)
  row2 <- as.integer(row2)

  w <- .RGtkCall("S_gtk_clist_swap_rows", object, row1, row2, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListRowMove <-
function(object, source.row, dest.row)
{
  checkPtrType(object, "GtkCList")
  source.row <- as.integer(source.row)
  dest.row <- as.integer(dest.row)

  w <- .RGtkCall("S_gtk_clist_row_move", object, source.row, dest.row, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetSortColumn <-
function(object, column)
{
  checkPtrType(object, "GtkCList")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_clist_set_sort_column", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetSortType <-
function(object, sort.type)
{
  checkPtrType(object, "GtkCList")
  

  w <- .RGtkCall("S_gtk_clist_set_sort_type", object, sort.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSort <-
function(object)
{
  checkPtrType(object, "GtkCList")

  w <- .RGtkCall("S_gtk_clist_sort", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCListSetAutoSort <-
function(object, auto.sort)
{
  checkPtrType(object, "GtkCList")
  auto.sort <- as.logical(auto.sort)

  w <- .RGtkCall("S_gtk_clist_set_auto_sort", object, auto.sort, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_color_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkColorButtonNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_color_button_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkColorButtonNewWithColor <-
function(color, show = TRUE)
{
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_color_button_new_with_color", color, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkColorButtonSetColor <-
function(object, color)
{
  checkPtrType(object, "GtkColorButton")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_color_button_set_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorButtonSetAlpha <-
function(object, alpha)
{
  checkPtrType(object, "GtkColorButton")
  alpha <- as.integer(alpha)

  w <- .RGtkCall("S_gtk_color_button_set_alpha", object, alpha, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorButtonGetColor <-
function(object)
{
  checkPtrType(object, "GtkColorButton")

  w <- .RGtkCall("S_gtk_color_button_get_color", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorButtonGetAlpha <-
function(object)
{
  checkPtrType(object, "GtkColorButton")

  w <- .RGtkCall("S_gtk_color_button_get_alpha", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorButtonSetUseAlpha <-
function(object, use.alpha)
{
  checkPtrType(object, "GtkColorButton")
  use.alpha <- as.logical(use.alpha)

  w <- .RGtkCall("S_gtk_color_button_set_use_alpha", object, use.alpha, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorButtonGetUseAlpha <-
function(object)
{
  checkPtrType(object, "GtkColorButton")

  w <- .RGtkCall("S_gtk_color_button_get_use_alpha", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorButtonSetTitle <-
function(object, title)
{
  checkPtrType(object, "GtkColorButton")
  title <- as.character(title)

  w <- .RGtkCall("S_gtk_color_button_set_title", object, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorButtonGetTitle <-
function(object)
{
  checkPtrType(object, "GtkColorButton")

  w <- .RGtkCall("S_gtk_color_button_get_title", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_color_selection_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_color_selection_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkColorSelectionGetHasOpacityControl <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_has_opacity_control", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetHasOpacityControl <-
function(object, has.opacity)
{
  checkPtrType(object, "GtkColorSelection")
  has.opacity <- as.logical(has.opacity)

  w <- .RGtkCall("S_gtk_color_selection_set_has_opacity_control", object, has.opacity, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionGetHasPalette <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_has_palette", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetHasPalette <-
function(object, has.palette)
{
  checkPtrType(object, "GtkColorSelection")
  has.palette <- as.logical(has.palette)

  w <- .RGtkCall("S_gtk_color_selection_set_has_palette", object, has.palette, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionSetCurrentColor <-
function(object, color)
{
  checkPtrType(object, "GtkColorSelection")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_color_selection_set_current_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionSetCurrentAlpha <-
function(object, alpha)
{
  checkPtrType(object, "GtkColorSelection")
  alpha <- as.integer(alpha)

  w <- .RGtkCall("S_gtk_color_selection_set_current_alpha", object, alpha, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionGetCurrentColor <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_current_color", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionGetCurrentAlpha <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_current_alpha", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetPreviousColor <-
function(object, color)
{
  checkPtrType(object, "GtkColorSelection")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_color_selection_set_previous_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionSetPreviousAlpha <-
function(object, alpha)
{
  checkPtrType(object, "GtkColorSelection")
  alpha <- as.integer(alpha)

  w <- .RGtkCall("S_gtk_color_selection_set_previous_alpha", object, alpha, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionGetPreviousColor <-
function(object, color)
{
  checkPtrType(object, "GtkColorSelection")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_color_selection_get_previous_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionGetPreviousAlpha <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_previous_alpha", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionIsAdjusting <-
function(object)
{
  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_is_adjusting", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionPaletteFromString <-
function(str)
{
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_color_selection_palette_from_string", str, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionPaletteToString <-
function(colors)
{
  colors <- lapply(colors, function(x) { x <- as.GdkColor(x); x })

  w <- .RGtkCall("S_gtk_color_selection_palette_to_string", colors, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetChangePaletteHook <-
function(func)
{
  if(getOption("depwarn"))
    .Deprecated("setChangePaletteWithScreenHook", "RGtk2")

  func <- as.function(func)

  w <- .RGtkCall("S_gtk_color_selection_set_change_palette_hook", func, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetChangePaletteWithScreenHook <-
function(func)
{
  func <- as.function(func)

  w <- .RGtkCall("S_gtk_color_selection_set_change_palette_with_screen_hook", func, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetColor <-
function(object, color)
{
  if(getOption("depwarn"))
    .Deprecated("gtkColorSelectionSetCurrentColor", "RGtk2")

  checkPtrType(object, "GtkColorSelection")
  color <- as.list(as.numeric(color))

  w <- .RGtkCall("S_gtk_color_selection_set_color", object, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionGetColor <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkColorSelectionGetCurrentColor", "RGtk2")

  checkPtrType(object, "GtkColorSelection")

  w <- .RGtkCall("S_gtk_color_selection_get_color", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionSetUpdatePolicy <-
function(object, policy)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkColorSelection")
  

  w <- .RGtkCall("S_gtk_color_selection_set_update_policy", object, policy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkColorSelectionDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_color_selection_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkColorSelectionDialogNew <-
function(title = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_color_selection_dialog_new", title, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_combo_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkComboNew <-
function(show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkComboBoxEntry", "RGtk2")

  

  w <- .RGtkCall("S_gtk_combo_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboSetValueInList <-
function(object, val, ok.if.empty)
{
  checkPtrType(object, "GtkCombo")
  val <- as.logical(val)
  ok.if.empty <- as.logical(ok.if.empty)

  w <- .RGtkCall("S_gtk_combo_set_value_in_list", object, val, ok.if.empty, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboSetUseArrows <-
function(object, val)
{
  checkPtrType(object, "GtkCombo")
  val <- as.logical(val)

  w <- .RGtkCall("S_gtk_combo_set_use_arrows", object, val, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboSetUseArrowsAlways <-
function(object, val)
{
  checkPtrType(object, "GtkCombo")
  val <- as.logical(val)

  w <- .RGtkCall("S_gtk_combo_set_use_arrows_always", object, val, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboSetCaseSensitive <-
function(object, val)
{
  checkPtrType(object, "GtkCombo")
  val <- as.logical(val)

  w <- .RGtkCall("S_gtk_combo_set_case_sensitive", object, val, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboSetItemString <-
function(object, item, item.value)
{
  checkPtrType(object, "GtkCombo")
  checkPtrType(item, "GtkItem")
  item.value <- as.character(item.value)

  w <- .RGtkCall("S_gtk_combo_set_item_string", object, item, item.value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboSetPopdownStrings <-
function(object, strings)
{
  checkPtrType(object, "GtkCombo")
  strings <- as.GList(strings)

  w <- .RGtkCall("S_gtk_combo_set_popdown_strings", object, strings, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboDisableActivate <-
function(object)
{
  checkPtrType(object, "GtkCombo")

  w <- .RGtkCall("S_gtk_combo_disable_activate", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_combo_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_combo_box_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboBoxNewWithModel <-
function(model, show = TRUE)
{
  checkPtrType(model, "GtkTreeModel")

  w <- .RGtkCall("S_gtk_combo_box_new_with_model", model, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboBoxSetWrapWidth <-
function(object, width)
{
  checkPtrType(object, "GtkComboBox")
  width <- as.integer(width)

  w <- .RGtkCall("S_gtk_combo_box_set_wrap_width", object, width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxSetRowSpanColumn <-
function(object, row.span)
{
  checkPtrType(object, "GtkComboBox")
  row.span <- as.integer(row.span)

  w <- .RGtkCall("S_gtk_combo_box_set_row_span_column", object, row.span, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxSetColumnSpanColumn <-
function(object, column.span)
{
  checkPtrType(object, "GtkComboBox")
  column.span <- as.integer(column.span)

  w <- .RGtkCall("S_gtk_combo_box_set_column_span_column", object, column.span, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetActive <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_active", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxSetActive <-
function(object, index)
{
  checkPtrType(object, "GtkComboBox")
  index <- as.integer(index)

  w <- .RGtkCall("S_gtk_combo_box_set_active", object, index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetActiveIter <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_active_iter", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxSetActiveIter <-
function(object, iter)
{
  checkPtrType(object, "GtkComboBox")
  checkPtrType(iter, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_combo_box_set_active_iter", object, iter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxSetModel <-
function(object, model = NULL)
{
  checkPtrType(object, "GtkComboBox")
  if (!is.null( model )) checkPtrType(model, "GtkTreeModel")

  w <- .RGtkCall("S_gtk_combo_box_set_model", object, model, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetModel <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_model", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxNewText <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_combo_box_new_text", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboBoxAppendText <-
function(object, text)
{
  checkPtrType(object, "GtkComboBox")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_combo_box_append_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxInsertText <-
function(object, position, text)
{
  checkPtrType(object, "GtkComboBox")
  position <- as.integer(position)
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_combo_box_insert_text", object, position, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxPrependText <-
function(object, text)
{
  checkPtrType(object, "GtkComboBox")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_combo_box_prepend_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxRemoveText <-
function(object, position)
{
  checkPtrType(object, "GtkComboBox")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_combo_box_remove_text", object, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxPopup <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_popup", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxPopdown <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_popdown", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetWrapWidth <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_wrap_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetRowSpanColumn <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_row_span_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetColumnSpanColumn <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_column_span_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxSetAddTearoffs <-
function(object, add.tearoffs)
{
  checkPtrType(object, "GtkComboBox")
  add.tearoffs <- as.logical(add.tearoffs)

  w <- .RGtkCall("S_gtk_combo_box_set_add_tearoffs", object, add.tearoffs, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxGetAddTearoffs <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_add_tearoffs", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetFocusOnClick <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_focus_on_click", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxSetFocusOnClick <-
function(object, focus.on.click)
{
  checkPtrType(object, "GtkComboBox")
  focus.on.click <- as.logical(focus.on.click)

  w <- .RGtkCall("S_gtk_combo_box_set_focus_on_click", object, focus.on.click, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxSetRowSeparatorFunc <-
function(object, func, data = NULL)
{
  checkPtrType(object, "GtkComboBox")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_combo_box_set_row_separator_func", object, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetRowSeparatorFunc <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_row_separator_func", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetActiveText <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_active_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxGetPopupAccessible <-
function(object)
{
  checkPtrType(object, "GtkComboBox")

  w <- .RGtkCall("S_gtk_combo_box_get_popup_accessible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxEntryGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_combo_box_entry_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxEntryNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_combo_box_entry_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboBoxEntryNewWithModel <-
function(model, text.column, show = TRUE)
{
  checkPtrType(model, "GtkTreeModel")
  text.column <- as.integer(text.column)

  w <- .RGtkCall("S_gtk_combo_box_entry_new_with_model", model, text.column, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkComboBoxEntrySetTextColumn <-
function(object, text.column)
{
  checkPtrType(object, "GtkComboBoxEntry")
  text.column <- as.integer(text.column)

  w <- .RGtkCall("S_gtk_combo_box_entry_set_text_column", object, text.column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkComboBoxEntryGetTextColumn <-
function(object)
{
  checkPtrType(object, "GtkComboBoxEntry")

  w <- .RGtkCall("S_gtk_combo_box_entry_get_text_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkComboBoxEntryNewText <-
function()
{
  

  w <- .RGtkCall("S_gtk_combo_box_entry_new_text", PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_container_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerSetBorderWidth <-
function(object, border.width)
{
  checkPtrType(object, "GtkContainer")
  border.width <- as.numeric(border.width)

  w <- .RGtkCall("S_gtk_container_set_border_width", object, border.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetBorderWidth <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_border_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerAdd <-
function(object, widget)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_container_add", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerRemove <-
function(object, widget)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_container_remove", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerSetResizeMode <-
function(object, resize.mode)
{
  checkPtrType(object, "GtkContainer")
  

  w <- .RGtkCall("S_gtk_container_set_resize_mode", object, resize.mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetResizeMode <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_resize_mode", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerCheckResize <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_check_resize", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerForeach <-
function(object, callback, callback.data = NULL)
{
  checkPtrType(object, "GtkContainer")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_container_foreach", object, callback, callback.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerForeachFull <-
function(object, callback, callback.data = NULL)
{
  checkPtrType(object, "GtkContainer")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_container_foreach_full", object, callback, callback.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetChildren <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_children", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerChildren <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkContainerGetChildren", "RGtk2")

  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_children", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerPropagateExpose <-
function(object, child, event)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(child, "GtkWidget")
  checkPtrType(event, "GdkEventExpose")

  w <- .RGtkCall("S_gtk_container_propagate_expose", object, child, event, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerSetFocusChain <-
function(object, focusable.widgets)
{
  checkPtrType(object, "GtkContainer")
  focusable.widgets <- as.GList(focusable.widgets)

  w <- .RGtkCall("S_gtk_container_set_focus_chain", object, focusable.widgets, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetFocusChain <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_focus_chain", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerUnsetFocusChain <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_unset_focus_chain", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerSetReallocateRedraws <-
function(object, needs.redraws)
{
  checkPtrType(object, "GtkContainer")
  needs.redraws <- as.logical(needs.redraws)

  w <- .RGtkCall("S_gtk_container_set_reallocate_redraws", object, needs.redraws, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerSetFocusChild <-
function(object, child)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_container_set_focus_child", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerSetFocusVadjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_container_set_focus_vadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetFocusVadjustment <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_focus_vadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerSetFocusHadjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_container_set_focus_hadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerGetFocusHadjustment <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_get_focus_hadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerResizeChildren <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_resize_children", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerChildType <-
function(object)
{
  checkPtrType(object, "GtkContainer")

  w <- .RGtkCall("S_gtk_container_child_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerClassInstallChildProperty <-
function(cclass, property.id, pspec)
{
  checkPtrType(cclass, "GtkContainerClass")
  property.id <- as.numeric(property.id)
  pspec <- as.GParamSpec(pspec)

  w <- .RGtkCall("S_gtk_container_class_install_child_property", cclass, property.id, pspec, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerClassFindChildProperty <-
function(cclass, property.name)
{
  checkPtrType(cclass, "GObjectClass")
  property.name <- as.character(property.name)

  w <- .RGtkCall("S_gtk_container_class_find_child_property", cclass, property.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerClassListChildProperties <-
function(cclass)
{
  checkPtrType(cclass, "GObjectClass")

  w <- .RGtkCall("S_gtk_container_class_list_child_properties", cclass, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerChildSetProperty <-
function(object, child, property.name, value)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(child, "GtkWidget")
  property.name <- as.character(property.name)
  

  w <- .RGtkCall("S_gtk_container_child_set_property", object, child, property.name, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkContainerChildGetProperty <-
function(object, child, property.name)
{
  checkPtrType(object, "GtkContainer")
  checkPtrType(child, "GtkWidget")
  property.name <- as.character(property.name)

  w <- .RGtkCall("S_gtk_container_child_get_property", object, child, property.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkContainerForall <-
function(object, callback, callback.data = NULL)
{
  checkPtrType(object, "GtkContainer")
  callback <- as.function(callback)
  

  w <- .RGtkCall("S_gtk_container_forall", object, callback, callback.data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_ctree_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNewWithTitles <-
function(columns = 1, tree.column = 0, titles, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkTreeStore/GtkTreeView", "RGtk2")

  columns <- as.integer(columns)
  tree.column <- as.integer(tree.column)
  titles <- as.list(as.character(titles))

  w <- .RGtkCall("S_gtk_ctree_new_with_titles", columns, tree.column, titles, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCTreeNew <-
function(columns = 1, tree.column = 0, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkTreeStore/GtkTreeView", "RGtk2")

  columns <- as.integer(columns)
  tree.column <- as.integer(tree.column)

  w <- .RGtkCall("S_gtk_ctree_new", columns, tree.column, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCTreeInsertNode <-
function(object, parent, sibling, text, spacing = 5, pixmap.closed = NULL, mask.closed = NULL, pixmap.opened = NULL, mask.opened = NULL, is.leaf = 1, expanded = 0)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(parent, "GtkCTreeNode")
  checkPtrType(sibling, "GtkCTreeNode")
  text <- as.list(as.character(text))
  spacing <- as.raw(spacing)
  if (!is.null( pixmap.closed )) checkPtrType(pixmap.closed, "GdkPixmap")
  if (!is.null( mask.closed )) checkPtrType(mask.closed, "GdkBitmap")
  if (!is.null( pixmap.opened )) checkPtrType(pixmap.opened, "GdkPixmap")
  if (!is.null( mask.opened )) checkPtrType(mask.opened, "GdkBitmap")
  is.leaf <- as.logical(is.leaf)
  expanded <- as.logical(expanded)

  w <- .RGtkCall("S_gtk_ctree_insert_node", object, parent, sibling, text, spacing, pixmap.closed, mask.closed, pixmap.opened, mask.opened, is.leaf, expanded, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeRemoveNode <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_remove_node", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeInsertGnode <-
function(object, parent, sibling, gnode, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(parent, "GtkCTreeNode")
  checkPtrType(sibling, "GtkCTreeNode")
  checkPtrType(gnode, "GNode")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_insert_gnode", object, parent, sibling, gnode, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeExportToGnode <-
function(object, parent, sibling, node, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(parent, "GNode")
  checkPtrType(sibling, "GNode")
  checkPtrType(node, "GtkCTreeNode")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_export_to_gnode", object, parent, sibling, node, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreePostRecursive <-
function(object, node, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_post_recursive", object, node, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreePostRecursiveToDepth <-
function(object, node, depth, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  depth <- as.integer(depth)
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_post_recursive_to_depth", object, node, depth, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreePreRecursive <-
function(object, node, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_pre_recursive", object, node, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreePreRecursiveToDepth <-
function(object, node, depth, func, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  depth <- as.integer(depth)
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_ctree_pre_recursive_to_depth", object, node, depth, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeIsViewable <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_is_viewable", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeLast <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_last", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFindNodePtr <-
function(object, ctree.row)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(ctree.row, "GtkCTreeRow")

  w <- .RGtkCall("S_gtk_ctree_find_node_ptr", object, ctree.row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeNth <-
function(object, row)
{
  checkPtrType(object, "GtkCTree")
  row <- as.numeric(row)

  w <- .RGtkCall("S_gtk_ctree_node_nth", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFind <-
function(object, node, child)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  checkPtrType(child, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_find", object, node, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeIsAncestor <-
function(object, node, child)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  checkPtrType(child, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_is_ancestor", object, node, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFindByRowData <-
function(object, node, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  

  w <- .RGtkCall("S_gtk_ctree_find_by_row_data", object, node, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFindAllByRowData <-
function(object, node, data = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  

  w <- .RGtkCall("S_gtk_ctree_find_all_by_row_data", object, node, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFindByRowDataCustom <-
function(object, node, data = NULL, func)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  
  func <- as.function(func)

  w <- .RGtkCall("S_gtk_ctree_find_by_row_data_custom", object, node, data, func, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeFindAllByRowDataCustom <-
function(object, node, data = NULL, func)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  
  func <- as.function(func)

  w <- .RGtkCall("S_gtk_ctree_find_all_by_row_data_custom", object, node, data, func, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeIsHotSpot <-
function(object, x, y)
{
  checkPtrType(object, "GtkCTree")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_ctree_is_hot_spot", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeMove <-
function(object, node, new.parent = NULL, new.sibling = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  if (!is.null( new.parent )) checkPtrType(new.parent, "GtkCTreeNode")
  if (!is.null( new.sibling )) checkPtrType(new.sibling, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_move", object, node, new.parent, new.sibling, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeExpand <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_expand", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeExpandRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_expand_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeExpandToDepth <-
function(object, node, depth)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  depth <- as.integer(depth)

  w <- .RGtkCall("S_gtk_ctree_expand_to_depth", object, node, depth, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeCollapse <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_collapse", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeCollapseRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_collapse_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeCollapseToDepth <-
function(object, node, depth)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  depth <- as.integer(depth)

  w <- .RGtkCall("S_gtk_ctree_collapse_to_depth", object, node, depth, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeToggleExpansion <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_toggle_expansion", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeToggleExpansionRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_toggle_expansion_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSelect <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_select", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSelectRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_select_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeUnselect <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_unselect", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeUnselectRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_unselect_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeRealSelectRecursive <-
function(object, node, state)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  state <- as.integer(state)

  w <- .RGtkCall("S_gtk_ctree_real_select_recursive", object, node, state, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetText <-
function(object, node, column, text)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_ctree_node_set_text", object, node, column, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetPixmap <-
function(object, node, column, pixmap, mask = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_ctree_node_set_pixmap", object, node, column, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetPixtext <-
function(object, node, column, text, spacing, pixmap, mask = NULL)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  text <- as.character(text)
  spacing <- as.raw(spacing)
  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_ctree_node_set_pixtext", object, node, column, text, spacing, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSetNodeInfo <-
function(object, node, text, spacing, pixmap.closed = NULL, mask.closed = NULL, pixmap.opened = NULL, mask.opened = NULL, is.leaf, expanded)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  text <- as.character(text)
  spacing <- as.raw(spacing)
  if (!is.null( pixmap.closed )) checkPtrType(pixmap.closed, "GdkPixmap")
  if (!is.null( mask.closed )) checkPtrType(mask.closed, "GdkBitmap")
  if (!is.null( pixmap.opened )) checkPtrType(pixmap.opened, "GdkPixmap")
  if (!is.null( mask.opened )) checkPtrType(mask.opened, "GdkBitmap")
  is.leaf <- as.logical(is.leaf)
  expanded <- as.logical(expanded)

  w <- .RGtkCall("S_gtk_ctree_set_node_info", object, node, text, spacing, pixmap.closed, mask.closed, pixmap.opened, mask.opened, is.leaf, expanded, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetShift <-
function(object, node, column, vertical, horizontal)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  vertical <- as.integer(vertical)
  horizontal <- as.integer(horizontal)

  w <- .RGtkCall("S_gtk_ctree_node_set_shift", object, node, column, vertical, horizontal, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetSelectable <-
function(object, node, selectable)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  selectable <- as.logical(selectable)

  w <- .RGtkCall("S_gtk_ctree_node_set_selectable", object, node, selectable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeGetSelectable <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_node_get_selectable", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeGetCellType <-
function(object, node, column)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_ctree_node_get_cell_type", object, node, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeGetText <-
function(object, node, column)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_ctree_node_get_text", object, node, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeGetPixmap <-
function(object, node, column)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_ctree_node_get_pixmap", object, node, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeGetPixtext <-
function(object, node, column)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_ctree_node_get_pixtext", object, node, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeGetNodeInfo <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_get_node_info", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeSetRowStyle <-
function(object, node, style)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  checkPtrType(style, "GtkStyle")

  w <- .RGtkCall("S_gtk_ctree_node_set_row_style", object, node, style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeGetRowStyle <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_node_get_row_style", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeSetCellStyle <-
function(object, node, column, style)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  checkPtrType(style, "GtkStyle")

  w <- .RGtkCall("S_gtk_ctree_node_set_cell_style", object, node, column, style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeGetCellStyle <-
function(object, node, column)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_ctree_node_get_cell_style", object, node, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeSetForeground <-
function(object, node, color)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_ctree_node_set_foreground", object, node, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetBackground <-
function(object, node, color)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_ctree_node_set_background", object, node, color, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetRowData <-
function(object, node, data)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  

  w <- .RGtkCall("S_gtk_ctree_node_set_row_data", object, node, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeSetRowDataFull <-
function(object, node, data)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  

  w <- .RGtkCall("S_gtk_ctree_node_set_row_data_full", object, node, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeGetRowData <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_node_get_row_data", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeNodeMoveto <-
function(object, node, column, row.align, col.align)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")
  column <- as.integer(column)
  row.align <- as.numeric(row.align)
  col.align <- as.numeric(col.align)

  w <- .RGtkCall("S_gtk_ctree_node_moveto", object, node, column, row.align, col.align, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeIsVisible <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_node_is_visible", object, node, PACKAGE = "RGtk2")

  return(w)
} 


gtkCTreeSetIndent <-
function(object, indent)
{
  checkPtrType(object, "GtkCTree")
  indent <- as.integer(indent)

  w <- .RGtkCall("S_gtk_ctree_set_indent", object, indent, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSetSpacing <-
function(object, spacing)
{
  checkPtrType(object, "GtkCTree")
  spacing <- as.integer(spacing)

  w <- .RGtkCall("S_gtk_ctree_set_spacing", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSetShowStub <-
function(object, show.stub)
{
  checkPtrType(object, "GtkCTree")
  show.stub <- as.logical(show.stub)

  w <- .RGtkCall("S_gtk_ctree_set_show_stub", object, show.stub, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSetLineStyle <-
function(object, line.style)
{
  checkPtrType(object, "GtkCTree")
  

  w <- .RGtkCall("S_gtk_ctree_set_line_style", object, line.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSetExpanderStyle <-
function(object, expander.style)
{
  checkPtrType(object, "GtkCTree")
  

  w <- .RGtkCall("S_gtk_ctree_set_expander_style", object, expander.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSortNode <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_sort_node", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeSortRecursive <-
function(object, node)
{
  checkPtrType(object, "GtkCTree")
  checkPtrType(node, "GtkCTreeNode")

  w <- .RGtkCall("S_gtk_ctree_sort_recursive", object, node, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCTreeNodeGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_ctree_node_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCurveGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_curve_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkCurveNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_curve_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkCurveReset <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")

  w <- .RGtkCall("S_gtk_curve_reset", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCurveSetGamma <-
function(object, gamma)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")
  gamma <- as.numeric(gamma)

  w <- .RGtkCall("S_gtk_curve_set_gamma", object, gamma, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCurveSetRange <-
function(object, min.x, max.x, min.y, max.y)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")
  min.x <- as.numeric(min.x)
  max.x <- as.numeric(max.x)
  min.y <- as.numeric(min.y)
  max.y <- as.numeric(max.y)

  w <- .RGtkCall("S_gtk_curve_set_range", object, min.x, max.x, min.y, max.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCurveGetVector <-
function(object, veclen)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")
  veclen <- as.integer(veclen)

  w <- .RGtkCall("S_gtk_curve_get_vector", object, veclen, PACKAGE = "RGtk2")

  return(w)
} 


gtkCurveSetVector <-
function(object, vector)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")
  vector <- as.list(as.numeric(vector))

  w <- .RGtkCall("S_gtk_curve_set_vector", object, vector, PACKAGE = "RGtk2")

  return(w)
} 


gtkCurveSetCurveType <-
function(object, type)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkCurve")
  

  w <- .RGtkCall("S_gtk_curve_set_curve_type", object, type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkDialogNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_dialog_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkDialogAddActionWidget <-
function(object, child, response.id)
{
  checkPtrType(object, "GtkDialog")
  checkPtrType(child, "GtkWidget")
  response.id <- as.integer(response.id)

  w <- .RGtkCall("S_gtk_dialog_add_action_widget", object, child, response.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogAddButton <-
function(object, button.text, response.id)
{
  checkPtrType(object, "GtkDialog")
  button.text <- as.character(button.text)
  response.id <- as.integer(response.id)

  w <- .RGtkCall("S_gtk_dialog_add_button", object, button.text, response.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkDialogSetResponseSensitive <-
function(object, response.id, setting)
{
  checkPtrType(object, "GtkDialog")
  response.id <- as.integer(response.id)
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_dialog_set_response_sensitive", object, response.id, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogSetDefaultResponse <-
function(object, response.id)
{
  checkPtrType(object, "GtkDialog")
  response.id <- as.integer(response.id)

  w <- .RGtkCall("S_gtk_dialog_set_default_response", object, response.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogGetResponseForWidget <-
function(object, widget)
{
  checkPtrType(object, "GtkDialog")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_dialog_get_response_for_widget", object, widget, PACKAGE = "RGtk2")

  return(w)
} 


gtkDialogSetHasSeparator <-
function(object, setting)
{
  checkPtrType(object, "GtkDialog")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_dialog_set_has_separator", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogGetHasSeparator <-
function(object)
{
  checkPtrType(object, "GtkDialog")

  w <- .RGtkCall("S_gtk_dialog_get_has_separator", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkDialogResponse <-
function(object, response.id)
{
  checkPtrType(object, "GtkDialog")
  response.id <- as.integer(response.id)

  w <- .RGtkCall("S_gtk_dialog_response", object, response.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDialogRun <-
function(object)
{
  checkPtrType(object, "GtkDialog")

  w <- .RGtkCall("S_gtk_dialog_run", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkDialogSetAlternativeButtonOrderFromArray <-
function(object, new.order)
{
  checkPtrType(object, "GtkDialog")
  new.order <- as.list(as.integer(new.order))

  w <- .RGtkCall("S_gtk_dialog_set_alternative_button_order_from_array", object, new.order, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragCheckThreshold <-
function(object, start.x, start.y, current.x, current.y)
{
  checkPtrType(object, "GtkWidget")
  start.x <- as.integer(start.x)
  start.y <- as.integer(start.y)
  current.x <- as.integer(current.x)
  current.y <- as.integer(current.y)

  w <- .RGtkCall("S_gtk_drag_check_threshold", object, start.x, start.y, current.x, current.y, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragGetData <-
function(object, context, target, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(context, "GdkDragContext")
  target <- as.GdkAtom(target)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_drag_get_data", object, context, target, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragHighlight <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_highlight", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragUnhighlight <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_unhighlight", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragDestSet <-
function(object, flags, targets, actions)
{
  checkPtrType(object, "GtkWidget")
  
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })
  

  w <- .RGtkCall("S_gtk_drag_dest_set", object, flags, targets, actions, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragDestSetProxy <-
function(object, proxy.window, protocol, use.coordinates)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(proxy.window, "GdkWindow")
  
  use.coordinates <- as.logical(use.coordinates)

  w <- .RGtkCall("S_gtk_drag_dest_set_proxy", object, proxy.window, protocol, use.coordinates, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragDestUnset <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_dest_unset", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragDestFindTarget <-
function(object, context, target.list)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(context, "GdkDragContext")
  checkPtrType(target.list, "GtkTargetList")

  w <- .RGtkCall("S_gtk_drag_dest_find_target", object, context, target.list, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragDestGetTargetList <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_dest_get_target_list", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragDestSetTargetList <-
function(object, target.list)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(target.list, "GtkTargetList")

  w <- .RGtkCall("S_gtk_drag_dest_set_target_list", object, target.list, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceSet <-
function(object, start.button.mask, targets, actions)
{
  checkPtrType(object, "GtkWidget")
  
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })
  

  w <- .RGtkCall("S_gtk_drag_source_set", object, start.button.mask, targets, actions, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragSourceUnset <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_source_unset", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceSetIcon <-
function(object, colormap, pixmap, mask = NULL)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(colormap, "GdkColormap")
  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_drag_source_set_icon", object, colormap, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceSetIconPixbuf <-
function(object, pixbuf)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_drag_source_set_icon_pixbuf", object, pixbuf, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceSetIconStock <-
function(object, stock.id)
{
  checkPtrType(object, "GtkWidget")
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_drag_source_set_icon_stock", object, stock.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceGetTargetList <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_source_get_target_list", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragSourceSetTargetList <-
function(object, target.list)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(target.list, "GtkTargetList")

  w <- .RGtkCall("S_gtk_drag_source_set_target_list", object, target.list, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragBegin <-
function(object, targets, actions, button, event)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(targets, "GtkTargetList")
  
  button <- as.integer(button)
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gtk_drag_begin", object, targets, actions, button, event, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragSetDefaultIcon <-
function(colormap, pixmap, mask, hot.x, hot.y)
{
  if(getOption("depwarn"))
    .Deprecated("a different stock pixbuf for GTK_STOCK_DND", "RGtk2")

  checkPtrType(colormap, "GdkColormap")
  checkPtrType(pixmap, "GdkPixmap")
  checkPtrType(mask, "GdkBitmap")
  hot.x <- as.integer(hot.x)
  hot.y <- as.integer(hot.y)

  w <- .RGtkCall("S_gtk_drag_set_default_icon", colormap, pixmap, mask, hot.x, hot.y, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragDestAddTextTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_dest_add_text_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragDestAddImageTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_dest_add_image_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragDestAddUriTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_dest_add_uri_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceAddTextTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_source_add_text_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceAddImageTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_source_add_image_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDragSourceAddUriTargets <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_drag_source_add_uri_targets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTargetListAddTextTargets <-
function(list, info)
{
  checkPtrType(list, "GtkTargetList")
  info <- as.numeric(info)

  w <- .RGtkCall("S_gtk_target_list_add_text_targets", list, info, PACKAGE = "RGtk2")

  return(w)
} 


gtkTargetListAddImageTargets <-
function(list, info, writable)
{
  checkPtrType(list, "GtkTargetList")
  info <- as.numeric(info)
  writable <- as.logical(writable)

  w <- .RGtkCall("S_gtk_target_list_add_image_targets", list, info, writable, PACKAGE = "RGtk2")

  return(w)
} 


gtkTargetListAddUriTargets <-
function(list, info)
{
  checkPtrType(list, "GtkTargetList")
  info <- as.numeric(info)

  w <- .RGtkCall("S_gtk_target_list_add_uri_targets", list, info, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragGetSourceWidget <-
function(context)
{
  checkPtrType(context, "GdkDragContext")

  w <- .RGtkCall("S_gtk_drag_get_source_widget", context, PACKAGE = "RGtk2")

  return(w)
} 


gtkDragSourceSetIconName <-
function(widget, icon.name)
{
  checkPtrType(widget, "GtkWidget")
  icon.name <- as.character(icon.name)

  w <- .RGtkCall("S_gtk_drag_source_set_icon_name", widget, icon.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkDrawingAreaGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_drawing_area_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkDrawingAreaNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_drawing_area_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkDrawingAreaSize <-
function(object, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkWidgetSetSizeRequest", "RGtk2")

  checkPtrType(object, "GtkDrawingArea")
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_drawing_area_size", object, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_editable_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkEditableSelectRegion <-
function(object, start, end)
{
  checkPtrType(object, "GtkEditable")
  start <- as.integer(start)
  end <- as.integer(end)

  w <- .RGtkCall("S_gtk_editable_select_region", object, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableGetSelectionBounds <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_get_selection_bounds", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEditableInsertText <-
function(object, new.text, position = 0)
{
  checkPtrType(object, "GtkEditable")
  new.text <- as.character(new.text)
  position <- as.list(as.integer(position))

  w <- .RGtkCall("S_gtk_editable_insert_text", object, new.text, position, PACKAGE = "RGtk2")

  return(w)
} 


gtkEditableDeleteText <-
function(object, start.pos, end.pos)
{
  checkPtrType(object, "GtkEditable")
  start.pos <- as.integer(start.pos)
  end.pos <- as.integer(end.pos)

  w <- .RGtkCall("S_gtk_editable_delete_text", object, start.pos, end.pos, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableGetChars <-
function(object, start.pos, end.pos)
{
  checkPtrType(object, "GtkEditable")
  start.pos <- as.integer(start.pos)
  end.pos <- as.integer(end.pos)

  w <- .RGtkCall("S_gtk_editable_get_chars", object, start.pos, end.pos, PACKAGE = "RGtk2")

  return(w)
} 


gtkEditableCutClipboard <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_cut_clipboard", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableCopyClipboard <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_copy_clipboard", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditablePasteClipboard <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_paste_clipboard", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableDeleteSelection <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_delete_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableSetPosition <-
function(object, position)
{
  checkPtrType(object, "GtkEditable")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_editable_set_position", object, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableGetPosition <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_get_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEditableSetEditable <-
function(object, is.editable)
{
  checkPtrType(object, "GtkEditable")
  is.editable <- as.logical(is.editable)

  w <- .RGtkCall("S_gtk_editable_set_editable", object, is.editable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEditableGetEditable <-
function(object)
{
  checkPtrType(object, "GtkEditable")

  w <- .RGtkCall("S_gtk_editable_get_editable", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_entry_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_entry_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkEntryNewWithMaxLength <-
function(max = 0, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("gtkEntryNew", "RGtk2")

  max <- as.integer(max)

  w <- .RGtkCall("S_gtk_entry_new_with_max_length", max, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkEntrySetVisibility <-
function(object, visible)
{
  checkPtrType(object, "GtkEntry")
  visible <- as.logical(visible)

  w <- .RGtkCall("S_gtk_entry_set_visibility", object, visible, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetVisibility <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_visibility", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetInvisibleChar <-
function(object, ch)
{
  checkPtrType(object, "GtkEntry")
  ch <- as.numeric(ch)

  w <- .RGtkCall("S_gtk_entry_set_invisible_char", object, ch, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetInvisibleChar <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_invisible_char", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetHasFrame <-
function(object, setting)
{
  checkPtrType(object, "GtkEntry")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_entry_set_has_frame", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetHasFrame <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_has_frame", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetMaxLength <-
function(object, max)
{
  checkPtrType(object, "GtkEntry")
  max <- as.integer(max)

  w <- .RGtkCall("S_gtk_entry_set_max_length", object, max, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetMaxLength <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_max_length", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetActivatesDefault <-
function(object, setting)
{
  checkPtrType(object, "GtkEntry")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_entry_set_activates_default", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetActivatesDefault <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_activates_default", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetWidthChars <-
function(object, n.chars)
{
  checkPtrType(object, "GtkEntry")
  n.chars <- as.integer(n.chars)

  w <- .RGtkCall("S_gtk_entry_set_width_chars", object, n.chars, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetWidthChars <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_width_chars", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetText <-
function(object, text)
{
  checkPtrType(object, "GtkEntry")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_entry_set_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetText <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryGetLayout <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_layout", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryGetLayoutOffsets <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_layout_offsets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryLayoutIndexToTextIndex <-
function(object, layout.index)
{
  checkPtrType(object, "GtkEntry")
  layout.index <- as.integer(layout.index)

  w <- .RGtkCall("S_gtk_entry_layout_index_to_text_index", object, layout.index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryTextIndexToLayoutIndex <-
function(object, text.index)
{
  checkPtrType(object, "GtkEntry")
  text.index <- as.integer(text.index)

  w <- .RGtkCall("S_gtk_entry_text_index_to_layout_index", object, text.index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntrySetAlignment <-
function(object, xalign)
{
  checkPtrType(object, "GtkEntry")
  xalign <- as.numeric(xalign)

  w <- .RGtkCall("S_gtk_entry_set_alignment", object, xalign, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetAlignment <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_alignment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntrySetCompletion <-
function(object, completion)
{
  checkPtrType(object, "GtkEntry")
  checkPtrType(completion, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_set_completion", object, completion, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryGetCompletion <-
function(object)
{
  checkPtrType(object, "GtkEntry")

  w <- .RGtkCall("S_gtk_entry_get_completion", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryAppendText <-
function(object, text)
{
  if(getOption("depwarn"))
    .Deprecated("gtkEditableInsertText", "RGtk2")

  checkPtrType(object, "GtkEntry")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_entry_append_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryPrependText <-
function(object, text)
{
  if(getOption("depwarn"))
    .Deprecated("gtkEditableInsertText", "RGtk2")

  checkPtrType(object, "GtkEntry")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_entry_prepend_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntrySetPosition <-
function(object, position)
{
  checkPtrType(object, "GtkEntry")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_entry_set_position", object, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntrySelectRegion <-
function(object, start, end)
{
  checkPtrType(object, "GtkEntry")
  start <- as.integer(start)
  end <- as.integer(end)

  w <- .RGtkCall("S_gtk_entry_select_region", object, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntrySetEditable <-
function(object, editable)
{
  checkPtrType(object, "GtkEntry")
  editable <- as.logical(editable)

  w <- .RGtkCall("S_gtk_entry_set_editable", object, editable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_entry_completion_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_entry_completion_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionGetEntry <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_entry", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetModel <-
function(object, model = NULL)
{
  checkPtrType(object, "GtkEntryCompletion")
  if (!is.null( model )) checkPtrType(model, "GtkTreeModel")

  w <- .RGtkCall("S_gtk_entry_completion_set_model", object, model, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetModel <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_model", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetMatchFunc <-
function(object, func, func.data = NULL)
{
  checkPtrType(object, "GtkEntryCompletion")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_entry_completion_set_match_func", object, func, func.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetMinimumKeyLength <-
function(object, length)
{
  checkPtrType(object, "GtkEntryCompletion")
  length <- as.integer(length)

  w <- .RGtkCall("S_gtk_entry_completion_set_minimum_key_length", object, length, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetMinimumKeyLength <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_minimum_key_length", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionComplete <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_complete", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionInsertActionText <-
function(object, index, text)
{
  checkPtrType(object, "GtkEntryCompletion")
  index <- as.integer(index)
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_entry_completion_insert_action_text", object, index, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionInsertActionMarkup <-
function(object, index, markup)
{
  checkPtrType(object, "GtkEntryCompletion")
  index <- as.integer(index)
  markup <- as.character(markup)

  w <- .RGtkCall("S_gtk_entry_completion_insert_action_markup", object, index, markup, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionDeleteAction <-
function(object, index)
{
  checkPtrType(object, "GtkEntryCompletion")
  index <- as.integer(index)

  w <- .RGtkCall("S_gtk_entry_completion_delete_action", object, index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionSetTextColumn <-
function(object, column)
{
  checkPtrType(object, "GtkEntryCompletion")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_entry_completion_set_text_column", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetTextColumn <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_text_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionInsertPrefix <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_insert_prefix", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionSetInlineCompletion <-
function(object, inline.completion)
{
  checkPtrType(object, "GtkEntryCompletion")
  inline.completion <- as.logical(inline.completion)

  w <- .RGtkCall("S_gtk_entry_completion_set_inline_completion", object, inline.completion, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetInlineCompletion <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_inline_completion", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetPopupCompletion <-
function(object, popup.completion)
{
  checkPtrType(object, "GtkEntryCompletion")
  popup.completion <- as.logical(popup.completion)

  w <- .RGtkCall("S_gtk_entry_completion_set_popup_completion", object, popup.completion, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetPopupCompletion <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_popup_completion", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetPopupSetWidth <-
function(object, popup.set.width)
{
  checkPtrType(object, "GtkEntryCompletion")
  popup.set.width <- as.logical(popup.set.width)

  w <- .RGtkCall("S_gtk_entry_completion_set_popup_set_width", object, popup.set.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetPopupSetWidth <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_popup_set_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEntryCompletionSetPopupSingleMatch <-
function(object, popup.single.match)
{
  checkPtrType(object, "GtkEntryCompletion")
  popup.single.match <- as.logical(popup.single.match)

  w <- .RGtkCall("S_gtk_entry_completion_set_popup_single_match", object, popup.single.match, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEntryCompletionGetPopupSingleMatch <-
function(object)
{
  checkPtrType(object, "GtkEntryCompletion")

  w <- .RGtkCall("S_gtk_entry_completion_get_popup_single_match", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEventBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_event_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkEventBoxNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_event_box_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkEventBoxGetVisibleWindow <-
function(object)
{
  checkPtrType(object, "GtkEventBox")

  w <- .RGtkCall("S_gtk_event_box_get_visible_window", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEventBoxSetVisibleWindow <-
function(object, visible.window)
{
  checkPtrType(object, "GtkEventBox")
  visible.window <- as.logical(visible.window)

  w <- .RGtkCall("S_gtk_event_box_set_visible_window", object, visible.window, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkEventBoxGetAboveChild <-
function(object)
{
  checkPtrType(object, "GtkEventBox")

  w <- .RGtkCall("S_gtk_event_box_get_above_child", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkEventBoxSetAboveChild <-
function(object, above.child)
{
  checkPtrType(object, "GtkEventBox")
  above.child <- as.logical(above.child)

  w <- .RGtkCall("S_gtk_event_box_set_above_child", object, above.child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_expander_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderNew <-
function(label = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_expander_new", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkExpanderNewWithMnemonic <-
function(label = NULL)
{
  if (!is.null( label )) label <- as.character(label)

  w <- .RGtkCall("S_gtk_expander_new_with_mnemonic", label, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetExpanded <-
function(object, expanded)
{
  checkPtrType(object, "GtkExpander")
  expanded <- as.logical(expanded)

  w <- .RGtkCall("S_gtk_expander_set_expanded", object, expanded, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetExpanded <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_expanded", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetSpacing <-
function(object, spacing)
{
  checkPtrType(object, "GtkExpander")
  spacing <- as.integer(spacing)

  w <- .RGtkCall("S_gtk_expander_set_spacing", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetSpacing <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetLabel <-
function(object, label = NULL)
{
  checkPtrType(object, "GtkExpander")
  if (!is.null( label )) label <- as.character(label)

  w <- .RGtkCall("S_gtk_expander_set_label", object, label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetLabel <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetUseUnderline <-
function(object, use.underline)
{
  checkPtrType(object, "GtkExpander")
  use.underline <- as.logical(use.underline)

  w <- .RGtkCall("S_gtk_expander_set_use_underline", object, use.underline, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetUseUnderline <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_use_underline", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetUseMarkup <-
function(object, use.markup)
{
  checkPtrType(object, "GtkExpander")
  use.markup <- as.logical(use.markup)

  w <- .RGtkCall("S_gtk_expander_set_use_markup", object, use.markup, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetUseMarkup <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_use_markup", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkExpanderSetLabelWidget <-
function(object, label.widget = NULL)
{
  checkPtrType(object, "GtkExpander")
  if (!is.null( label.widget )) checkPtrType(label.widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_expander_set_label_widget", object, label.widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkExpanderGetLabelWidget <-
function(object)
{
  checkPtrType(object, "GtkExpander")

  w <- .RGtkCall("S_gtk_expander_get_label_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_chooser_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserErrorQuark <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_chooser_error_quark", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetAction <-
function(object, action)
{
  checkPtrType(object, "GtkFileChooser")
  

  w <- .RGtkCall("S_gtk_file_chooser_set_action", object, action, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetAction <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_action", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetLocalOnly <-
function(object, local.only)
{
  checkPtrType(object, "GtkFileChooser")
  local.only <- as.logical(local.only)

  w <- .RGtkCall("S_gtk_file_chooser_set_local_only", object, local.only, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetLocalOnly <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_local_only", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetSelectMultiple <-
function(object, select.multiple)
{
  checkPtrType(object, "GtkFileChooser")
  select.multiple <- as.logical(select.multiple)

  w <- .RGtkCall("S_gtk_file_chooser_set_select_multiple", object, select.multiple, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetSelectMultiple <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_select_multiple", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetShowHidden <-
function(object, show.hidden)
{
  checkPtrType(object, "GtkFileChooser")
  show.hidden <- as.logical(show.hidden)

  w <- .RGtkCall("S_gtk_file_chooser_set_show_hidden", object, show.hidden, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetShowHidden <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_show_hidden", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetDoOverwriteConfirmation <-
function(object, do.overwrite.confirmation)
{
  checkPtrType(object, "GtkFileChooser")
  do.overwrite.confirmation <- as.logical(do.overwrite.confirmation)

  w <- .RGtkCall("S_gtk_file_chooser_set_do_overwrite_confirmation", object, do.overwrite.confirmation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetDoOverwriteConfirmation <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_do_overwrite_confirmation", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetCurrentName <-
function(object, name)
{
  checkPtrType(object, "GtkFileChooser")
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_file_chooser_set_current_name", object, name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetFilename <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_filename", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetFilename <-
function(object, filename)
{
  checkPtrType(object, "GtkFileChooser")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_file_chooser_set_filename", object, filename, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSelectFilename <-
function(object, filename)
{
  checkPtrType(object, "GtkFileChooser")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_file_chooser_select_filename", object, filename, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserUnselectFilename <-
function(object, filename)
{
  checkPtrType(object, "GtkFileChooser")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_file_chooser_unselect_filename", object, filename, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserSelectAll <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_select_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserUnselectAll <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_unselect_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetFilenames <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_filenames", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetCurrentFolder <-
function(object, filename)
{
  checkPtrType(object, "GtkFileChooser")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_file_chooser_set_current_folder", object, filename, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetCurrentFolder <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_current_folder", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetUri <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_uri", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetUri <-
function(object, uri)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_set_uri", object, uri, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSelectUri <-
function(object, uri)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_select_uri", object, uri, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserUnselectUri <-
function(object, uri)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_unselect_uri", object, uri, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetUris <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_uris", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetCurrentFolderUri <-
function(object, uri)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_set_current_folder_uri", object, uri, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetCurrentFolderUri <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_current_folder_uri", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetPreviewWidget <-
function(object, preview.widget)
{
  checkPtrType(object, "GtkFileChooser")
  checkPtrType(preview.widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_file_chooser_set_preview_widget", object, preview.widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetPreviewWidget <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_preview_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetPreviewWidgetActive <-
function(object, active)
{
  checkPtrType(object, "GtkFileChooser")
  active <- as.logical(active)

  w <- .RGtkCall("S_gtk_file_chooser_set_preview_widget_active", object, active, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetPreviewWidgetActive <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_preview_widget_active", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetUsePreviewLabel <-
function(object, use.label)
{
  checkPtrType(object, "GtkFileChooser")
  use.label <- as.logical(use.label)

  w <- .RGtkCall("S_gtk_file_chooser_set_use_preview_label", object, use.label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetUsePreviewLabel <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_use_preview_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetPreviewFilename <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_preview_filename", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserGetPreviewUri <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_preview_uri", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetExtraWidget <-
function(object, extra.widget)
{
  checkPtrType(object, "GtkFileChooser")
  checkPtrType(extra.widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_file_chooser_set_extra_widget", object, extra.widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetExtraWidget <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_extra_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserAddFilter <-
function(object, filter)
{
  checkPtrType(object, "GtkFileChooser")
  checkPtrType(filter, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_chooser_add_filter", object, filter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserRemoveFilter <-
function(object, filter)
{
  checkPtrType(object, "GtkFileChooser")
  checkPtrType(filter, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_chooser_remove_filter", object, filter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserListFilters <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_list_filters", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserSetFilter <-
function(object, filter)
{
  checkPtrType(object, "GtkFileChooser")
  checkPtrType(filter, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_chooser_set_filter", object, filter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserGetFilter <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_get_filter", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserAddShortcutFolder <-
function(object, folder, .errwarn = TRUE)
{
  checkPtrType(object, "GtkFileChooser")
  folder <- as.character(folder)

  w <- .RGtkCall("S_gtk_file_chooser_add_shortcut_folder", object, folder, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkFileChooserRemoveShortcutFolder <-
function(object, folder, .errwarn = TRUE)
{
  checkPtrType(object, "GtkFileChooser")
  folder <- as.character(folder)

  w <- .RGtkCall("S_gtk_file_chooser_remove_shortcut_folder", object, folder, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkFileChooserListShortcutFolders <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_list_shortcut_folders", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserAddShortcutFolderUri <-
function(object, uri, .errwarn = TRUE)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_add_shortcut_folder_uri", object, uri, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkFileChooserRemoveShortcutFolderUri <-
function(object, uri, .errwarn = TRUE)
{
  checkPtrType(object, "GtkFileChooser")
  uri <- as.character(uri)

  w <- .RGtkCall("S_gtk_file_chooser_remove_shortcut_folder_uri", object, uri, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkFileChooserListShortcutFolderUris <-
function(object)
{
  checkPtrType(object, "GtkFileChooser")

  w <- .RGtkCall("S_gtk_file_chooser_list_shortcut_folder_uris", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_chooser_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserButtonNew <-
function(title, action, show = TRUE)
{
  title <- as.character(title)
  

  w <- .RGtkCall("S_gtk_file_chooser_button_new", title, action, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFileChooserButtonNewWithBackend <-
function(title, action, backend, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("gtkFileChooserButtonNew", "RGtk2")

  title <- as.character(title)
  
  backend <- as.character(backend)

  w <- .RGtkCall("S_gtk_file_chooser_button_new_with_backend", title, action, backend, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFileChooserButtonNewWithDialog <-
function(dialog)
{
  checkPtrType(dialog, "GtkWidget")

  w <- .RGtkCall("S_gtk_file_chooser_button_new_with_dialog", dialog, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserButtonGetTitle <-
function(object)
{
  checkPtrType(object, "GtkFileChooserButton")

  w <- .RGtkCall("S_gtk_file_chooser_button_get_title", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserButtonSetTitle <-
function(object, title)
{
  checkPtrType(object, "GtkFileChooserButton")
  title <- as.character(title)

  w <- .RGtkCall("S_gtk_file_chooser_button_set_title", object, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserButtonGetWidthChars <-
function(object)
{
  checkPtrType(object, "GtkFileChooserButton")

  w <- .RGtkCall("S_gtk_file_chooser_button_get_width_chars", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserButtonSetWidthChars <-
function(object, n.chars)
{
  checkPtrType(object, "GtkFileChooserButton")
  n.chars <- as.integer(n.chars)

  w <- .RGtkCall("S_gtk_file_chooser_button_set_width_chars", object, n.chars, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileChooserDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_chooser_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserWidgetGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_chooser_widget_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileChooserWidgetNew <-
function(action, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_file_chooser_widget_new", action, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFileChooserWidgetNewWithBackend <-
function(action, backend, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("gtkFileChooserWidgetNew", "RGtk2")

  
  backend <- as.character(backend)

  w <- .RGtkCall("S_gtk_file_chooser_widget_new_with_backend", action, backend, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFileFilterGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_filter_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileFilterNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_filter_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileFilterSetName <-
function(object, name)
{
  checkPtrType(object, "GtkFileFilter")
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_file_filter_set_name", object, name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileFilterGetName <-
function(object)
{
  checkPtrType(object, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_filter_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileFilterAddMimeType <-
function(object, mime.type)
{
  checkPtrType(object, "GtkFileFilter")
  mime.type <- as.character(mime.type)

  w <- .RGtkCall("S_gtk_file_filter_add_mime_type", object, mime.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileFilterAddPattern <-
function(object, pattern)
{
  checkPtrType(object, "GtkFileFilter")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_file_filter_add_pattern", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileFilterAddPixbufFormats <-
function(object)
{
  checkPtrType(object, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_filter_add_pixbuf_formats", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileFilterAddCustom <-
function(object, needed, func, data = NULL)
{
  checkPtrType(object, "GtkFileFilter")
  
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_file_filter_add_custom", object, needed, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileFilterGetNeeded <-
function(object)
{
  checkPtrType(object, "GtkFileFilter")

  w <- .RGtkCall("S_gtk_file_filter_get_needed", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileFilterFilter <-
function(object, filter.info)
{
  checkPtrType(object, "GtkFileFilter")
  filter.info <- as.GtkFileFilterInfo(filter.info)

  w <- .RGtkCall("S_gtk_file_filter_filter", object, filter.info, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileSelectionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_file_selection_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFileSelectionNew <-
function(title = NULL, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  

  w <- .RGtkCall("S_gtk_file_selection_new", title, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFileSelectionSetFilename <-
function(object, filename)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_file_selection_set_filename", object, filename, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileSelectionGetFilename <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")

  w <- .RGtkCall("S_gtk_file_selection_get_filename", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileSelectionComplete <-
function(object, pattern)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_file_selection_complete", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileSelectionShowFileopButtons <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")

  w <- .RGtkCall("S_gtk_file_selection_show_fileop_buttons", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileSelectionHideFileopButtons <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")

  w <- .RGtkCall("S_gtk_file_selection_hide_fileop_buttons", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileSelectionGetSelections <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")

  w <- .RGtkCall("S_gtk_file_selection_get_selections", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFileSelectionSetSelectMultiple <-
function(object, select.multiple)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")
  select.multiple <- as.logical(select.multiple)

  w <- .RGtkCall("S_gtk_file_selection_set_select_multiple", object, select.multiple, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFileSelectionGetSelectMultiple <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkFileChooser", "RGtk2")

  checkPtrType(object, "GtkFileSelection")

  w <- .RGtkCall("S_gtk_file_selection_get_select_multiple", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFixedGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_fixed_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFixedNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_fixed_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFixedPut <-
function(object, widget, x, y)
{
  checkPtrType(object, "GtkFixed")
  checkPtrType(widget, "GtkWidget")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_fixed_put", object, widget, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFixedMove <-
function(object, widget, x, y)
{
  checkPtrType(object, "GtkFixed")
  checkPtrType(widget, "GtkWidget")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_fixed_move", object, widget, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFixedSetHasWindow <-
function(object, has.window)
{
  checkPtrType(object, "GtkFixed")
  has.window <- as.logical(has.window)

  w <- .RGtkCall("S_gtk_fixed_set_has_window", object, has.window, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFixedGetHasWindow <-
function(object)
{
  checkPtrType(object, "GtkFixed")

  w <- .RGtkCall("S_gtk_fixed_get_has_window", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_font_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_font_button_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFontButtonNewWithFont <-
function(fontname)
{
  fontname <- as.character(fontname)

  w <- .RGtkCall("S_gtk_font_button_new_with_font", fontname, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonGetTitle <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_title", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetTitle <-
function(object, title)
{
  checkPtrType(object, "GtkFontButton")
  title <- as.character(title)

  w <- .RGtkCall("S_gtk_font_button_set_title", object, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontButtonGetUseFont <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_use_font", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetUseFont <-
function(object, use.font)
{
  checkPtrType(object, "GtkFontButton")
  use.font <- as.logical(use.font)

  w <- .RGtkCall("S_gtk_font_button_set_use_font", object, use.font, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontButtonGetUseSize <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_use_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetUseSize <-
function(object, use.size)
{
  checkPtrType(object, "GtkFontButton")
  use.size <- as.logical(use.size)

  w <- .RGtkCall("S_gtk_font_button_set_use_size", object, use.size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontButtonGetFontName <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_font_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetFontName <-
function(object, fontname)
{
  checkPtrType(object, "GtkFontButton")
  fontname <- as.character(fontname)

  w <- .RGtkCall("S_gtk_font_button_set_font_name", object, fontname, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonGetShowStyle <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_show_style", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetShowStyle <-
function(object, show.style)
{
  checkPtrType(object, "GtkFontButton")
  show.style <- as.logical(show.style)

  w <- .RGtkCall("S_gtk_font_button_set_show_style", object, show.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontButtonGetShowSize <-
function(object)
{
  checkPtrType(object, "GtkFontButton")

  w <- .RGtkCall("S_gtk_font_button_get_show_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontButtonSetShowSize <-
function(object, show.size)
{
  checkPtrType(object, "GtkFontButton")
  show.size <- as.logical(show.size)

  w <- .RGtkCall("S_gtk_font_button_set_show_size", object, show.size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontSelectionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_font_selection_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_font_selection_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFontSelectionGetFontName <-
function(object)
{
  checkPtrType(object, "GtkFontSelection")

  w <- .RGtkCall("S_gtk_font_selection_get_font_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionGetFont <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkFontSelectionGetFontName", "RGtk2")

  checkPtrType(object, "GtkFontSelection")

  w <- .RGtkCall("S_gtk_font_selection_get_font", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionSetFontName <-
function(object, fontname)
{
  checkPtrType(object, "GtkFontSelection")
  fontname <- as.character(fontname)

  w <- .RGtkCall("S_gtk_font_selection_set_font_name", object, fontname, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionGetPreviewText <-
function(object)
{
  checkPtrType(object, "GtkFontSelection")

  w <- .RGtkCall("S_gtk_font_selection_get_preview_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionSetPreviewText <-
function(object, text)
{
  checkPtrType(object, "GtkFontSelection")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_font_selection_set_preview_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFontSelectionDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_font_selection_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionDialogNew <-
function(title = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_font_selection_dialog_new", title, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFontSelectionDialogGetFontName <-
function(object)
{
  checkPtrType(object, "GtkFontSelectionDialog")

  w <- .RGtkCall("S_gtk_font_selection_dialog_get_font_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionDialogGetFont <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkFontSelectionGetFontName", "RGtk2")

  checkPtrType(object, "GtkFontSelectionDialog")

  w <- .RGtkCall("S_gtk_font_selection_dialog_get_font", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionDialogSetFontName <-
function(object, fontname)
{
  checkPtrType(object, "GtkFontSelectionDialog")
  fontname <- as.character(fontname)

  w <- .RGtkCall("S_gtk_font_selection_dialog_set_font_name", object, fontname, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionDialogGetPreviewText <-
function(object)
{
  checkPtrType(object, "GtkFontSelectionDialog")

  w <- .RGtkCall("S_gtk_font_selection_dialog_get_preview_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFontSelectionDialogSetPreviewText <-
function(object, text)
{
  checkPtrType(object, "GtkFontSelectionDialog")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_font_selection_dialog_set_preview_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_frame_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkFrameNew <-
function(label = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_frame_new", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkFrameSetLabel <-
function(object, label = NULL)
{
  checkPtrType(object, "GtkFrame")
  if (!is.null( label )) label <- as.character(label)

  w <- .RGtkCall("S_gtk_frame_set_label", object, label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameGetLabel <-
function(object)
{
  checkPtrType(object, "GtkFrame")

  w <- .RGtkCall("S_gtk_frame_get_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFrameSetLabelWidget <-
function(object, label.widget)
{
  checkPtrType(object, "GtkFrame")
  checkPtrType(label.widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_frame_set_label_widget", object, label.widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameGetLabelWidget <-
function(object)
{
  checkPtrType(object, "GtkFrame")

  w <- .RGtkCall("S_gtk_frame_get_label_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkFrameSetLabelAlign <-
function(object, xalign, yalign)
{
  checkPtrType(object, "GtkFrame")
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)

  w <- .RGtkCall("S_gtk_frame_set_label_align", object, xalign, yalign, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameGetLabelAlign <-
function(object)
{
  checkPtrType(object, "GtkFrame")

  w <- .RGtkCall("S_gtk_frame_get_label_align", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameSetShadowType <-
function(object, type)
{
  checkPtrType(object, "GtkFrame")
  

  w <- .RGtkCall("S_gtk_frame_set_shadow_type", object, type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkFrameGetShadowType <-
function(object)
{
  checkPtrType(object, "GtkFrame")

  w <- .RGtkCall("S_gtk_frame_get_shadow_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkGammaCurveGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_gamma_curve_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkGammaCurveNew <-
function(show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  

  w <- .RGtkCall("S_gtk_gamma_curve_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkGcGet <-
function(depth, colormap, values)
{
  depth <- as.integer(depth)
  checkPtrType(colormap, "GdkColormap")
  values <- as.GdkGCValues(values)

  w <- .RGtkCall("S_gtk_gc_get", depth, colormap, values, PACKAGE = "RGtk2")

  return(w)
} 


gtkGcRelease <-
function(gc)
{
  checkPtrType(gc, "GdkGC")

  w <- .RGtkCall("S_gtk_gc_release", gc, PACKAGE = "RGtk2")

  return(w)
} 


gtkHandleBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_handle_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHandleBoxNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_handle_box_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHandleBoxSetShadowType <-
function(object, type)
{
  checkPtrType(object, "GtkHandleBox")
  

  w <- .RGtkCall("S_gtk_handle_box_set_shadow_type", object, type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkHandleBoxGetShadowType <-
function(object)
{
  checkPtrType(object, "GtkHandleBox")

  w <- .RGtkCall("S_gtk_handle_box_get_shadow_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkHandleBoxSetHandlePosition <-
function(object, position)
{
  checkPtrType(object, "GtkHandleBox")
  

  w <- .RGtkCall("S_gtk_handle_box_set_handle_position", object, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkHandleBoxGetHandlePosition <-
function(object)
{
  checkPtrType(object, "GtkHandleBox")

  w <- .RGtkCall("S_gtk_handle_box_get_handle_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkHandleBoxSetSnapEdge <-
function(object, edge)
{
  checkPtrType(object, "GtkHandleBox")
  

  w <- .RGtkCall("S_gtk_handle_box_set_snap_edge", object, edge, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkHandleBoxGetSnapEdge <-
function(object)
{
  checkPtrType(object, "GtkHandleBox")

  w <- .RGtkCall("S_gtk_handle_box_get_snap_edge", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkHButtonBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hbutton_box_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHButtonBoxNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hbutton_box_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHButtonBoxGetSpacingDefault <-
function()
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  

  w <- .RGtkCall("S_gtk_hbutton_box_get_spacing_default", PACKAGE = "RGtk2")

  return(w)
} 


gtkHButtonBoxGetLayoutDefault <-
function()
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  

  w <- .RGtkCall("S_gtk_hbutton_box_get_layout_default", PACKAGE = "RGtk2")

  return(w)
} 


gtkHButtonBoxSetSpacingDefault <-
function(spacing)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  spacing <- as.integer(spacing)

  w <- .RGtkCall("S_gtk_hbutton_box_set_spacing_default", spacing, PACKAGE = "RGtk2")

  return(w)
} 


gtkHButtonBoxSetLayoutDefault <-
function(layout)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  

  w <- .RGtkCall("S_gtk_hbutton_box_set_layout_default", layout, PACKAGE = "RGtk2")

  return(w)
} 


gtkHBoxGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hbox_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHBoxNew <-
function(homogeneous = NULL, spacing = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hbox_new", homogeneous, spacing, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHPanedGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hpaned_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHPanedNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hpaned_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHRulerGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hruler_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHRulerNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hruler_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHScaleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hscale_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHScaleNew <-
function(adjustment = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hscale_new", adjustment, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHScaleNewWithRange <-
function(min, max, step, show = TRUE)
{
  min <- as.numeric(min)
  max <- as.numeric(max)
  step <- as.numeric(step)

  w <- .RGtkCall("S_gtk_hscale_new_with_range", min, max, step, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHScrollbarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hscrollbar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHScrollbarNew <-
function(adjustment = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hscrollbar_new", adjustment, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkHSeparatorGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_hseparator_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkHSeparatorNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_hseparator_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkIconFactoryGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_factory_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconFactoryNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_factory_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconFactoryAdd <-
function(object, stock.id, icon.set)
{
  checkPtrType(object, "GtkIconFactory")
  stock.id <- as.character(stock.id)
  checkPtrType(icon.set, "GtkIconSet")

  w <- .RGtkCall("S_gtk_icon_factory_add", object, stock.id, icon.set, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconFactoryLookup <-
function(object, stock.id)
{
  checkPtrType(object, "GtkIconFactory")
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_icon_factory_lookup", object, stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconFactoryAddDefault <-
function(object)
{
  checkPtrType(object, "GtkIconFactory")

  w <- .RGtkCall("S_gtk_icon_factory_add_default", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconFactoryRemoveDefault <-
function(object)
{
  checkPtrType(object, "GtkIconFactory")

  w <- .RGtkCall("S_gtk_icon_factory_remove_default", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconFactoryLookupDefault <-
function(stock.id)
{
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_icon_factory_lookup_default", stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeLookup <-
function(size)
{
  

  w <- .RGtkCall("S_gtk_icon_size_lookup", size, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeLookupForSettings <-
function(settings, size)
{
  checkPtrType(settings, "GtkSettings")
  

  w <- .RGtkCall("S_gtk_icon_size_lookup_for_settings", settings, size, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeRegister <-
function(name, width, height)
{
  name <- as.character(name)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_icon_size_register", name, width, height, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeRegisterAlias <-
function(alias, target)
{
  alias <- as.character(alias)
  

  w <- .RGtkCall("S_gtk_icon_size_register_alias", alias, target, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeFromName <-
function(name)
{
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_icon_size_from_name", name, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSizeGetName <-
function(size)
{
  

  w <- .RGtkCall("S_gtk_icon_size_get_name", size, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_set_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_set_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetNewFromPixbuf <-
function(pixbuf)
{
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_icon_set_new_from_pixbuf", pixbuf, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetCopy <-
function(object)
{
  checkPtrType(object, "GtkIconSet")

  w <- .RGtkCall("S_gtk_icon_set_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetRenderIcon <-
function(object, style, direction, state, size, widget = NULL, detail = NULL)
{
  checkPtrType(object, "GtkIconSet")
  checkPtrType(style, "GtkStyle")
  
  
  
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)

  w <- .RGtkCall("S_gtk_icon_set_render_icon", object, style, direction, state, size, widget, detail, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSetAddSource <-
function(object, source)
{
  checkPtrType(object, "GtkIconSet")
  checkPtrType(source, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_set_add_source", object, source, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSetGetSizes <-
function(object)
{
  checkPtrType(object, "GtkIconSet")

  w <- .RGtkCall("S_gtk_icon_set_get_sizes", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_source_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_source_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceCopy <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceSetFilename <-
function(object, filename)
{
  checkPtrType(object, "GtkIconSource")
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_icon_source_set_filename", object, filename, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetIconName <-
function(object, icon.name)
{
  checkPtrType(object, "GtkIconSource")
  icon.name <- as.character(icon.name)

  w <- .RGtkCall("S_gtk_icon_source_set_icon_name", object, icon.name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetPixbuf <-
function(object, pixbuf)
{
  checkPtrType(object, "GtkIconSource")
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_icon_source_set_pixbuf", object, pixbuf, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceGetFilename <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_filename", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetIconName <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_icon_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetPixbuf <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_pixbuf", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceSetDirectionWildcarded <-
function(object, setting)
{
  checkPtrType(object, "GtkIconSource")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_icon_source_set_direction_wildcarded", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetStateWildcarded <-
function(object, setting)
{
  checkPtrType(object, "GtkIconSource")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_icon_source_set_state_wildcarded", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetSizeWildcarded <-
function(object, setting)
{
  checkPtrType(object, "GtkIconSource")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_icon_source_set_size_wildcarded", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceGetSizeWildcarded <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_size_wildcarded", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetStateWildcarded <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_state_wildcarded", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetDirectionWildcarded <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_direction_wildcarded", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceSetDirection <-
function(object, direction)
{
  checkPtrType(object, "GtkIconSource")
  

  w <- .RGtkCall("S_gtk_icon_source_set_direction", object, direction, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetState <-
function(object, state)
{
  checkPtrType(object, "GtkIconSource")
  

  w <- .RGtkCall("S_gtk_icon_source_set_state", object, state, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceSetSize <-
function(object, size)
{
  checkPtrType(object, "GtkIconSource")
  

  w <- .RGtkCall("S_gtk_icon_source_set_size", object, size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconSourceGetDirection <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_direction", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetState <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_state", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconSourceGetSize <-
function(object)
{
  checkPtrType(object, "GtkIconSource")

  w <- .RGtkCall("S_gtk_icon_source_get_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeErrorQuark <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_theme_error_quark", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_theme_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_theme_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeGetDefault <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_theme_get_default", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeGetForScreen <-
function(screen)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_icon_theme_get_for_screen", screen, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeSetScreen <-
function(object, screen)
{
  checkPtrType(object, "GtkIconTheme")
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_icon_theme_set_screen", object, screen, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconThemeGetSearchPath <-
function(object)
{
  checkPtrType(object, "GtkIconTheme")

  w <- .RGtkCall("S_gtk_icon_theme_get_search_path", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconThemeAppendSearchPath <-
function(object, path)
{
  checkPtrType(object, "GtkIconTheme")
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_icon_theme_append_search_path", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconThemePrependSearchPath <-
function(object, path)
{
  checkPtrType(object, "GtkIconTheme")
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_icon_theme_prepend_search_path", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconThemeSetCustomTheme <-
function(object, theme.name)
{
  checkPtrType(object, "GtkIconTheme")
  theme.name <- as.character(theme.name)

  w <- .RGtkCall("S_gtk_icon_theme_set_custom_theme", object, theme.name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconThemeHasIcon <-
function(object, icon.name)
{
  checkPtrType(object, "GtkIconTheme")
  icon.name <- as.character(icon.name)

  w <- .RGtkCall("S_gtk_icon_theme_has_icon", object, icon.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeLookupIcon <-
function(object, icon.name, size, flags)
{
  checkPtrType(object, "GtkIconTheme")
  icon.name <- as.character(icon.name)
  size <- as.integer(size)
  

  w <- .RGtkCall("S_gtk_icon_theme_lookup_icon", object, icon.name, size, flags, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeLoadIcon <-
function(object, icon.name, size, flags, .errwarn = TRUE)
{
  checkPtrType(object, "GtkIconTheme")
  icon.name <- as.character(icon.name)
  size <- as.integer(size)
  

  w <- .RGtkCall("S_gtk_icon_theme_load_icon", object, icon.name, size, flags, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkIconThemeListIcons <-
function(object, context = NULL)
{
  checkPtrType(object, "GtkIconTheme")
  if (!is.null( context )) context <- as.character(context)

  w <- .RGtkCall("S_gtk_icon_theme_list_icons", object, context, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeGetExampleIconName <-
function(object)
{
  checkPtrType(object, "GtkIconTheme")

  w <- .RGtkCall("S_gtk_icon_theme_get_example_icon_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeRescanIfNeeded <-
function(object)
{
  checkPtrType(object, "GtkIconTheme")

  w <- .RGtkCall("S_gtk_icon_theme_rescan_if_needed", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeAddBuiltinIcon <-
function(icon.name, size, pixbuf)
{
  icon.name <- as.character(icon.name)
  size <- as.integer(size)
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_icon_theme_add_builtin_icon", icon.name, size, pixbuf, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_info_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoCopy <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetBaseSize <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_base_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetFilename <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_filename", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetBuiltinPixbuf <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_builtin_pixbuf", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoLoadIcon <-
function(object, .errwarn = TRUE)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_load_icon", object, PACKAGE = "RGtk2")

  w <- handleError(w, .errwarn)

  return(w)
} 


gtkIconInfoSetRawCoordinates <-
function(object, raw.coordinates)
{
  checkPtrType(object, "GtkIconInfo")
  raw.coordinates <- as.logical(raw.coordinates)

  w <- .RGtkCall("S_gtk_icon_info_set_raw_coordinates", object, raw.coordinates, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconInfoGetEmbeddedRect <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_embedded_rect", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetAttachPoints <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_attach_points", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconInfoGetDisplayName <-
function(object)
{
  checkPtrType(object, "GtkIconInfo")

  w <- .RGtkCall("S_gtk_icon_info_get_display_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconThemeGetIconSizes <-
function(object, icon.name)
{
  checkPtrType(object, "GtkIconTheme")
  icon.name <- as.character(icon.name)

  w <- .RGtkCall("S_gtk_icon_theme_get_icon_sizes", object, icon.name, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_icon_view_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_icon_view_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkIconViewNewWithModel <-
function(model = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_icon_view_new_with_model", model, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkIconViewSetModel <-
function(object, model = NULL)
{
  checkPtrType(object, "GtkIconView")
  if (!is.null( model )) checkPtrType(model, "GtkTreeModel")

  w <- .RGtkCall("S_gtk_icon_view_set_model", object, model, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetModel <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_model", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetTextColumn <-
function(object, column)
{
  checkPtrType(object, "GtkIconView")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_icon_view_set_text_column", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetTextColumn <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_text_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetMarkupColumn <-
function(object, column)
{
  checkPtrType(object, "GtkIconView")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_icon_view_set_markup_column", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetMarkupColumn <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_markup_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetPixbufColumn <-
function(object, column)
{
  checkPtrType(object, "GtkIconView")
  column <- as.integer(column)

  w <- .RGtkCall("S_gtk_icon_view_set_pixbuf_column", object, column, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetPixbufColumn <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_pixbuf_column", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetOrientation <-
function(object, orientation)
{
  checkPtrType(object, "GtkIconView")
  

  w <- .RGtkCall("S_gtk_icon_view_set_orientation", object, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetOrientation <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_orientation", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetColumns <-
function(object, columns)
{
  checkPtrType(object, "GtkIconView")
  columns <- as.integer(columns)

  w <- .RGtkCall("S_gtk_icon_view_set_columns", object, columns, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetColumns <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_columns", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetItemWidth <-
function(object, item.width)
{
  checkPtrType(object, "GtkIconView")
  item.width <- as.integer(item.width)

  w <- .RGtkCall("S_gtk_icon_view_set_item_width", object, item.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetItemWidth <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_item_width", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetSpacing <-
function(object, spacing)
{
  checkPtrType(object, "GtkIconView")
  spacing <- as.integer(spacing)

  w <- .RGtkCall("S_gtk_icon_view_set_spacing", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetSpacing <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetRowSpacing <-
function(object, row.spacing)
{
  checkPtrType(object, "GtkIconView")
  row.spacing <- as.integer(row.spacing)

  w <- .RGtkCall("S_gtk_icon_view_set_row_spacing", object, row.spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetRowSpacing <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_row_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetColumnSpacing <-
function(object, column.spacing)
{
  checkPtrType(object, "GtkIconView")
  column.spacing <- as.integer(column.spacing)

  w <- .RGtkCall("S_gtk_icon_view_set_column_spacing", object, column.spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetColumnSpacing <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_column_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetMargin <-
function(object, margin)
{
  checkPtrType(object, "GtkIconView")
  margin <- as.integer(margin)

  w <- .RGtkCall("S_gtk_icon_view_set_margin", object, margin, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetMargin <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_margin", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewGetPathAtPos <-
function(object, x, y)
{
  checkPtrType(object, "GtkIconView")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_icon_view_get_path_at_pos", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewGetItemAtPos <-
function(object, x, y)
{
  checkPtrType(object, "GtkIconView")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_icon_view_get_item_at_pos", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewGetVisibleRange <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_visible_range", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSelectedForeach <-
function(object, func, data = NULL)
{
  checkPtrType(object, "GtkIconView")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_icon_view_selected_foreach", object, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewSetSelectionMode <-
function(object, mode)
{
  checkPtrType(object, "GtkIconView")
  

  w <- .RGtkCall("S_gtk_icon_view_set_selection_mode", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetSelectionMode <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_selection_mode", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSelectPath <-
function(object, path)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_icon_view_select_path", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewUnselectPath <-
function(object, path)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_icon_view_unselect_path", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewPathIsSelected <-
function(object, path)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_icon_view_path_is_selected", object, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewGetSelectedItems <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_selected_items", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSelectAll <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_select_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewUnselectAll <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_unselect_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewItemActivated <-
function(object, path)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_icon_view_item_activated", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewSetCursor <-
function(object, path, cell, start.editing)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")
  checkPtrType(cell, "GtkCellRenderer")
  start.editing <- as.logical(start.editing)

  w <- .RGtkCall("S_gtk_icon_view_set_cursor", object, path, cell, start.editing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetCursor <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_cursor", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewScrollToPath <-
function(object, path, use.align, row.align, col.align)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")
  use.align <- as.logical(use.align)
  row.align <- as.numeric(row.align)
  col.align <- as.numeric(col.align)

  w <- .RGtkCall("S_gtk_icon_view_scroll_to_path", object, path, use.align, row.align, col.align, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewEnableModelDragSource <-
function(object, start.button.mask, targets, actions)
{
  checkPtrType(object, "GtkIconView")
  
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })
  

  w <- .RGtkCall("S_gtk_icon_view_enable_model_drag_source", object, start.button.mask, targets, actions, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewEnableModelDragDest <-
function(object, targets, actions)
{
  checkPtrType(object, "GtkIconView")
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })
  

  w <- .RGtkCall("S_gtk_icon_view_enable_model_drag_dest", object, targets, actions, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewUnsetModelDragSource <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_unset_model_drag_source", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewUnsetModelDragDest <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_unset_model_drag_dest", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewSetReorderable <-
function(object, reorderable)
{
  checkPtrType(object, "GtkIconView")
  reorderable <- as.logical(reorderable)

  w <- .RGtkCall("S_gtk_icon_view_set_reorderable", object, reorderable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetReorderable <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_reorderable", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewSetDragDestItem <-
function(object, path, pos)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")
  

  w <- .RGtkCall("S_gtk_icon_view_set_drag_dest_item", object, path, pos, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetDragDestItem <-
function(object)
{
  checkPtrType(object, "GtkIconView")

  w <- .RGtkCall("S_gtk_icon_view_get_drag_dest_item", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIconViewGetDestItemAtPos <-
function(object, drag.x, drag.y)
{
  checkPtrType(object, "GtkIconView")
  drag.x <- as.integer(drag.x)
  drag.y <- as.integer(drag.y)

  w <- .RGtkCall("S_gtk_icon_view_get_dest_item_at_pos", object, drag.x, drag.y, PACKAGE = "RGtk2")

  return(w)
} 


gtkIconViewCreateDragIcon <-
function(object, path)
{
  checkPtrType(object, "GtkIconView")
  checkPtrType(path, "GtkTreePath")

  w <- .RGtkCall("S_gtk_icon_view_create_drag_icon", object, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_image_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkImageNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_image_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromPixmap <-
function(pixmap = NULL, mask = NULL, show = TRUE)
{
  if (!is.null( pixmap )) checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_image_new_from_pixmap", pixmap, mask, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromImage <-
function(image = NULL, mask = NULL, show = TRUE)
{
  if (!is.null( image )) checkPtrType(image, "GdkImage")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_image_new_from_image", image, mask, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromFile <-
function(filename, show = TRUE)
{
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_image_new_from_file", filename, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromPixbuf <-
function(pixbuf = NULL, show = TRUE)
{
  if (!is.null( pixbuf )) checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_image_new_from_pixbuf", pixbuf, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromStock <-
function(stock.id, size, show = TRUE)
{
  stock.id <- as.character(stock.id)
  

  w <- .RGtkCall("S_gtk_image_new_from_stock", stock.id, size, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromIconSet <-
function(icon.set, size, show = TRUE)
{
  checkPtrType(icon.set, "GtkIconSet")
  

  w <- .RGtkCall("S_gtk_image_new_from_icon_set", icon.set, size, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageNewFromAnimation <-
function(animation, show = TRUE)
{
  checkPtrType(animation, "GdkPixbufAnimation")

  w <- .RGtkCall("S_gtk_image_new_from_animation", animation, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageClear <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromPixmap <-
function(object, pixmap, mask = NULL)
{
  checkPtrType(object, "GtkImage")
  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_image_set_from_pixmap", object, pixmap, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromImage <-
function(object, gdk.image = NULL, mask = NULL)
{
  checkPtrType(object, "GtkImage")
  if (!is.null( gdk.image )) checkPtrType(gdk.image, "GdkImage")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_image_set_from_image", object, gdk.image, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromFile <-
function(object, filename = NULL)
{
  checkPtrType(object, "GtkImage")
  if (!is.null( filename )) filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_image_set_from_file", object, filename, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromPixbuf <-
function(object, pixbuf = NULL)
{
  checkPtrType(object, "GtkImage")
  if (!is.null( pixbuf )) checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_image_set_from_pixbuf", object, pixbuf, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromStock <-
function(object, stock.id, size)
{
  checkPtrType(object, "GtkImage")
  stock.id <- as.character(stock.id)
  

  w <- .RGtkCall("S_gtk_image_set_from_stock", object, stock.id, size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromIconSet <-
function(object, icon.set, size)
{
  checkPtrType(object, "GtkImage")
  checkPtrType(icon.set, "GtkIconSet")
  

  w <- .RGtkCall("S_gtk_image_set_from_icon_set", object, icon.set, size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetFromAnimation <-
function(object, animation)
{
  checkPtrType(object, "GtkImage")
  checkPtrType(animation, "GdkPixbufAnimation")

  w <- .RGtkCall("S_gtk_image_set_from_animation", object, animation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetStorageType <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_storage_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageGetPixmap <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_pixmap", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetImage <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_image", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetPixbuf <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_pixbuf", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageGetStock <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_stock", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetIconSet <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_icon_set", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetAnimation <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_animation", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageSet <-
function(object, val, mask)
{
  checkPtrType(object, "GtkImage")
  checkPtrType(val, "GdkImage")
  checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_image_set", object, val, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGet <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageNewFromIconName <-
function(icon.name, size)
{
  icon.name <- as.character(icon.name)
  

  w <- .RGtkCall("S_gtk_image_new_from_icon_name", icon.name, size, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageSetFromIconName <-
function(object, icon.name, size)
{
  checkPtrType(object, "GtkImage")
  icon.name <- as.character(icon.name)
  

  w <- .RGtkCall("S_gtk_image_set_from_icon_name", object, icon.name, size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageSetPixelSize <-
function(object, pixel.size)
{
  checkPtrType(object, "GtkImage")
  pixel.size <- as.integer(pixel.size)

  w <- .RGtkCall("S_gtk_image_set_pixel_size", object, pixel.size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetIconName <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_icon_name", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageGetPixelSize <-
function(object)
{
  checkPtrType(object, "GtkImage")

  w <- .RGtkCall("S_gtk_image_get_pixel_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkImageMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_image_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkImageMenuItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_image_menu_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageMenuItemNewWithLabel <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_image_menu_item_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageMenuItemNewWithMnemonic <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_image_menu_item_new_with_mnemonic", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageMenuItemNewFromStock <-
function(stock.id, accel.group, show = TRUE)
{
  stock.id <- as.character(stock.id)
  checkPtrType(accel.group, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_image_menu_item_new_from_stock", stock.id, accel.group, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkImageMenuItemSetImage <-
function(object, image = NULL)
{
  checkPtrType(object, "GtkImageMenuItem")
  if (!is.null( image )) checkPtrType(image, "GtkWidget")

  w <- .RGtkCall("S_gtk_image_menu_item_set_image", object, image, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkImageMenuItemGetImage <-
function(object)
{
  checkPtrType(object, "GtkImageMenuItem")

  w <- .RGtkCall("S_gtk_image_menu_item_get_image", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_im_context_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextSetClientWindow <-
function(object, window)
{
  checkPtrType(object, "GtkIMContext")
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gtk_im_context_set_client_window", object, window, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextGetPreeditString <-
function(object)
{
  checkPtrType(object, "GtkIMContext")

  w <- .RGtkCall("S_gtk_im_context_get_preedit_string", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextFilterKeypress <-
function(object, event)
{
  checkPtrType(object, "GtkIMContext")
  checkPtrType(event, "GdkEventKey")

  w <- .RGtkCall("S_gtk_im_context_filter_keypress", object, event, PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextFocusIn <-
function(object)
{
  checkPtrType(object, "GtkIMContext")

  w <- .RGtkCall("S_gtk_im_context_focus_in", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextFocusOut <-
function(object)
{
  checkPtrType(object, "GtkIMContext")

  w <- .RGtkCall("S_gtk_im_context_focus_out", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextReset <-
function(object)
{
  checkPtrType(object, "GtkIMContext")

  w <- .RGtkCall("S_gtk_im_context_reset", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextSetCursorLocation <-
function(object, area)
{
  checkPtrType(object, "GtkIMContext")
  area <- as.GdkRectangle(area)

  w <- .RGtkCall("S_gtk_im_context_set_cursor_location", object, area, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextSetUsePreedit <-
function(object, use.preedit)
{
  checkPtrType(object, "GtkIMContext")
  use.preedit <- as.logical(use.preedit)

  w <- .RGtkCall("S_gtk_im_context_set_use_preedit", object, use.preedit, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextSetSurrounding <-
function(object, text, len, cursor.index)
{
  checkPtrType(object, "GtkIMContext")
  text <- as.character(text)
  len <- as.integer(len)
  cursor.index <- as.integer(cursor.index)

  w <- .RGtkCall("S_gtk_im_context_set_surrounding", object, text, len, cursor.index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkIMContextGetSurrounding <-
function(object)
{
  checkPtrType(object, "GtkIMContext")

  w <- .RGtkCall("S_gtk_im_context_get_surrounding", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextDeleteSurrounding <-
function(object, offset, n.chars)
{
  checkPtrType(object, "GtkIMContext")
  offset <- as.integer(offset)
  n.chars <- as.integer(n.chars)

  w <- .RGtkCall("S_gtk_im_context_delete_surrounding", object, offset, n.chars, PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextSimpleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_im_context_simple_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIMContextSimpleNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_im_context_simple_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIMMulticontextGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_im_multicontext_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkIMMulticontextNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_im_multicontext_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkIMMulticontextAppendMenuitems <-
function(object, menushell)
{
  checkPtrType(object, "GtkIMMulticontext")
  checkPtrType(menushell, "GtkMenuShell")

  w <- .RGtkCall("S_gtk_im_multicontext_append_menuitems", object, menushell, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkInputDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_input_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkInputDialogNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_input_dialog_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkInvisibleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_invisible_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkInvisibleNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_invisible_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkInvisibleNewForScreen <-
function(screen, show = TRUE)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_invisible_new_for_screen", screen, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkInvisibleSetScreen <-
function(object, screen)
{
  checkPtrType(object, "GtkInvisible")
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_invisible_set_screen", object, screen, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkInvisibleGetScreen <-
function(object)
{
  checkPtrType(object, "GtkInvisible")

  w <- .RGtkCall("S_gtk_invisible_get_screen", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkItemSelect <-
function(object)
{
  checkPtrType(object, "GtkItem")

  w <- .RGtkCall("S_gtk_item_select", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemDeselect <-
function(object)
{
  checkPtrType(object, "GtkItem")

  w <- .RGtkCall("S_gtk_item_deselect", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemToggle <-
function(object)
{
  checkPtrType(object, "GtkItem")

  w <- .RGtkCall("S_gtk_item_toggle", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_item_factory_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryNew <-
function(container.type, path, accel.group = NULL)
{
  if(getOption("depwarn"))
    .Deprecated("GtkUIManager", "RGtk2")

  container.type <- as.GType(container.type)
  path <- as.character(path)
  if (!is.null( accel.group )) checkPtrType(accel.group, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_item_factory_new", container.type, path, accel.group, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryConstruct <-
function(object, container.type, path, accel.group)
{
  checkPtrType(object, "GtkItemFactory")
  container.type <- as.GType(container.type)
  path <- as.character(path)
  checkPtrType(accel.group, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_item_factory_construct", object, container.type, path, accel.group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryAddForeign <-
function(accel.widget, full.path, accel.group, keyval, modifiers)
{
  checkPtrType(accel.widget, "GtkWidget")
  full.path <- as.character(full.path)
  checkPtrType(accel.group, "GtkAccelGroup")
  keyval <- as.numeric(keyval)
  

  w <- .RGtkCall("S_gtk_item_factory_add_foreign", accel.widget, full.path, accel.group, keyval, modifiers, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryFromWidget <-
function(widget)
{
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_item_factory_from_widget", widget, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryPathFromWidget <-
function(widget)
{
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_item_factory_path_from_widget", widget, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryGetItem <-
function(object, path)
{
  checkPtrType(object, "GtkItemFactory")
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_item_factory_get_item", object, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryGetWidget <-
function(object, path)
{
  checkPtrType(object, "GtkItemFactory")
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_item_factory_get_widget", object, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryGetWidgetByAction <-
function(object, action)
{
  checkPtrType(object, "GtkItemFactory")
  action <- as.numeric(action)

  w <- .RGtkCall("S_gtk_item_factory_get_widget_by_action", object, action, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryGetItemByAction <-
function(object, action)
{
  checkPtrType(object, "GtkItemFactory")
  action <- as.numeric(action)

  w <- .RGtkCall("S_gtk_item_factory_get_item_by_action", object, action, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryCreateItem <-
function(object, entry, callback.data = NULL, callback.type)
{
  checkPtrType(object, "GtkItemFactory")
  entry <- as.GtkItemFactoryEntry(entry)
  
  callback.type <- as.numeric(callback.type)

  w <- .RGtkCall("S_gtk_item_factory_create_item", object, entry, callback.data, callback.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryCreateItems <-
function(object, entries, callback.data = NULL)
{
  checkPtrType(object, "GtkItemFactory")
  entries <- lapply(entries, function(x) { x <- as.GtkItemFactoryEntry(x); x })
  

  w <- .RGtkCall("S_gtk_item_factory_create_items", object, entries, callback.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryDeleteItem <-
function(object, path)
{
  checkPtrType(object, "GtkItemFactory")
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_item_factory_delete_item", object, path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryDeleteEntry <-
function(object, entry)
{
  checkPtrType(object, "GtkItemFactory")
  entry <- as.GtkItemFactoryEntry(entry)

  w <- .RGtkCall("S_gtk_item_factory_delete_entry", object, entry, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryDeleteEntries <-
function(object, entries)
{
  checkPtrType(object, "GtkItemFactory")
  entries <- lapply(entries, function(x) { x <- as.GtkItemFactoryEntry(x); x })

  w <- .RGtkCall("S_gtk_item_factory_delete_entries", object, entries, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryPopup <-
function(object, x, y, mouse.button, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkItemFactory")
  x <- as.numeric(x)
  y <- as.numeric(y)
  mouse.button <- as.numeric(mouse.button)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_item_factory_popup", object, x, y, mouse.button, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkItemFactoryPopupWithData <-
function(object, popup.data, x, y, mouse.button, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkItemFactory")
  
  x <- as.numeric(x)
  y <- as.numeric(y)
  mouse.button <- as.numeric(mouse.button)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_item_factory_popup_with_data", object, popup.data, x, y, mouse.button, time, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryPopupData <-
function(object)
{
  checkPtrType(object, "GtkItemFactory")

  w <- .RGtkCall("S_gtk_item_factory_popup_data", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryPopupDataFromWidget <-
function(widget)
{
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_item_factory_popup_data_from_widget", widget, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactorySetTranslateFunc <-
function(object, func, data = NULL)
{
  checkPtrType(object, "GtkItemFactory")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_item_factory_set_translate_func", object, func, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryFromPath <-
function(path)
{
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_item_factory_from_path", path, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoriesPathDelete <-
function(ifactory.path, path)
{
  ifactory.path <- as.character(ifactory.path)
  path <- as.character(path)

  w <- .RGtkCall("S_gtk_item_factories_path_delete", ifactory.path, path, PACKAGE = "RGtk2")

  return(w)
} 


gtkItemFactoryCreateItemsAc <-
function(object, entries, callback.data, callback.type)
{
  checkPtrType(object, "GtkItemFactory")
  entries <- lapply(entries, function(x) { x <- as.GtkItemFactoryEntry(x); x })
  
  callback.type <- as.numeric(callback.type)

  w <- .RGtkCall("S_gtk_item_factory_create_items_ac", object, entries, callback.data, callback.type, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_label_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelNew <-
function(str = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_label_new", str, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkLabelNewWithMnemonic <-
function(str = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_label_new_with_mnemonic", str, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkLabelSetText <-
function(object, str)
{
  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set_text", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetText <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetAttributes <-
function(object, attrs)
{
  checkPtrType(object, "GtkLabel")
  checkPtrType(attrs, "PangoAttrList")

  w <- .RGtkCall("S_gtk_label_set_attributes", object, attrs, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetAttributes <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_attributes", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetLabel <-
function(object, str)
{
  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set_label", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetLabel <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_label", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetMarkup <-
function(object, str)
{
  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set_markup", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelSetUseMarkup <-
function(object, setting)
{
  checkPtrType(object, "GtkLabel")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_label_set_use_markup", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetUseMarkup <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_use_markup", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetUseUnderline <-
function(object, setting)
{
  checkPtrType(object, "GtkLabel")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_label_set_use_underline", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetUseUnderline <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_use_underline", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetMarkupWithMnemonic <-
function(object, str)
{
  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set_markup_with_mnemonic", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetMnemonicKeyval <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_mnemonic_keyval", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetMnemonicWidget <-
function(object, widget)
{
  checkPtrType(object, "GtkLabel")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_label_set_mnemonic_widget", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetMnemonicWidget <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_mnemonic_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetTextWithMnemonic <-
function(object, str)
{
  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set_text_with_mnemonic", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelSetJustify <-
function(object, jtype)
{
  checkPtrType(object, "GtkLabel")
  

  w <- .RGtkCall("S_gtk_label_set_justify", object, jtype, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetJustify <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_justify", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetPattern <-
function(object, pattern)
{
  checkPtrType(object, "GtkLabel")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_label_set_pattern", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelSetLineWrap <-
function(object, wrap)
{
  checkPtrType(object, "GtkLabel")
  wrap <- as.logical(wrap)

  w <- .RGtkCall("S_gtk_label_set_line_wrap", object, wrap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetLineWrap <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_line_wrap", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetSelectable <-
function(object, setting)
{
  checkPtrType(object, "GtkLabel")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_label_set_selectable", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetSelectable <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_selectable", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSelectRegion <-
function(object, start.offset, end.offset)
{
  checkPtrType(object, "GtkLabel")
  start.offset <- as.integer(start.offset)
  end.offset <- as.integer(end.offset)

  w <- .RGtkCall("S_gtk_label_select_region", object, start.offset, end.offset, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetSelectionBounds <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_selection_bounds", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelGetLayout <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_layout", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelGetLayoutOffsets <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_layout_offsets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelSet <-
function(object, str)
{
  if(getOption("depwarn"))
    .Deprecated("gtkLabelSetText", "RGtk2")

  checkPtrType(object, "GtkLabel")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_label_set", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGet <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkLabelGetText", "RGtk2")

  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelParseUline <-
function(object, string)
{
  checkPtrType(object, "GtkLabel")
  string <- as.character(string)

  w <- .RGtkCall("S_gtk_label_parse_uline", object, string, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetEllipsize <-
function(object, mode)
{
  checkPtrType(object, "GtkLabel")
  

  w <- .RGtkCall("S_gtk_label_set_ellipsize", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetEllipsize <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_ellipsize", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetAngle <-
function(object, angle)
{
  checkPtrType(object, "GtkLabel")
  angle <- as.integer(angle)

  w <- .RGtkCall("S_gtk_label_set_angle", object, angle, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetAngle <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_angle", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetWidthChars <-
function(object, n.chars)
{
  checkPtrType(object, "GtkLabel")
  n.chars <- as.integer(n.chars)

  w <- .RGtkCall("S_gtk_label_set_width_chars", object, n.chars, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetWidthChars <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_width_chars", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetMaxWidthChars <-
function(object, n.chars)
{
  checkPtrType(object, "GtkLabel")
  n.chars <- as.integer(n.chars)

  w <- .RGtkCall("S_gtk_label_set_max_width_chars", object, n.chars, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetMaxWidthChars <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_max_width_chars", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLabelSetSingleLineMode <-
function(object, single.line.mode)
{
  checkPtrType(object, "GtkLabel")
  single.line.mode <- as.logical(single.line.mode)

  w <- .RGtkCall("S_gtk_label_set_single_line_mode", object, single.line.mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLabelGetSingleLineMode <-
function(object)
{
  checkPtrType(object, "GtkLabel")

  w <- .RGtkCall("S_gtk_label_get_single_line_mode", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLayoutGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_layout_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkLayoutNew <-
function(hadjustment = NULL, vadjustment = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_layout_new", hadjustment, vadjustment, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkLayoutPut <-
function(object, child.widget, x, y)
{
  checkPtrType(object, "GtkLayout")
  checkPtrType(child.widget, "GtkWidget")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_layout_put", object, child.widget, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutMove <-
function(object, child.widget, x, y)
{
  checkPtrType(object, "GtkLayout")
  checkPtrType(child.widget, "GtkWidget")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_layout_move", object, child.widget, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutSetSize <-
function(object, width, height)
{
  checkPtrType(object, "GtkLayout")
  width <- as.numeric(width)
  height <- as.numeric(height)

  w <- .RGtkCall("S_gtk_layout_set_size", object, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutGetSize <-
function(object)
{
  checkPtrType(object, "GtkLayout")

  w <- .RGtkCall("S_gtk_layout_get_size", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutGetHadjustment <-
function(object)
{
  checkPtrType(object, "GtkLayout")

  w <- .RGtkCall("S_gtk_layout_get_hadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLayoutGetVadjustment <-
function(object)
{
  checkPtrType(object, "GtkLayout")

  w <- .RGtkCall("S_gtk_layout_get_vadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkLayoutSetHadjustment <-
function(object, adjustment = NULL)
{
  checkPtrType(object, "GtkLayout")
  if (!is.null( adjustment )) checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_layout_set_hadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutSetVadjustment <-
function(object, adjustment = NULL)
{
  checkPtrType(object, "GtkLayout")
  if (!is.null( adjustment )) checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_layout_set_vadjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutFreeze <-
function(object)
{
  checkPtrType(object, "GtkLayout")

  w <- .RGtkCall("S_gtk_layout_freeze", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkLayoutThaw <-
function(object)
{
  checkPtrType(object, "GtkLayout")

  w <- .RGtkCall("S_gtk_layout_thaw", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListGetType <-
function()
{
  if(getOption("depwarn"))
    .Deprecated("GtkListStore/GtkTreeView", "RGtk2")

  

  w <- .RGtkCall("S_gtk_list_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkListNew <-
function(show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkListStore/GtkTreeView", "RGtk2")

  

  w <- .RGtkCall("S_gtk_list_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkListInsertItems <-
function(object, items, position)
{
  checkPtrType(object, "GtkList")
  items <- as.GList(items)
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_list_insert_items", object, items, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListAppendItems <-
function(object, items)
{
  checkPtrType(object, "GtkList")
  items <- as.GList(items)

  w <- .RGtkCall("S_gtk_list_append_items", object, items, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListPrependItems <-
function(object, items)
{
  checkPtrType(object, "GtkList")
  items <- as.GList(items)

  w <- .RGtkCall("S_gtk_list_prepend_items", object, items, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListRemoveItems <-
function(object, items)
{
  checkPtrType(object, "GtkList")
  items <- as.GList(items)

  w <- .RGtkCall("S_gtk_list_remove_items", object, items, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListClearItems <-
function(object, start, end)
{
  checkPtrType(object, "GtkList")
  start <- as.integer(start)
  end <- as.integer(end)

  w <- .RGtkCall("S_gtk_list_clear_items", object, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListSelectItem <-
function(object, item)
{
  checkPtrType(object, "GtkList")
  item <- as.integer(item)

  w <- .RGtkCall("S_gtk_list_select_item", object, item, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListUnselectItem <-
function(object, item)
{
  checkPtrType(object, "GtkList")
  item <- as.integer(item)

  w <- .RGtkCall("S_gtk_list_unselect_item", object, item, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListSelectChild <-
function(object, child)
{
  checkPtrType(object, "GtkList")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_list_select_child", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListUnselectChild <-
function(object, child)
{
  checkPtrType(object, "GtkList")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_list_unselect_child", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListChildPosition <-
function(object, child)
{
  checkPtrType(object, "GtkList")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_list_child_position", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkListSetSelectionMode <-
function(object, mode)
{
  checkPtrType(object, "GtkList")
  

  w <- .RGtkCall("S_gtk_list_set_selection_mode", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListExtendSelection <-
function(object, scroll.type, position, auto.start.selection)
{
  checkPtrType(object, "GtkList")
  
  position <- as.numeric(position)
  auto.start.selection <- as.logical(auto.start.selection)

  w <- .RGtkCall("S_gtk_list_extend_selection", object, scroll.type, position, auto.start.selection, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStartSelection <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_start_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListEndSelection <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_end_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListSelectAll <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_select_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListUnselectAll <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_unselect_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListScrollHorizontal <-
function(object, scroll.type, position)
{
  checkPtrType(object, "GtkList")
  
  position <- as.numeric(position)

  w <- .RGtkCall("S_gtk_list_scroll_horizontal", object, scroll.type, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListScrollVertical <-
function(object, scroll.type, position)
{
  checkPtrType(object, "GtkList")
  
  position <- as.numeric(position)

  w <- .RGtkCall("S_gtk_list_scroll_vertical", object, scroll.type, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListToggleAddMode <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_toggle_add_mode", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListToggleFocusRow <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_toggle_focus_row", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListToggleRow <-
function(object, item)
{
  checkPtrType(object, "GtkList")
  checkPtrType(item, "GtkWidget")

  w <- .RGtkCall("S_gtk_list_toggle_row", object, item, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListUndoSelection <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_undo_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListEndDragSelection <-
function(object)
{
  checkPtrType(object, "GtkList")

  w <- .RGtkCall("S_gtk_list_end_drag_selection", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_list_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkListItemNew <-
function(show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkTreeView", "RGtk2")

  

  w <- .RGtkCall("S_gtk_list_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkListItemNewWithLabel <-
function(label, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkTreeView", "RGtk2")

  label <- as.character(label)

  w <- .RGtkCall("S_gtk_list_item_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkListItemSelect <-
function(object)
{
  checkPtrType(object, "GtkListItem")

  w <- .RGtkCall("S_gtk_list_item_select", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListItemDeselect <-
function(object)
{
  checkPtrType(object, "GtkListItem")

  w <- .RGtkCall("S_gtk_list_item_deselect", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_list_store_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreNewv <-
function(value)
{
  value <- as.list(as.GType(value))

  w <- .RGtkCall("S_gtk_list_store_newv", value, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreSetColumnTypes <-
function(object, types)
{
  checkPtrType(object, "GtkListStore")
  types <- as.list(as.GType(types))

  w <- .RGtkCall("S_gtk_list_store_set_column_types", object, types, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreSetValue <-
function(object, iter, column, value)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")
  column <- as.integer(column)
  

  w <- .RGtkCall("S_gtk_list_store_set_value", object, iter, column, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreRemove <-
function(object, iter)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_remove", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreInsert <-
function(object, position)
{
  checkPtrType(object, "GtkListStore")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_list_store_insert", object, position, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreInsertBefore <-
function(object, sibling)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(sibling, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_insert_before", object, sibling, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreInsertAfter <-
function(object, sibling)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(sibling, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_insert_after", object, sibling, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStorePrepend <-
function(object, iter)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_prepend", object, iter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreAppend <-
function(object)
{
  checkPtrType(object, "GtkListStore")

  w <- .RGtkCall("S_gtk_list_store_append", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreClear <-
function(object)
{
  checkPtrType(object, "GtkListStore")

  w <- .RGtkCall("S_gtk_list_store_clear", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreIterIsValid <-
function(object, iter)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_iter_is_valid", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkListStoreReorder <-
function(object, new.order)
{
  checkPtrType(object, "GtkListStore")
  new.order <- as.list(as.integer(new.order))

  w <- .RGtkCall("S_gtk_list_store_reorder", object, new.order, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreSwap <-
function(object, a, b)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(a, "GtkTreeIter")
  checkPtrType(b, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_swap", object, a, b, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreMoveAfter <-
function(object, iter, position = NULL)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")
  if (!is.null( position )) checkPtrType(position, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_move_after", object, iter, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkListStoreMoveBefore <-
function(object, iter, position = NULL)
{
  checkPtrType(object, "GtkListStore")
  checkPtrType(iter, "GtkTreeIter")
  if (!is.null( position )) checkPtrType(position, "GtkTreeIter")

  w <- .RGtkCall("S_gtk_list_store_move_before", object, iter, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkCheckVersion <-
function(required.major, required.minor, required.micro)
{
  required.major <- as.numeric(required.major)
  required.minor <- as.numeric(required.minor)
  required.micro <- as.numeric(required.micro)

  w <- .RGtkCall("S_gtk_check_version", required.major, required.minor, required.micro, PACKAGE = "RGtk2")

  return(w)
} 


gtkExit <-
function(error.code)
{
  error.code <- as.integer(error.code)

  w <- .RGtkCall("S_gtk_exit", error.code, PACKAGE = "RGtk2")

  return(w)
} 


gtkGetDefaultLanguage <-
function()
{
  

  w <- .RGtkCall("S_gtk_get_default_language", PACKAGE = "RGtk2")

  return(w)
} 


gtkEventsPending <-
function()
{
  

  w <- .RGtkCall("S_gtk_events_pending", PACKAGE = "RGtk2")

  return(w)
} 


gtkMainDoEvent <-
function(event)
{
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gtk_main_do_event", event, PACKAGE = "RGtk2")

  return(w)
} 


gtkMain <-
function()
{
  

  w <- .RGtkCall("S_gtk_main", PACKAGE = "RGtk2")

  return(w)
} 


gtkMainLevel <-
function()
{
  

  w <- .RGtkCall("S_gtk_main_level", PACKAGE = "RGtk2")

  return(w)
} 


gtkMainQuit <-
function()
{
  

  w <- .RGtkCall("S_gtk_main_quit", PACKAGE = "RGtk2")

  return(w)
} 


gtkMainIteration <-
function()
{
  

  w <- .RGtkCall("S_gtk_main_iteration", PACKAGE = "RGtk2")

  return(w)
} 


gtkMainIterationDo <-
function(blocking = TRUE)
{
  blocking <- as.logical(blocking)

  w <- .RGtkCall("S_gtk_main_iteration_do", blocking, PACKAGE = "RGtk2")

  return(w)
} 


gtkTrue <-
function()
{
  

  w <- .RGtkCall("S_gtk_true", PACKAGE = "RGtk2")

  return(w)
} 


gtkFalse <-
function()
{
  

  w <- .RGtkCall("S_gtk_false", PACKAGE = "RGtk2")

  return(w)
} 


gtkGrabAdd <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_grab_add", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkGrabGetCurrent <-
function()
{
  

  w <- .RGtkCall("S_gtk_grab_get_current", PACKAGE = "RGtk2")

  return(w)
} 


gtkGrabRemove <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_grab_remove", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkInitAdd <-
function(fun, data = NULL)
{
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_init_add", fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkQuitAddDestroy <-
function(main.level, object)
{
  main.level <- as.numeric(main.level)
  checkPtrType(object, "GtkObject")

  w <- .RGtkCall("S_gtk_quit_add_destroy", main.level, object, PACKAGE = "RGtk2")

  return(w)
} 


gtkQuitAdd <-
function(main.level, fun, data = NULL)
{
  main.level <- as.numeric(main.level)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_quit_add", main.level, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkQuitAddFull <-
function(main.level, fun, data = NULL)
{
  main.level <- as.numeric(main.level)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_quit_add_full", main.level, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkQuitRemove <-
function(quit.handler.id)
{
  quit.handler.id <- as.numeric(quit.handler.id)

  w <- .RGtkCall("S_gtk_quit_remove", quit.handler.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkQuitRemoveByData <-
function(data)
{
  

  w <- .RGtkCall("S_gtk_quit_remove_by_data", data, PACKAGE = "RGtk2")

  return(w)
} 


gtkTimeoutAdd <-
function(interval, fun, data = NULL)
{
  interval <- as.numeric(interval)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_timeout_add", interval, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkTimeoutAddFull <-
function(interval, fun, data = NULL)
{
  interval <- as.numeric(interval)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_timeout_add_full", interval, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkTimeoutRemove <-
function(timeout.handler.id)
{
  timeout.handler.id <- as.numeric(timeout.handler.id)

  w <- .RGtkCall("S_gtk_timeout_remove", timeout.handler.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkIdleAdd <-
function(fun, data = NULL)
{
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_idle_add", fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkIdleAddPriority <-
function(priority, fun, data = NULL)
{
  priority <- as.integer(priority)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_idle_add_priority", priority, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkIdleAddFull <-
function(priority, fun, data = NULL)
{
  priority <- as.integer(priority)
  fun <- as.function(fun)
  

  w <- .RGtkCall("S_gtk_idle_add_full", priority, fun, data, PACKAGE = "RGtk2")

  return(w)
} 


gtkIdleRemove <-
function(idle.handler.id)
{
  idle.handler.id <- as.numeric(idle.handler.id)

  w <- .RGtkCall("S_gtk_idle_remove", idle.handler.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkIdleRemoveByData <-
function(data)
{
  

  w <- .RGtkCall("S_gtk_idle_remove_by_data", data, PACKAGE = "RGtk2")

  return(w)
} 


gtkInputRemove <-
function(input.handler.id)
{
  input.handler.id <- as.numeric(input.handler.id)

  w <- .RGtkCall("S_gtk_input_remove", input.handler.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkKeySnooperInstall <-
function(snooper, func.data = NULL)
{
  snooper <- as.function(snooper)
  

  w <- .RGtkCall("S_gtk_key_snooper_install", snooper, func.data, PACKAGE = "RGtk2")

  return(w)
} 


gtkKeySnooperRemove <-
function(snooper.handler.id)
{
  snooper.handler.id <- as.numeric(snooper.handler.id)

  w <- .RGtkCall("S_gtk_key_snooper_remove", snooper.handler.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkGetCurrentEvent <-
function()
{
  

  w <- .RGtkCall("S_gtk_get_current_event", PACKAGE = "RGtk2")

  return(w)
} 


gtkGetCurrentEventTime <-
function()
{
  

  w <- .RGtkCall("S_gtk_get_current_event_time", PACKAGE = "RGtk2")

  return(w)
} 


gtkGetCurrentEventState <-
function()
{
  

  w <- .RGtkCall("S_gtk_get_current_event_state", PACKAGE = "RGtk2")

  return(w)
} 


gtkGetEventWidget <-
function(event)
{
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gtk_get_event_widget", event, PACKAGE = "RGtk2")

  return(w)
} 


gtkPropagateEvent <-
function(object, event)
{
  checkPtrType(object, "GtkWidget")
  checkPtrType(event, "GdkEvent")

  w <- .RGtkCall("S_gtk_propagate_event", object, event, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_menu_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_menu_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuPopup <-
function(object, parent.menu.shell = NULL, parent.menu.item = NULL, func = NULL, data = NULL, button, activate.time)
{
  checkPtrType(object, "GtkMenu")
  if (!is.null( parent.menu.shell )) checkPtrType(parent.menu.shell, "GtkWidget")
  if (!is.null( parent.menu.item )) checkPtrType(parent.menu.item, "GtkWidget")
  if (!is.null( func )) func <- as.function(func)
  
  button <- as.numeric(button)
  activate.time <- as.numeric(activate.time)

  w <- .RGtkCall("S_gtk_menu_popup", object, parent.menu.shell, parent.menu.item, func, data, button, activate.time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuReposition <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_reposition", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuPopdown <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_popdown", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetActive <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_get_active", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuSetActive <-
function(object, index)
{
  checkPtrType(object, "GtkMenu")
  index <- as.numeric(index)

  w <- .RGtkCall("S_gtk_menu_set_active", object, index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuSetAccelGroup <-
function(object, accel.group)
{
  checkPtrType(object, "GtkMenu")
  checkPtrType(accel.group, "GtkAccelGroup")

  w <- .RGtkCall("S_gtk_menu_set_accel_group", object, accel.group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetAccelGroup <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_get_accel_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuSetAccelPath <-
function(object, accel.path)
{
  checkPtrType(object, "GtkMenu")
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_menu_set_accel_path", object, accel.path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuDetach <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_detach", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetAttachWidget <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_get_attach_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuSetTearoffState <-
function(object, torn.off)
{
  checkPtrType(object, "GtkMenu")
  torn.off <- as.logical(torn.off)

  w <- .RGtkCall("S_gtk_menu_set_tearoff_state", object, torn.off, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetTearoffState <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_get_tearoff_state", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuSetTitle <-
function(object, title)
{
  checkPtrType(object, "GtkMenu")
  title <- as.character(title)

  w <- .RGtkCall("S_gtk_menu_set_title", object, title, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetTitle <-
function(object)
{
  checkPtrType(object, "GtkMenu")

  w <- .RGtkCall("S_gtk_menu_get_title", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuReorderChild <-
function(object, child, position)
{
  checkPtrType(object, "GtkMenu")
  checkPtrType(child, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_menu_reorder_child", object, child, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuSetScreen <-
function(object, screen = NULL)
{
  checkPtrType(object, "GtkMenu")
  if (!is.null( screen )) checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_menu_set_screen", object, screen, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuAttach <-
function(object, child, left.attach, right.attach, top.attach, bottom.attach)
{
  checkPtrType(object, "GtkMenu")
  checkPtrType(child, "GtkWidget")
  left.attach <- as.numeric(left.attach)
  right.attach <- as.numeric(right.attach)
  top.attach <- as.numeric(top.attach)
  bottom.attach <- as.numeric(bottom.attach)

  w <- .RGtkCall("S_gtk_menu_attach", object, child, left.attach, right.attach, top.attach, bottom.attach, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuSetMonitor <-
function(object, monitor.num)
{
  checkPtrType(object, "GtkMenu")
  monitor.num <- as.integer(monitor.num)

  w <- .RGtkCall("S_gtk_menu_set_monitor", object, monitor.num, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuGetForAttachWidget <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_get_for_attach_widget", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuBarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_menu_bar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuBarNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_menu_bar_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuBarGetPackDirection <-
function(object)
{
  checkPtrType(object, "GtkMenuBar")

  w <- .RGtkCall("S_gtk_menu_bar_get_pack_direction", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuBarSetPackDirection <-
function(object, pack.dir)
{
  checkPtrType(object, "GtkMenuBar")
  

  w <- .RGtkCall("S_gtk_menu_bar_set_pack_direction", object, pack.dir, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuBarGetChildPackDirection <-
function(object)
{
  checkPtrType(object, "GtkMenuBar")

  w <- .RGtkCall("S_gtk_menu_bar_get_child_pack_direction", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuBarSetChildPackDirection <-
function(object, child.pack.dir)
{
  checkPtrType(object, "GtkMenuBar")
  

  w <- .RGtkCall("S_gtk_menu_bar_set_child_pack_direction", object, child.pack.dir, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_menu_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuItemNewWithLabel <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_menu_item_new_with_label", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuItemNewWithMnemonic <-
function(label, show = TRUE)
{
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_menu_item_new_with_mnemonic", label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuItemSetSubmenu <-
function(object, submenu)
{
  checkPtrType(object, "GtkMenuItem")
  checkPtrType(submenu, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_item_set_submenu", object, submenu, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemGetSubmenu <-
function(object)
{
  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_get_submenu", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuItemRemoveSubmenu <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("setSubmenu", "RGtk2")

  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_remove_submenu", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemSelect <-
function(object)
{
  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_select", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemDeselect <-
function(object)
{
  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_deselect", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemActivate <-
function(object)
{
  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_activate", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemToggleSizeRequest <-
function(object, requisition)
{
  checkPtrType(object, "GtkMenuItem")
  requisition <- as.list(as.integer(requisition))

  w <- .RGtkCall("S_gtk_menu_item_toggle_size_request", object, requisition, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemToggleSizeAllocate <-
function(object, allocation)
{
  checkPtrType(object, "GtkMenuItem")
  allocation <- as.integer(allocation)

  w <- .RGtkCall("S_gtk_menu_item_toggle_size_allocate", object, allocation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemSetRightJustified <-
function(object, right.justified)
{
  checkPtrType(object, "GtkMenuItem")
  right.justified <- as.logical(right.justified)

  w <- .RGtkCall("S_gtk_menu_item_set_right_justified", object, right.justified, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemGetRightJustified <-
function(object)
{
  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_get_right_justified", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuItemSetAccelPath <-
function(object, accel.path)
{
  checkPtrType(object, "GtkMenuItem")
  accel.path <- as.character(accel.path)

  w <- .RGtkCall("S_gtk_menu_item_set_accel_path", object, accel.path, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuItemRightJustify <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkMenuItemSetRightJustified", "RGtk2")

  checkPtrType(object, "GtkMenuItem")

  w <- .RGtkCall("S_gtk_menu_item_right_justify", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_menu_shell_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuShellAppend <-
function(object, child)
{
  checkPtrType(object, "GtkMenuShell")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_shell_append", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellPrepend <-
function(object, child)
{
  checkPtrType(object, "GtkMenuShell")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_shell_prepend", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellInsert <-
function(object, child, position)
{
  checkPtrType(object, "GtkMenuShell")
  checkPtrType(child, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_menu_shell_insert", object, child, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellDeactivate <-
function(object)
{
  checkPtrType(object, "GtkMenuShell")

  w <- .RGtkCall("S_gtk_menu_shell_deactivate", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellSelectItem <-
function(object, menu.item)
{
  checkPtrType(object, "GtkMenuShell")
  checkPtrType(menu.item, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_shell_select_item", object, menu.item, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellDeselect <-
function(object)
{
  checkPtrType(object, "GtkMenuShell")

  w <- .RGtkCall("S_gtk_menu_shell_deselect", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellActivateItem <-
function(object, menu.item, force.deactivate)
{
  checkPtrType(object, "GtkMenuShell")
  checkPtrType(menu.item, "GtkWidget")
  force.deactivate <- as.logical(force.deactivate)

  w <- .RGtkCall("S_gtk_menu_shell_activate_item", object, menu.item, force.deactivate, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellSelectFirst <-
function(object, search.sensitive)
{
  checkPtrType(object, "GtkMenuShell")
  search.sensitive <- as.logical(search.sensitive)

  w <- .RGtkCall("S_gtk_menu_shell_select_first", object, search.sensitive, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellCancel <-
function(object)
{
  checkPtrType(object, "GtkMenuShell")

  w <- .RGtkCall("S_gtk_menu_shell_cancel", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuShellGetTakeFocus <-
function(object)
{
  checkPtrType(object, "GtkMenuShell")

  w <- .RGtkCall("S_gtk_menu_shell_get_take_focus", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuShellSetTakeFocus <-
function(object, take.focus)
{
  checkPtrType(object, "GtkMenuShell")
  take.focus <- as.logical(take.focus)

  w <- .RGtkCall("S_gtk_menu_shell_set_take_focus", object, take.focus, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuToolButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_menu_tool_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuToolButtonNew <-
function(icon.widget, label, show = TRUE)
{
  checkPtrType(icon.widget, "GtkWidget")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_menu_tool_button_new", icon.widget, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkMenuToolButtonNewFromStock <-
function(stock.id)
{
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_menu_tool_button_new_from_stock", stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuToolButtonSetMenu <-
function(object, menu)
{
  checkPtrType(object, "GtkMenuToolButton")
  checkPtrType(menu, "GtkWidget")

  w <- .RGtkCall("S_gtk_menu_tool_button_set_menu", object, menu, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMenuToolButtonGetMenu <-
function(object)
{
  checkPtrType(object, "GtkMenuToolButton")

  w <- .RGtkCall("S_gtk_menu_tool_button_get_menu", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkMenuToolButtonSetArrowTooltip <-
function(object, tooltips, tip.text = NULL, tip.private = NULL)
{
  if(getOption("depwarn"))
    .Deprecated("setArrowTooltipText", "RGtk2")

  checkPtrType(object, "GtkMenuToolButton")
  checkPtrType(tooltips, "GtkTooltips")
  if (!is.null( tip.text )) tip.text <- as.character(tip.text)
  if (!is.null( tip.private )) tip.private <- as.character(tip.private)

  w <- .RGtkCall("S_gtk_menu_tool_button_set_arrow_tooltip", object, tooltips, tip.text, tip.private, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMessageDialogGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_message_dialog_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMessageDialogSetMarkup <-
function(object, str)
{
  checkPtrType(object, "GtkMessageDialog")
  str <- as.character(str)

  w <- .RGtkCall("S_gtk_message_dialog_set_markup", object, str, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMiscGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_misc_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkMiscSetAlignment <-
function(object, xalign, yalign)
{
  checkPtrType(object, "GtkMisc")
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)

  w <- .RGtkCall("S_gtk_misc_set_alignment", object, xalign, yalign, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMiscGetAlignment <-
function(object)
{
  checkPtrType(object, "GtkMisc")

  w <- .RGtkCall("S_gtk_misc_get_alignment", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMiscSetPadding <-
function(object, xpad, ypad)
{
  checkPtrType(object, "GtkMisc")
  xpad <- as.integer(xpad)
  ypad <- as.integer(ypad)

  w <- .RGtkCall("S_gtk_misc_set_padding", object, xpad, ypad, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkMiscGetPadding <-
function(object)
{
  checkPtrType(object, "GtkMisc")

  w <- .RGtkCall("S_gtk_misc_get_padding", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_notebook_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_notebook_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkNotebookAppendPage <-
function(object, child, tab.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_append_page", object, child, tab.label, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookAppendPageMenu <-
function(object, child, tab.label = NULL, menu.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")
  if (!is.null( menu.label )) checkPtrType(menu.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_append_page_menu", object, child, tab.label, menu.label, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookPrependPage <-
function(object, child, tab.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_prepend_page", object, child, tab.label, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookPrependPageMenu <-
function(object, child, tab.label = NULL, menu.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")
  if (!is.null( menu.label )) checkPtrType(menu.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_prepend_page_menu", object, child, tab.label, menu.label, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookInsertPage <-
function(object, child, tab.label = NULL, position = -1)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_notebook_insert_page", object, child, tab.label, position, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookInsertPageMenu <-
function(object, child, tab.label = NULL, menu.label = NULL, position = -1)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")
  if (!is.null( menu.label )) checkPtrType(menu.label, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_notebook_insert_page_menu", object, child, tab.label, menu.label, position, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookRemovePage <-
function(object, page.num)
{
  checkPtrType(object, "GtkNotebook")
  page.num <- as.integer(page.num)

  w <- .RGtkCall("S_gtk_notebook_remove_page", object, page.num, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetCurrentPage <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_current_page", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookGetNthPage <-
function(object, page.num)
{
  checkPtrType(object, "GtkNotebook")
  page.num <- as.integer(page.num)

  w <- .RGtkCall("S_gtk_notebook_get_nth_page", object, page.num, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookGetNPages <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_n_pages", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookPageNum <-
function(object, child)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_page_num", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetCurrentPage <-
function(object, page.num)
{
  checkPtrType(object, "GtkNotebook")
  page.num <- as.integer(page.num)

  w <- .RGtkCall("S_gtk_notebook_set_current_page", object, page.num, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookNextPage <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_next_page", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookPrevPage <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_prev_page", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetShowBorder <-
function(object, show.border)
{
  checkPtrType(object, "GtkNotebook")
  show.border <- as.logical(show.border)

  w <- .RGtkCall("S_gtk_notebook_set_show_border", object, show.border, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetShowBorder <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_show_border", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetShowTabs <-
function(object, show.tabs)
{
  checkPtrType(object, "GtkNotebook")
  show.tabs <- as.logical(show.tabs)

  w <- .RGtkCall("S_gtk_notebook_set_show_tabs", object, show.tabs, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetShowTabs <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_show_tabs", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetTabPos <-
function(object, pos)
{
  checkPtrType(object, "GtkNotebook")
  

  w <- .RGtkCall("S_gtk_notebook_set_tab_pos", object, pos, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetTabPos <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_tab_pos", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetHomogeneousTabs <-
function(object, homogeneous)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  homogeneous <- as.logical(homogeneous)

  w <- .RGtkCall("S_gtk_notebook_set_homogeneous_tabs", object, homogeneous, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetTabBorder <-
function(object, border.width)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  border.width <- as.numeric(border.width)

  w <- .RGtkCall("S_gtk_notebook_set_tab_border", object, border.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetTabHborder <-
function(object, tab.hborder)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  tab.hborder <- as.numeric(tab.hborder)

  w <- .RGtkCall("S_gtk_notebook_set_tab_hborder", object, tab.hborder, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetTabVborder <-
function(object, tab.vborder)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  tab.vborder <- as.numeric(tab.vborder)

  w <- .RGtkCall("S_gtk_notebook_set_tab_vborder", object, tab.vborder, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetScrollable <-
function(object, scrollable)
{
  checkPtrType(object, "GtkNotebook")
  scrollable <- as.logical(scrollable)

  w <- .RGtkCall("S_gtk_notebook_set_scrollable", object, scrollable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetScrollable <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_get_scrollable", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookPopupEnable <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_popup_enable", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookPopupDisable <-
function(object)
{
  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_popup_disable", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetTabLabel <-
function(object, child)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_get_tab_label", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetTabLabel <-
function(object, child, tab.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( tab.label )) checkPtrType(tab.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_set_tab_label", object, child, tab.label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetTabLabelText <-
function(object, child, tab.text)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  tab.text <- as.character(tab.text)

  w <- .RGtkCall("S_gtk_notebook_set_tab_label_text", object, child, tab.text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetTabLabelText <-
function(object, child)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_get_tab_label_text", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookGetMenuLabel <-
function(object, child)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_get_menu_label", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetMenuLabel <-
function(object, child, menu.label = NULL)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  if (!is.null( menu.label )) checkPtrType(menu.label, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_set_menu_label", object, child, menu.label, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetMenuLabelText <-
function(object, child, menu.text)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  menu.text <- as.character(menu.text)

  w <- .RGtkCall("S_gtk_notebook_set_menu_label_text", object, child, menu.text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookGetMenuLabelText <-
function(object, child)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_get_menu_label_text", object, child, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookQueryTabLabelPacking <-
function(object, child)
{
  if(getOption("depwarn"))
    .Deprecated("'tab-expand' and 'tab-fill' child properties", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_notebook_query_tab_label_packing", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookSetTabLabelPacking <-
function(object, child, expand, fill, pack.type)
{
  if(getOption("depwarn"))
    .Deprecated("'tab-expand' and 'tab-fill' child properties", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  expand <- as.logical(expand)
  fill <- as.logical(fill)
  

  w <- .RGtkCall("S_gtk_notebook_set_tab_label_packing", object, child, expand, fill, pack.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookReorderChild <-
function(object, child, position)
{
  checkPtrType(object, "GtkNotebook")
  checkPtrType(child, "GtkWidget")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_notebook_reorder_child", object, child, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkNotebookCurrentPage <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkNotebookGetCurrentPage", "RGtk2")

  checkPtrType(object, "GtkNotebook")

  w <- .RGtkCall("S_gtk_notebook_current_page", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkNotebookSetPage <-
function(object, page.num)
{
  if(getOption("depwarn"))
    .Deprecated("gtkNotebookSetCurrentPage", "RGtk2")

  checkPtrType(object, "GtkNotebook")
  page.num <- as.integer(page.num)

  w <- .RGtkCall("S_gtk_notebook_set_page", object, page.num, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkObjectGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_object_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkOldEditableGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_old_editable_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkOldEditableClaimSelection <-
function(object, claim, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkOldEditable")
  claim <- as.logical(claim)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_old_editable_claim_selection", object, claim, time, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkOldEditableChanged <-
function(object)
{
  checkPtrType(object, "GtkOldEditable")

  w <- .RGtkCall("S_gtk_old_editable_changed", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkOptionMenuGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_option_menu_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkOptionMenuNew <-
function(show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkComboBox", "RGtk2")

  

  w <- .RGtkCall("S_gtk_option_menu_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkOptionMenuGetMenu <-
function(object)
{
  checkPtrType(object, "GtkOptionMenu")

  w <- .RGtkCall("S_gtk_option_menu_get_menu", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkOptionMenuSetMenu <-
function(object, menu)
{
  checkPtrType(object, "GtkOptionMenu")
  checkPtrType(menu, "GtkWidget")

  w <- .RGtkCall("S_gtk_option_menu_set_menu", object, menu, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkOptionMenuRemoveMenu <-
function(object)
{
  checkPtrType(object, "GtkOptionMenu")

  w <- .RGtkCall("S_gtk_option_menu_remove_menu", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkOptionMenuGetHistory <-
function(object)
{
  checkPtrType(object, "GtkOptionMenu")

  w <- .RGtkCall("S_gtk_option_menu_get_history", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkOptionMenuSetHistory <-
function(object, index)
{
  checkPtrType(object, "GtkOptionMenu")
  index <- as.numeric(index)

  w <- .RGtkCall("S_gtk_option_menu_set_history", object, index, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_paned_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkPanedAdd1 <-
function(object, child)
{
  checkPtrType(object, "GtkPaned")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_paned_add1", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedAdd2 <-
function(object, child)
{
  checkPtrType(object, "GtkPaned")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_paned_add2", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedPack1 <-
function(object, child, resize = FALSE, shrink = TRUE)
{
  checkPtrType(object, "GtkPaned")
  checkPtrType(child, "GtkWidget")
  resize <- as.logical(resize)
  shrink <- as.logical(shrink)

  w <- .RGtkCall("S_gtk_paned_pack1", object, child, resize, shrink, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedPack2 <-
function(object, child, resize = TRUE, shrink = TRUE)
{
  checkPtrType(object, "GtkPaned")
  checkPtrType(child, "GtkWidget")
  resize <- as.logical(resize)
  shrink <- as.logical(shrink)

  w <- .RGtkCall("S_gtk_paned_pack2", object, child, resize, shrink, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedGetPosition <-
function(object)
{
  checkPtrType(object, "GtkPaned")

  w <- .RGtkCall("S_gtk_paned_get_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkPanedSetPosition <-
function(object, position)
{
  checkPtrType(object, "GtkPaned")
  position <- as.integer(position)

  w <- .RGtkCall("S_gtk_paned_set_position", object, position, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPanedGetChild1 <-
function(object)
{
  checkPtrType(object, "GtkPaned")

  w <- .RGtkCall("S_gtk_paned_get_child1", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkPanedGetChild2 <-
function(object)
{
  checkPtrType(object, "GtkPaned")

  w <- .RGtkCall("S_gtk_paned_get_child2", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkPixmapGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_pixmap_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkPixmapNew <-
function(pixmap, mask = NULL, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkImage", "RGtk2")

  checkPtrType(pixmap, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_pixmap_new", pixmap, mask, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkPixmapSet <-
function(object, val, mask = NULL)
{
  checkPtrType(object, "GtkPixmap")
  checkPtrType(val, "GdkPixmap")
  if (!is.null( mask )) checkPtrType(mask, "GdkBitmap")

  w <- .RGtkCall("S_gtk_pixmap_set", object, val, mask, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPixmapGet <-
function(object)
{
  checkPtrType(object, "GtkPixmap")

  w <- .RGtkCall("S_gtk_pixmap_get", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPixmapSetBuildInsensitive <-
function(object, build)
{
  checkPtrType(object, "GtkPixmap")
  build <- as.logical(build)

  w <- .RGtkCall("S_gtk_pixmap_set_build_insensitive", object, build, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPlugGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_plug_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkPlugConstruct <-
function(object, socket.id)
{
  checkPtrType(object, "GtkPlug")
  socket.id <- as.GdkNativeWindow(socket.id)

  w <- .RGtkCall("S_gtk_plug_construct", object, socket.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPlugNew <-
function(socket.id, show = TRUE)
{
  socket.id <- as.GdkNativeWindow(socket.id)

  w <- .RGtkCall("S_gtk_plug_new", socket.id, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkPlugConstructForDisplay <-
function(object, display, socket.id)
{
  checkPtrType(object, "GtkPlug")
  checkPtrType(display, "GdkDisplay")
  socket.id <- as.GdkNativeWindow(socket.id)

  w <- .RGtkCall("S_gtk_plug_construct_for_display", object, display, socket.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPlugNewForDisplay <-
function(display, socket.id)
{
  checkPtrType(display, "GdkDisplay")
  socket.id <- as.GdkNativeWindow(socket.id)

  w <- .RGtkCall("S_gtk_plug_new_for_display", display, socket.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkPlugGetId <-
function(object)
{
  checkPtrType(object, "GtkPlug")

  w <- .RGtkCall("S_gtk_plug_get_id", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewUninit <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_uninit", PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewNew <-
function(type, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("GtkDrawingArea", "RGtk2")

  

  w <- .RGtkCall("S_gtk_preview_new", type, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkPreviewSize <-
function(object, width, height)
{
  checkPtrType(object, "GtkPreview")
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_preview_size", object, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPreviewPut <-
function(object, window, gc, srcx, srcy, destx, desty, width, height)
{
  checkPtrType(object, "GtkPreview")
  checkPtrType(window, "GdkWindow")
  checkPtrType(gc, "GdkGC")
  srcx <- as.integer(srcx)
  srcy <- as.integer(srcy)
  destx <- as.integer(destx)
  desty <- as.integer(desty)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_preview_put", object, window, gc, srcx, srcy, destx, desty, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPreviewDrawRow <-
function(object, data, y, w)
{
  checkPtrType(object, "GtkPreview")
  data <- as.list(as.raw(data))
  y <- as.integer(y)
  w <- as.integer(w)

  w <- .RGtkCall("S_gtk_preview_draw_row", object, data, y, w, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewSetExpand <-
function(object, expand)
{
  checkPtrType(object, "GtkPreview")
  expand <- as.logical(expand)

  w <- .RGtkCall("S_gtk_preview_set_expand", object, expand, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPreviewSetGamma <-
function(gamma)
{
  gamma <- as.numeric(gamma)

  w <- .RGtkCall("S_gtk_preview_set_gamma", gamma, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewSetColorCube <-
function(nred.shades, ngreen.shades, nblue.shades, ngray.shades)
{
  nred.shades <- as.numeric(nred.shades)
  ngreen.shades <- as.numeric(ngreen.shades)
  nblue.shades <- as.numeric(nblue.shades)
  ngray.shades <- as.numeric(ngray.shades)

  w <- .RGtkCall("S_gtk_preview_set_color_cube", nred.shades, ngreen.shades, nblue.shades, ngray.shades, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewSetInstallCmap <-
function(install.cmap)
{
  install.cmap <- as.integer(install.cmap)

  w <- .RGtkCall("S_gtk_preview_set_install_cmap", install.cmap, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewSetReserved <-
function(nreserved)
{
  nreserved <- as.integer(nreserved)

  w <- .RGtkCall("S_gtk_preview_set_reserved", nreserved, PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewSetDither <-
function(object, dither)
{
  checkPtrType(object, "GtkPreview")
  

  w <- .RGtkCall("S_gtk_preview_set_dither", object, dither, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPreviewGetVisual <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_get_visual", PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewGetCmap <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_get_cmap", PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewGetInfo <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_get_info", PACKAGE = "RGtk2")

  return(w)
} 


gtkPreviewReset <-
function()
{
  

  w <- .RGtkCall("S_gtk_preview_reset", PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_progress_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressSetShowText <-
function(object, show.text)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  show.text <- as.logical(show.text)

  w <- .RGtkCall("S_gtk_progress_set_show_text", object, show.text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressSetTextAlignment <-
function(object, x.align, y.align)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  x.align <- as.numeric(x.align)
  y.align <- as.numeric(y.align)

  w <- .RGtkCall("S_gtk_progress_set_text_alignment", object, x.align, y.align, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressSetFormatString <-
function(object, format)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  format <- as.character(format)

  w <- .RGtkCall("S_gtk_progress_set_format_string", object, format, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressSetAdjustment <-
function(object, adjustment)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_progress_set_adjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressConfigure <-
function(object, value, min, max)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  value <- as.numeric(value)
  min <- as.numeric(min)
  max <- as.numeric(max)

  w <- .RGtkCall("S_gtk_progress_configure", object, value, min, max, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressSetPercentage <-
function(object, percentage)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  percentage <- as.numeric(percentage)

  w <- .RGtkCall("S_gtk_progress_set_percentage", object, percentage, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressSetValue <-
function(object, value)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_progress_set_value", object, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressGetValue <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")

  w <- .RGtkCall("S_gtk_progress_get_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressSetActivityMode <-
function(object, activity.mode)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  activity.mode <- as.logical(activity.mode)

  w <- .RGtkCall("S_gtk_progress_set_activity_mode", object, activity.mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressGetCurrentText <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")

  w <- .RGtkCall("S_gtk_progress_get_current_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressGetTextFromValue <-
function(object, value)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_progress_get_text_from_value", object, value, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressGetCurrentPercentage <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")

  w <- .RGtkCall("S_gtk_progress_get_current_percentage", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressGetPercentageFromValue <-
function(object, value)
{
  if(getOption("depwarn"))
    .Deprecated("GtkProgressBar methods", "RGtk2")

  checkPtrType(object, "GtkProgress")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_progress_get_percentage_from_value", object, value, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_progress_bar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_progress_bar_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkProgressBarPulse <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_pulse", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetText <-
function(object, text)
{
  checkPtrType(object, "GtkProgressBar")
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_progress_bar_set_text", object, text, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetFraction <-
function(object, fraction)
{
  checkPtrType(object, "GtkProgressBar")
  fraction <- as.numeric(fraction)

  w <- .RGtkCall("S_gtk_progress_bar_set_fraction", object, fraction, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetPulseStep <-
function(object, fraction)
{
  checkPtrType(object, "GtkProgressBar")
  fraction <- as.numeric(fraction)

  w <- .RGtkCall("S_gtk_progress_bar_set_pulse_step", object, fraction, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetOrientation <-
function(object, orientation)
{
  checkPtrType(object, "GtkProgressBar")
  

  w <- .RGtkCall("S_gtk_progress_bar_set_orientation", object, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarGetText <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_get_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarGetFraction <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_get_fraction", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarGetPulseStep <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_get_pulse_step", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarGetOrientation <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_get_orientation", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkProgressBarNewWithAdjustment <-
function(adjustment = NULL, show = TRUE)
{
  if(getOption("depwarn"))
    .Deprecated("", "RGtk2")

  if (!is.null( adjustment )) checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_progress_bar_new_with_adjustment", adjustment, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkProgressBarSetBarStyle <-
function(object, style)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkProgressBar")
  

  w <- .RGtkCall("S_gtk_progress_bar_set_bar_style", object, style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetDiscreteBlocks <-
function(object, blocks)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkProgressBar")
  blocks <- as.numeric(blocks)

  w <- .RGtkCall("S_gtk_progress_bar_set_discrete_blocks", object, blocks, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetActivityStep <-
function(object, step)
{
  if(getOption("depwarn"))
    .Deprecated("'pulse-step' property", "RGtk2")

  checkPtrType(object, "GtkProgressBar")
  step <- as.numeric(step)

  w <- .RGtkCall("S_gtk_progress_bar_set_activity_step", object, step, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetActivityBlocks <-
function(object, blocks)
{
  if(getOption("depwarn"))
    .Deprecated("'pulse-step' property", "RGtk2")

  checkPtrType(object, "GtkProgressBar")
  blocks <- as.numeric(blocks)

  w <- .RGtkCall("S_gtk_progress_bar_set_activity_blocks", object, blocks, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarUpdate <-
function(object, percentage)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkProgressBar")
  percentage <- as.numeric(percentage)

  w <- .RGtkCall("S_gtk_progress_bar_update", object, percentage, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarSetEllipsize <-
function(object, mode)
{
  checkPtrType(object, "GtkProgressBar")
  

  w <- .RGtkCall("S_gtk_progress_bar_set_ellipsize", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkProgressBarGetEllipsize <-
function(object)
{
  checkPtrType(object, "GtkProgressBar")

  w <- .RGtkCall("S_gtk_progress_bar_get_ellipsize", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioActionGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_radio_action_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioActionNew <-
function(name = NULL, label = NULL, tooltip = NULL, stock.id = NULL, value = NULL)
{
  

  w <- .RGtkCall("S_gtk_radio_action_new", name, label, tooltip, stock.id, value, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioActionSetGroup <-
function(object, group)
{
  checkPtrType(object, "GtkRadioAction")
  group <- as.GSList(group)

  w <- .RGtkCall("S_gtk_radio_action_set_group", object, group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRadioActionGetGroup <-
function(object)
{
  checkPtrType(object, "GtkRadioAction")

  w <- .RGtkCall("S_gtk_radio_action_get_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioActionGetCurrentValue <-
function(object)
{
  checkPtrType(object, "GtkRadioAction")

  w <- .RGtkCall("S_gtk_radio_action_get_current_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_radio_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioButtonNewFromWidget <-
function(group = NULL, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioButton")

  w <- .RGtkCall("S_gtk_radio_button_new_from_widget", group, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioButtonNewWithLabelFromWidget <-
function(group = NULL, label, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioButton")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_radio_button_new_with_label_from_widget", group, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioButtonNewWithMnemonic <-
function(group, label, show = TRUE)
{
  group <- as.GSList(group)
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_radio_button_new_with_mnemonic", group, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioButtonNewWithMnemonicFromWidget <-
function(group = NULL, label, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioButton")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_radio_button_new_with_mnemonic_from_widget", group, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioButtonGetGroup <-
function(object)
{
  checkPtrType(object, "GtkRadioButton")

  w <- .RGtkCall("S_gtk_radio_button_get_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioButtonSetGroup <-
function(object, group)
{
  checkPtrType(object, "GtkRadioButton")
  group <- as.GSList(group)

  w <- .RGtkCall("S_gtk_radio_button_set_group", object, group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRadioButtonGroup <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkRadioButtonGetGroup", "RGtk2")

  checkPtrType(object, "GtkRadioButton")

  w <- .RGtkCall("S_gtk_radio_button_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_radio_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioMenuItemNewFromWidget <-
function(group = NULL, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioMenuItem")

  w <- .RGtkCall("S_gtk_radio_menu_item_new_from_widget", group, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioMenuItemNewWithMnemonicFromWidget <-
function(group = NULL, label, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioMenuItem")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_radio_menu_item_new_with_mnemonic_from_widget", group, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioMenuItemNewWithLabelFromWidget <-
function(group = NULL, label, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioMenuItem")
  label <- as.character(label)

  w <- .RGtkCall("S_gtk_radio_menu_item_new_with_label_from_widget", group, label, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioMenuItemGetGroup <-
function(object)
{
  checkPtrType(object, "GtkRadioMenuItem")

  w <- .RGtkCall("S_gtk_radio_menu_item_get_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioMenuItemSetGroup <-
function(object, group)
{
  checkPtrType(object, "GtkRadioMenuItem")
  group <- as.GSList(group)

  w <- .RGtkCall("S_gtk_radio_menu_item_set_group", object, group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRadioMenuItemGroup <-
function(object)
{
  if(getOption("depwarn"))
    .Deprecated("gtkRadioMenuItemGetGroup", "RGtk2")

  checkPtrType(object, "GtkRadioMenuItem")

  w <- .RGtkCall("S_gtk_radio_menu_item_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioToolButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_radio_tool_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRadioToolButtonNewFromWidget <-
function(group = NULL, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioToolButton")

  w <- .RGtkCall("S_gtk_radio_tool_button_new_from_widget", group, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioToolButtonNewWithStockFromWidget <-
function(group = NULL, stock.id, show = TRUE)
{
  if (!is.null( group )) checkPtrType(group, "GtkRadioToolButton")
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_radio_tool_button_new_with_stock_from_widget", group, stock.id, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkRadioToolButtonSetGroup <-
function(object, group)
{
  checkPtrType(object, "GtkRadioToolButton")
  group <- as.GSList(group)

  w <- .RGtkCall("S_gtk_radio_tool_button_set_group", object, group, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRadioToolButtonGetGroup <-
function(object)
{
  checkPtrType(object, "GtkRadioToolButton")

  w <- .RGtkCall("S_gtk_radio_tool_button_get_group", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRangeGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_range_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRangeSetUpdatePolicy <-
function(object, policy)
{
  checkPtrType(object, "GtkRange")
  

  w <- .RGtkCall("S_gtk_range_set_update_policy", object, policy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeGetUpdatePolicy <-
function(object)
{
  checkPtrType(object, "GtkRange")

  w <- .RGtkCall("S_gtk_range_get_update_policy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRangeSetAdjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkRange")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_range_set_adjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeGetAdjustment <-
function(object)
{
  checkPtrType(object, "GtkRange")

  w <- .RGtkCall("S_gtk_range_get_adjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRangeSetInverted <-
function(object, setting)
{
  checkPtrType(object, "GtkRange")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_range_set_inverted", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeGetInverted <-
function(object)
{
  checkPtrType(object, "GtkRange")

  w <- .RGtkCall("S_gtk_range_get_inverted", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRangeSetIncrements <-
function(object, step, page)
{
  checkPtrType(object, "GtkRange")
  step <- as.numeric(step)
  page <- as.numeric(page)

  w <- .RGtkCall("S_gtk_range_set_increments", object, step, page, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeSetRange <-
function(object, min, max)
{
  checkPtrType(object, "GtkRange")
  min <- as.numeric(min)
  max <- as.numeric(max)

  w <- .RGtkCall("S_gtk_range_set_range", object, min, max, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeSetValue <-
function(object, value)
{
  checkPtrType(object, "GtkRange")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_range_set_value", object, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRangeGetValue <-
function(object)
{
  checkPtrType(object, "GtkRange")

  w <- .RGtkCall("S_gtk_range_get_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcAddDefaultFile <-
function(filename)
{
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_rc_add_default_file", filename, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcSetDefaultFiles <-
function(filenames)
{
  filenames <- as.list(as.character(filenames))

  w <- .RGtkCall("S_gtk_rc_set_default_files", filenames, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetDefaultFiles <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_get_default_files", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetStyle <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_rc_get_style", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetStyleByPaths <-
function(settings, widget.path, class.path, type)
{
  checkPtrType(settings, "GtkSettings")
  widget.path <- as.character(widget.path)
  class.path <- as.character(class.path)
  type <- as.GType(type)

  w <- .RGtkCall("S_gtk_rc_get_style_by_paths", settings, widget.path, class.path, type, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcReparseAllForSettings <-
function(settings, force.load)
{
  checkPtrType(settings, "GtkSettings")
  force.load <- as.logical(force.load)

  w <- .RGtkCall("S_gtk_rc_reparse_all_for_settings", settings, force.load, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcResetStyles <-
function(settings)
{
  checkPtrType(settings, "GtkSettings")

  w <- .RGtkCall("S_gtk_rc_reset_styles", settings, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcFindPixmapInPath <-
function(settings, scanner = NULL, pixmap.file)
{
  checkPtrType(settings, "GtkSettings")
  if (!is.null( scanner )) checkPtrType(scanner, "GScanner")
  pixmap.file <- as.character(pixmap.file)

  w <- .RGtkCall("S_gtk_rc_find_pixmap_in_path", settings, scanner, pixmap.file, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcParse <-
function(filename)
{
  filename <- as.character(filename)

  w <- .RGtkCall("S_gtk_rc_parse", filename, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcParseString <-
function(rc.string)
{
  rc.string <- as.character(rc.string)

  w <- .RGtkCall("S_gtk_rc_parse_string", rc.string, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcReparseAll <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_reparse_all", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcAddWidgetNameStyle <-
function(object, pattern)
{
  checkPtrType(object, "GtkRcStyle")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_rc_add_widget_name_style", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRcAddWidgetClassStyle <-
function(object, pattern)
{
  checkPtrType(object, "GtkRcStyle")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_rc_add_widget_class_style", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRcAddClassStyle <-
function(object, pattern)
{
  checkPtrType(object, "GtkRcStyle")
  pattern <- as.character(pattern)

  w <- .RGtkCall("S_gtk_rc_add_class_style", object, pattern, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRcStyleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_style_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcStyleNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_style_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcStyleCopy <-
function(object)
{
  checkPtrType(object, "GtkRcStyle")

  w <- .RGtkCall("S_gtk_rc_style_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcFindModuleInPath <-
function(module.file)
{
  module.file <- as.character(module.file)

  w <- .RGtkCall("S_gtk_rc_find_module_in_path", module.file, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetThemeDir <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_get_theme_dir", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetModuleDir <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_get_module_dir", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetImModulePath <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_get_im_module_path", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcGetImModuleFile <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_get_im_module_file", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcScannerNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_rc_scanner_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkRcParseColor <-
function(scanner, color)
{
  checkPtrType(scanner, "GScanner")
  color <- as.GdkColor(color)

  w <- .RGtkCall("S_gtk_rc_parse_color", scanner, color, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcParseState <-
function(scanner)
{
  checkPtrType(scanner, "GScanner")

  w <- .RGtkCall("S_gtk_rc_parse_state", scanner, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcParsePriority <-
function(scanner)
{
  checkPtrType(scanner, "GScanner")

  w <- .RGtkCall("S_gtk_rc_parse_priority", scanner, PACKAGE = "RGtk2")

  return(w)
} 


gtkRulerGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_ruler_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkRulerSetMetric <-
function(object, metric)
{
  checkPtrType(object, "GtkRuler")
  

  w <- .RGtkCall("S_gtk_ruler_set_metric", object, metric, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRulerSetRange <-
function(object, lower, upper, position, max.size)
{
  checkPtrType(object, "GtkRuler")
  lower <- as.numeric(lower)
  upper <- as.numeric(upper)
  position <- as.numeric(position)
  max.size <- as.numeric(max.size)

  w <- .RGtkCall("S_gtk_ruler_set_range", object, lower, upper, position, max.size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkRulerGetMetric <-
function(object)
{
  checkPtrType(object, "GtkRuler")

  w <- .RGtkCall("S_gtk_ruler_get_metric", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkRulerGetRange <-
function(object)
{
  checkPtrType(object, "GtkRuler")

  w <- .RGtkCall("S_gtk_ruler_get_range", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScaleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_scale_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkScaleSetDigits <-
function(object, digits)
{
  checkPtrType(object, "GtkScale")
  digits <- as.integer(digits)

  w <- .RGtkCall("S_gtk_scale_set_digits", object, digits, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScaleGetDigits <-
function(object)
{
  checkPtrType(object, "GtkScale")

  w <- .RGtkCall("S_gtk_scale_get_digits", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScaleSetDrawValue <-
function(object, draw.value)
{
  checkPtrType(object, "GtkScale")
  draw.value <- as.logical(draw.value)

  w <- .RGtkCall("S_gtk_scale_set_draw_value", object, draw.value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScaleGetDrawValue <-
function(object)
{
  checkPtrType(object, "GtkScale")

  w <- .RGtkCall("S_gtk_scale_get_draw_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScaleSetValuePos <-
function(object, pos)
{
  checkPtrType(object, "GtkScale")
  

  w <- .RGtkCall("S_gtk_scale_set_value_pos", object, pos, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScaleGetValuePos <-
function(object)
{
  checkPtrType(object, "GtkScale")

  w <- .RGtkCall("S_gtk_scale_get_value_pos", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScaleGetLayout <-
function(object)
{
  checkPtrType(object, "GtkScale")

  w <- .RGtkCall("S_gtk_scale_get_layout", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScaleGetLayoutOffsets <-
function(object)
{
  checkPtrType(object, "GtkScale")

  w <- .RGtkCall("S_gtk_scale_get_layout_offsets", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrollbarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_scrollbar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_scrolled_window_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowNew <-
function(hadjustment = NULL, vadjustment = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_scrolled_window_new", hadjustment, vadjustment, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkScrolledWindowSetHadjustment <-
function(object, hadjustment)
{
  checkPtrType(object, "GtkScrolledWindow")
  checkPtrType(hadjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_scrolled_window_set_hadjustment", object, hadjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowSetVadjustment <-
function(object, hadjustment)
{
  checkPtrType(object, "GtkScrolledWindow")
  checkPtrType(hadjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_scrolled_window_set_vadjustment", object, hadjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowGetHadjustment <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_hadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowGetVadjustment <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_vadjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowGetHscrollbar <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_hscrollbar", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowGetVscrollbar <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_vscrollbar", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowSetPolicy <-
function(object, hscrollbar.policy, vscrollbar.policy)
{
  checkPtrType(object, "GtkScrolledWindow")
  
  

  w <- .RGtkCall("S_gtk_scrolled_window_set_policy", object, hscrollbar.policy, vscrollbar.policy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowGetPolicy <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_policy", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowSetPlacement <-
function(object, window.placement)
{
  checkPtrType(object, "GtkScrolledWindow")
  

  w <- .RGtkCall("S_gtk_scrolled_window_set_placement", object, window.placement, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowGetPlacement <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_placement", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowSetShadowType <-
function(object, type)
{
  checkPtrType(object, "GtkScrolledWindow")
  

  w <- .RGtkCall("S_gtk_scrolled_window_set_shadow_type", object, type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkScrolledWindowGetShadowType <-
function(object)
{
  checkPtrType(object, "GtkScrolledWindow")

  w <- .RGtkCall("S_gtk_scrolled_window_get_shadow_type", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkScrolledWindowAddWithViewport <-
function(object, child)
{
  checkPtrType(object, "GtkScrolledWindow")
  checkPtrType(child, "GtkWidget")

  w <- .RGtkCall("S_gtk_scrolled_window_add_with_viewport", object, child, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTargetListNew <-
function(targets)
{
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })

  w <- .RGtkCall("S_gtk_target_list_new", targets, PACKAGE = "RGtk2")

  return(w)
} 


gtkTargetListAdd <-
function(object, target, flags, info)
{
  checkPtrType(object, "GtkTargetList")
  target <- as.GdkAtom(target)
  flags <- as.numeric(flags)
  info <- as.numeric(info)

  w <- .RGtkCall("S_gtk_target_list_add", object, target, flags, info, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTargetListAddTable <-
function(object, targets)
{
  checkPtrType(object, "GtkTargetList")
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })

  w <- .RGtkCall("S_gtk_target_list_add_table", object, targets, PACKAGE = "RGtk2")

  return(w)
} 


gtkTargetListRemove <-
function(object, target)
{
  checkPtrType(object, "GtkTargetList")
  target <- as.GdkAtom(target)

  w <- .RGtkCall("S_gtk_target_list_remove", object, target, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTargetListFind <-
function(object, target)
{
  checkPtrType(object, "GtkTargetList")
  target <- as.GdkAtom(target)

  w <- .RGtkCall("S_gtk_target_list_find", object, target, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionOwnerSet <-
function(object, selection, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkWidget")
  selection <- as.GdkAtom(selection)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_selection_owner_set", object, selection, time, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionOwnerSetForDisplay <-
function(display, widget = NULL, selection, time = "GDK_CURRENT_TIME")
{
  checkPtrType(display, "GdkDisplay")
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  selection <- as.GdkAtom(selection)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_selection_owner_set_for_display", display, widget, selection, time, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionAddTarget <-
function(object, selection, target, info)
{
  checkPtrType(object, "GtkWidget")
  selection <- as.GdkAtom(selection)
  target <- as.GdkAtom(target)
  info <- as.numeric(info)

  w <- .RGtkCall("S_gtk_selection_add_target", object, selection, target, info, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSelectionAddTargets <-
function(object, selection, targets)
{
  checkPtrType(object, "GtkWidget")
  selection <- as.GdkAtom(selection)
  targets <- lapply(targets, function(x) { x <- as.GtkTargetEntry(x); x })

  w <- .RGtkCall("S_gtk_selection_add_targets", object, selection, targets, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionClearTargets <-
function(object, selection)
{
  checkPtrType(object, "GtkWidget")
  selection <- as.GdkAtom(selection)

  w <- .RGtkCall("S_gtk_selection_clear_targets", object, selection, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSelectionConvert <-
function(object, selection, target, time = "GDK_CURRENT_TIME")
{
  checkPtrType(object, "GtkWidget")
  selection <- as.GdkAtom(selection)
  target <- as.GdkAtom(target)
  time <- as.numeric(time)

  w <- .RGtkCall("S_gtk_selection_convert", object, selection, target, time, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataSetText <-
function(object, str, len = -1)
{
  checkPtrType(object, "GtkSelectionData")
  str <- as.character(str)
  len <- as.integer(len)

  w <- .RGtkCall("S_gtk_selection_data_set_text", object, str, len, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataGetText <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_get_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataGetTargets <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_get_targets", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataTargetsIncludeText <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_targets_include_text", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionRemoveAll <-
function(object)
{
  checkPtrType(object, "GtkWidget")

  w <- .RGtkCall("S_gtk_selection_remove_all", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSelectionClear <-
function(object, event)
{
  if(getOption("depwarn"))
    .Deprecated("a chain up from 'selection-clear-event' handler", "RGtk2")

  checkPtrType(object, "GtkWidget")
  checkPtrType(event, "GdkEventSelection")

  w <- .RGtkCall("S_gtk_selection_clear", object, event, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_selection_data_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataCopy <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataSetPixbuf <-
function(object, pixbuf)
{
  checkPtrType(object, "GtkSelectionData")
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_selection_data_set_pixbuf", object, pixbuf, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataGetPixbuf <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_get_pixbuf", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataSetUris <-
function(object, uris)
{
  checkPtrType(object, "GtkSelectionData")
  uris <- as.list(as.character(uris))

  w <- .RGtkCall("S_gtk_selection_data_set_uris", object, uris, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataGetUris <-
function(object)
{
  checkPtrType(object, "GtkSelectionData")

  w <- .RGtkCall("S_gtk_selection_data_get_uris", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSelectionDataTargetsIncludeImage <-
function(object, writable)
{
  checkPtrType(object, "GtkSelectionData")
  writable <- as.logical(writable)

  w <- .RGtkCall("S_gtk_selection_data_targets_include_image", object, writable, PACKAGE = "RGtk2")

  return(w)
} 


gtkSeparatorGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_separator_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSeparatorMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_separator_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSeparatorMenuItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_separator_menu_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkSeparatorToolItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_separator_tool_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSeparatorToolItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_separator_tool_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkSeparatorToolItemGetDraw <-
function(object)
{
  checkPtrType(object, "GtkSeparatorToolItem")

  w <- .RGtkCall("S_gtk_separator_tool_item_get_draw", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSeparatorToolItemSetDraw <-
function(object, draw)
{
  checkPtrType(object, "GtkSeparatorToolItem")
  draw <- as.logical(draw)

  w <- .RGtkCall("S_gtk_separator_tool_item_set_draw", object, draw, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSettingsGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_settings_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSettingsGetDefault <-
function()
{
  

  w <- .RGtkCall("S_gtk_settings_get_default", PACKAGE = "RGtk2")

  return(w)
} 


gtkSettingsGetForScreen <-
function(screen)
{
  checkPtrType(screen, "GdkScreen")

  w <- .RGtkCall("S_gtk_settings_get_for_screen", screen, PACKAGE = "RGtk2")

  return(w)
} 


gtkSettingsInstallProperty <-
function(pspec)
{
  pspec <- as.GParamSpec(pspec)

  w <- .RGtkCall("S_gtk_settings_install_property", pspec, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcPropertyParseColor <-
function(pspec, gstring)
{
  pspec <- as.GParamSpec(pspec)
  gstring <- as.GString(gstring)

  w <- .RGtkCall("S_gtk_rc_property_parse_color", pspec, gstring, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcPropertyParseEnum <-
function(pspec, gstring)
{
  pspec <- as.GParamSpec(pspec)
  gstring <- as.GString(gstring)

  w <- .RGtkCall("S_gtk_rc_property_parse_enum", pspec, gstring, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcPropertyParseFlags <-
function(pspec, gstring)
{
  pspec <- as.GParamSpec(pspec)
  gstring <- as.GString(gstring)

  w <- .RGtkCall("S_gtk_rc_property_parse_flags", pspec, gstring, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcPropertyParseRequisition <-
function(pspec, gstring)
{
  pspec <- as.GParamSpec(pspec)
  gstring <- as.GString(gstring)

  w <- .RGtkCall("S_gtk_rc_property_parse_requisition", pspec, gstring, PACKAGE = "RGtk2")

  return(w)
} 


gtkRcPropertyParseBorder <-
function(pspec, gstring)
{
  pspec <- as.GParamSpec(pspec)
  gstring <- as.GString(gstring)

  w <- .RGtkCall("S_gtk_rc_property_parse_border", pspec, gstring, PACKAGE = "RGtk2")

  return(w)
} 


gtkSettingsSetPropertyValue <-
function(object, name, svalue)
{
  checkPtrType(object, "GtkSettings")
  name <- as.character(name)
  svalue <- as.GtkSettingsValue(svalue)

  w <- .RGtkCall("S_gtk_settings_set_property_value", object, name, svalue, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSettingsSetStringProperty <-
function(object, name, v.string, origin)
{
  checkPtrType(object, "GtkSettings")
  name <- as.character(name)
  v.string <- as.character(v.string)
  origin <- as.character(origin)

  w <- .RGtkCall("S_gtk_settings_set_string_property", object, name, v.string, origin, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSettingsSetLongProperty <-
function(object, name, v.long, origin)
{
  checkPtrType(object, "GtkSettings")
  name <- as.character(name)
  v.long <- as.numeric(v.long)
  origin <- as.character(origin)

  w <- .RGtkCall("S_gtk_settings_set_long_property", object, name, v.long, origin, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSettingsSetDoubleProperty <-
function(object, name, v.double, origin)
{
  checkPtrType(object, "GtkSettings")
  name <- as.character(name)
  v.double <- as.numeric(v.double)
  origin <- as.character(origin)

  w <- .RGtkCall("S_gtk_settings_set_double_property", object, name, v.double, origin, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSizeGroupGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_size_group_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSizeGroupNew <-
function(mode = NULL)
{
  

  w <- .RGtkCall("S_gtk_size_group_new", mode, PACKAGE = "RGtk2")

  return(w)
} 


gtkSizeGroupSetMode <-
function(object, mode)
{
  checkPtrType(object, "GtkSizeGroup")
  

  w <- .RGtkCall("S_gtk_size_group_set_mode", object, mode, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSizeGroupGetMode <-
function(object)
{
  checkPtrType(object, "GtkSizeGroup")

  w <- .RGtkCall("S_gtk_size_group_get_mode", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSizeGroupSetIgnoreHidden <-
function(object, ignore.hidden)
{
  checkPtrType(object, "GtkSizeGroup")
  ignore.hidden <- as.logical(ignore.hidden)

  w <- .RGtkCall("S_gtk_size_group_set_ignore_hidden", object, ignore.hidden, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSizeGroupGetIgnoreHidden <-
function(object)
{
  checkPtrType(object, "GtkSizeGroup")

  w <- .RGtkCall("S_gtk_size_group_get_ignore_hidden", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSizeGroupAddWidget <-
function(object, widget)
{
  checkPtrType(object, "GtkSizeGroup")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_size_group_add_widget", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSizeGroupRemoveWidget <-
function(object, widget)
{
  checkPtrType(object, "GtkSizeGroup")
  checkPtrType(widget, "GtkWidget")

  w <- .RGtkCall("S_gtk_size_group_remove_widget", object, widget, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSocketGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_socket_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSocketNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_socket_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkSocketAddId <-
function(object, window.id)
{
  checkPtrType(object, "GtkSocket")
  window.id <- as.GdkNativeWindow(window.id)

  w <- .RGtkCall("S_gtk_socket_add_id", object, window.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSocketGetId <-
function(object)
{
  checkPtrType(object, "GtkSocket")

  w <- .RGtkCall("S_gtk_socket_get_id", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSocketSteal <-
function(object, wid)
{
  checkPtrType(object, "GtkSocket")
  wid <- as.GdkNativeWindow(wid)

  w <- .RGtkCall("S_gtk_socket_steal", object, wid, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_spin_button_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonConfigure <-
function(object, adjustment = NULL, climb.rate, digits)
{
  checkPtrType(object, "GtkSpinButton")
  if (!is.null( adjustment )) checkPtrType(adjustment, "GtkAdjustment")
  climb.rate <- as.numeric(climb.rate)
  digits <- as.numeric(digits)

  w <- .RGtkCall("S_gtk_spin_button_configure", object, adjustment, climb.rate, digits, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonNew <-
function(adjustment = NULL, climb.rate = NULL, digits = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_spin_button_new", adjustment, climb.rate, digits, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkSpinButtonNewWithRange <-
function(min, max, step, show = TRUE)
{
  min <- as.numeric(min)
  max <- as.numeric(max)
  step <- as.numeric(step)

  w <- .RGtkCall("S_gtk_spin_button_new_with_range", min, max, step, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkSpinButtonSetAdjustment <-
function(object, adjustment)
{
  checkPtrType(object, "GtkSpinButton")
  checkPtrType(adjustment, "GtkAdjustment")

  w <- .RGtkCall("S_gtk_spin_button_set_adjustment", object, adjustment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetAdjustment <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_adjustment", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSetDigits <-
function(object, digits)
{
  checkPtrType(object, "GtkSpinButton")
  digits <- as.numeric(digits)

  w <- .RGtkCall("S_gtk_spin_button_set_digits", object, digits, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetDigits <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_digits", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSetIncrements <-
function(object, step, page)
{
  checkPtrType(object, "GtkSpinButton")
  step <- as.numeric(step)
  page <- as.numeric(page)

  w <- .RGtkCall("S_gtk_spin_button_set_increments", object, step, page, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetIncrements <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_increments", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonSetRange <-
function(object, min, max)
{
  checkPtrType(object, "GtkSpinButton")
  min <- as.numeric(min)
  max <- as.numeric(max)

  w <- .RGtkCall("S_gtk_spin_button_set_range", object, min, max, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetRange <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_range", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetValue <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_value", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonGetValueAsInt <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_value_as_int", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSetValue <-
function(object, value)
{
  checkPtrType(object, "GtkSpinButton")
  value <- as.numeric(value)

  w <- .RGtkCall("S_gtk_spin_button_set_value", object, value, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonSetUpdatePolicy <-
function(object, policy)
{
  checkPtrType(object, "GtkSpinButton")
  

  w <- .RGtkCall("S_gtk_spin_button_set_update_policy", object, policy, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetUpdatePolicy <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_update_policy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSetNumeric <-
function(object, numeric)
{
  checkPtrType(object, "GtkSpinButton")
  numeric <- as.logical(numeric)

  w <- .RGtkCall("S_gtk_spin_button_set_numeric", object, numeric, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetNumeric <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_numeric", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSpin <-
function(object, direction, increment)
{
  checkPtrType(object, "GtkSpinButton")
  
  increment <- as.numeric(increment)

  w <- .RGtkCall("S_gtk_spin_button_spin", object, direction, increment, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonSetWrap <-
function(object, wrap)
{
  checkPtrType(object, "GtkSpinButton")
  wrap <- as.logical(wrap)

  w <- .RGtkCall("S_gtk_spin_button_set_wrap", object, wrap, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetWrap <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_wrap", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonSetSnapToTicks <-
function(object, snap.to.ticks)
{
  checkPtrType(object, "GtkSpinButton")
  snap.to.ticks <- as.logical(snap.to.ticks)

  w <- .RGtkCall("S_gtk_spin_button_set_snap_to_ticks", object, snap.to.ticks, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkSpinButtonGetSnapToTicks <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_get_snap_to_ticks", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkSpinButtonUpdate <-
function(object)
{
  checkPtrType(object, "GtkSpinButton")

  w <- .RGtkCall("S_gtk_spin_button_update", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStatusbarGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_statusbar_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkStatusbarNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_statusbar_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkStatusbarGetContextId <-
function(object, context.description)
{
  checkPtrType(object, "GtkStatusbar")
  context.description <- as.character(context.description)

  w <- .RGtkCall("S_gtk_statusbar_get_context_id", object, context.description, PACKAGE = "RGtk2")

  return(w)
} 


gtkStatusbarPush <-
function(object, context.id, text)
{
  checkPtrType(object, "GtkStatusbar")
  context.id <- as.numeric(context.id)
  text <- as.character(text)

  w <- .RGtkCall("S_gtk_statusbar_push", object, context.id, text, PACKAGE = "RGtk2")

  return(w)
} 


gtkStatusbarPop <-
function(object, context.id)
{
  checkPtrType(object, "GtkStatusbar")
  context.id <- as.numeric(context.id)

  w <- .RGtkCall("S_gtk_statusbar_pop", object, context.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStatusbarRemove <-
function(object, context.id, message.id)
{
  checkPtrType(object, "GtkStatusbar")
  context.id <- as.numeric(context.id)
  message.id <- as.numeric(message.id)

  w <- .RGtkCall("S_gtk_statusbar_remove", object, context.id, message.id, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStatusbarSetHasResizeGrip <-
function(object, setting)
{
  checkPtrType(object, "GtkStatusbar")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_statusbar_set_has_resize_grip", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStatusbarGetHasResizeGrip <-
function(object)
{
  checkPtrType(object, "GtkStatusbar")

  w <- .RGtkCall("S_gtk_statusbar_get_has_resize_grip", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkStockAdd <-
function(items)
{
  items <- lapply(items, function(x) { x <- as.GtkStockItem(x); x })

  w <- .RGtkCall("S_gtk_stock_add", items, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStockAddStatic <-
function(items)
{
  items <- lapply(items, function(x) { x <- as.GtkStockItem(x); x })

  w <- .RGtkCall("S_gtk_stock_add_static", items, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStockLookup <-
function(stock.id)
{
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_stock_lookup", stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkStockListIds <-
function()
{
  

  w <- .RGtkCall("S_gtk_stock_list_ids", PACKAGE = "RGtk2")

  return(w)
} 


gtkStockItemCopy <-
function(object)
{
  object <- as.GtkStockItem(object)

  w <- .RGtkCall("S_gtk_stock_item_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkStockSetTranslateFunc <-
function(domain, func, data)
{
  domain <- as.character(domain)
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_stock_set_translate_func", domain, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStyleGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_style_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_style_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleCopy <-
function(object)
{
  checkPtrType(object, "GtkStyle")

  w <- .RGtkCall("S_gtk_style_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleAttach <-
function(object, window)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gtk_style_attach", object, window, PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleDetach <-
function(object)
{
  checkPtrType(object, "GtkStyle")

  w <- .RGtkCall("S_gtk_style_detach", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStyleGetFont <-
function(object)
{
  checkPtrType(object, "GtkStyle")

  w <- .RGtkCall("S_gtk_style_get_font", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleSetFont <-
function(object, font)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(font, "GdkFont")

  w <- .RGtkCall("S_gtk_style_set_font", object, font, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStyleSetBackground <-
function(object, window, state.type)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  

  w <- .RGtkCall("S_gtk_style_set_background", object, window, state.type, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStyleApplyDefaultBackground <-
function(object, window, set.bg, state.type, area = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  set.bg <- as.logical(set.bg)
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_style_apply_default_background", object, window, set.bg, state.type, area, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkStyleLookupIconSet <-
function(object, stock.id)
{
  checkPtrType(object, "GtkStyle")
  stock.id <- as.character(stock.id)

  w <- .RGtkCall("S_gtk_style_lookup_icon_set", object, stock.id, PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleRenderIcon <-
function(object, source, direction, state, size, widget = NULL, detail = NULL)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(source, "GtkIconSource")
  
  
  
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)

  w <- .RGtkCall("S_gtk_style_render_icon", object, source, direction, state, size, widget, detail, PACKAGE = "RGtk2")

  return(w)
} 


gtkDrawHline <-
function(object, window, state.type, x1, x2, y)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintHline", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  x1 <- as.integer(x1)
  x2 <- as.integer(x2)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_draw_hline", object, window, state.type, x1, x2, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawVline <-
function(object, window, state.type, y1, y2, x)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintVline", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  y1 <- as.integer(y1)
  y2 <- as.integer(y2)
  x <- as.integer(x)

  w <- .RGtkCall("S_gtk_draw_vline", object, window, state.type, y1, y2, x, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawShadow <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintShadow", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_shadow", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawPolygon <-
function(object, window, state.type, shadow.type, points, fill)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintPolygon", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  points <- lapply(points, function(x) { x <- as.GdkPoint(x); x })
  fill <- as.logical(fill)

  w <- .RGtkCall("S_gtk_draw_polygon", object, window, state.type, shadow.type, points, fill, PACKAGE = "RGtk2")

  return(w)
} 


gtkDrawArrow <-
function(object, window, state.type, shadow.type, arrow.type, fill, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintArrow", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  
  fill <- as.logical(fill)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_arrow", object, window, state.type, shadow.type, arrow.type, fill, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawDiamond <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintDiamond", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_diamond", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawBox <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintBox", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_box", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawFlatBox <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintFlatBox", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_flat_box", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawCheck <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintCheck", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_check", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawOption <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintOption", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_option", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawTab <-
function(object, window, state.type, shadow.type, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintTab", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_tab", object, window, state.type, shadow.type, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawShadowGap <-
function(object, window, state.type, shadow.type, x, y, width, height, gap.side, gap.x, gap.width)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintShadowGap", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  gap.x <- as.integer(gap.x)
  gap.width <- as.integer(gap.width)

  w <- .RGtkCall("S_gtk_draw_shadow_gap", object, window, state.type, shadow.type, x, y, width, height, gap.side, gap.x, gap.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawBoxGap <-
function(object, window, state.type, shadow.type, x, y, width, height, gap.side, gap.x, gap.width)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintBoxGap", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  gap.x <- as.integer(gap.x)
  gap.width <- as.integer(gap.width)

  w <- .RGtkCall("S_gtk_draw_box_gap", object, window, state.type, shadow.type, x, y, width, height, gap.side, gap.x, gap.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawExtension <-
function(object, window, state.type, shadow.type, x, y, width, height, gap.side)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintExtension", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_draw_extension", object, window, state.type, shadow.type, x, y, width, height, gap.side, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawFocus <-
function(object, window, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintFocus", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_focus", object, window, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawSlider <-
function(object, window, state.type, shadow.type, x, y, width, height, orientation)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_draw_slider", object, window, state.type, shadow.type, x, y, width, height, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawHandle <-
function(object, window, state.type, shadow.type, x, y, width, height, orientation)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintHandle", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_draw_handle", object, window, state.type, shadow.type, x, y, width, height, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawExpander <-
function(object, window, state.type, x, y, is.open)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintExpander", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  x <- as.integer(x)
  y <- as.integer(y)
  is.open <- as.logical(is.open)

  w <- .RGtkCall("S_gtk_draw_expander", object, window, state.type, x, y, is.open, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawLayout <-
function(object, window, state.type, use.text, x, y, layout)
{
  if(getOption("depwarn"))
    .Deprecated("nothing", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  use.text <- as.logical(use.text)
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(layout, "PangoLayout")

  w <- .RGtkCall("S_gtk_draw_layout", object, window, state.type, use.text, x, y, layout, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawResizeGrip <-
function(object, window, state.type, edge, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintResizeGrip", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_draw_resize_grip", object, window, state.type, edge, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintHline <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, x1, x2, y)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x1 <- as.integer(x1)
  x2 <- as.integer(x2)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_paint_hline", object, window, state.type, area, widget, detail, x1, x2, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintVline <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, y1, y2, x)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  y1 <- as.integer(y1)
  y2 <- as.integer(y2)
  x <- as.integer(x)

  w <- .RGtkCall("S_gtk_paint_vline", object, window, state.type, area, widget, detail, y1, y2, x, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintShadow <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_shadow", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintPolygon <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, points, fill)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  points <- lapply(points, function(x) { x <- as.GdkPoint(x); x })
  fill <- as.logical(fill)

  w <- .RGtkCall("S_gtk_paint_polygon", object, window, state.type, shadow.type, area, widget, detail, points, fill, PACKAGE = "RGtk2")

  return(w)
} 


gtkPaintArrow <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, arrow.type, fill, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  
  fill <- as.logical(fill)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_arrow", object, window, state.type, shadow.type, area, widget, detail, arrow.type, fill, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintDiamond <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_diamond", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintBox <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_box", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintFlatBox <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_flat_box", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintCheck <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_check", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintOption <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_option", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintTab <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_tab", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintShadowGap <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height, gap.side, gap.x, gap.width)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  gap.x <- as.integer(gap.x)
  gap.width <- as.integer(gap.width)

  w <- .RGtkCall("S_gtk_paint_shadow_gap", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, gap.side, gap.x, gap.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintBoxGap <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height, gap.side, gap.x, gap.width)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  
  gap.x <- as.integer(gap.x)
  gap.width <- as.integer(gap.width)

  w <- .RGtkCall("S_gtk_paint_box_gap", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, gap.side, gap.x, gap.width, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintExtension <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height, gap.side)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_paint_extension", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, gap.side, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintFocus <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_focus", object, window, state.type, area, widget, detail, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintSlider <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height, orientation)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_paint_slider", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintHandle <-
function(object, window, state.type, shadow.type, area = NULL, widget = NULL, detail = NULL, x, y, width, height, orientation)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)
  

  w <- .RGtkCall("S_gtk_paint_handle", object, window, state.type, shadow.type, area, widget, detail, x, y, width, height, orientation, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintExpander <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, x, y, expander.style)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  

  w <- .RGtkCall("S_gtk_paint_expander", object, window, state.type, area, widget, detail, x, y, expander.style, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintLayout <-
function(object, window, state.type, use.text, area = NULL, widget = NULL, detail = NULL, x, y, layout)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  use.text <- as.logical(use.text)
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  checkPtrType(layout, "PangoLayout")

  w <- .RGtkCall("S_gtk_paint_layout", object, window, state.type, use.text, area, widget, detail, x, y, layout, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintResizeGrip <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, edge, x, y, width, height)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_paint_resize_grip", object, window, state.type, area, widget, detail, edge, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkBorderGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_border_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkBorderCopy <-
function(object)
{
  checkPtrType(object, "GtkBorder")

  w <- .RGtkCall("S_gtk_border_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkStyleApplyDefaultPixmap <-
function(object, window, set.bg, area, x, y, width, height)
{
  if(getOption("depwarn"))
    .Deprecated("gtkStyleApplyDefaultBackground", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  set.bg <- as.logical(set.bg)
  area <- as.GdkRectangle(area)
  x <- as.integer(x)
  y <- as.integer(y)
  width <- as.integer(width)
  height <- as.integer(height)

  w <- .RGtkCall("S_gtk_style_apply_default_pixmap", object, window, set.bg, area, x, y, width, height, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawString <-
function(object, window, state.type, x, y, string)
{
  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  x <- as.integer(x)
  y <- as.integer(y)
  string <- as.character(string)

  w <- .RGtkCall("S_gtk_draw_string", object, window, state.type, x, y, string, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkPaintString <-
function(object, window, state.type, area = NULL, widget = NULL, detail = NULL, x, y, string)
{
  if(getOption("depwarn"))
    .Deprecated("gtkPaintLayout", "RGtk2")

  checkPtrType(object, "GtkStyle")
  checkPtrType(window, "GdkWindow")
  
  if (!is.null( area )) area <- as.GdkRectangle(area)
  if (!is.null( widget )) checkPtrType(widget, "GtkWidget")
  if (!is.null( detail )) detail <- as.character(detail)
  x <- as.integer(x)
  y <- as.integer(y)
  string <- as.character(string)

  w <- .RGtkCall("S_gtk_paint_string", object, window, state.type, area, widget, detail, x, y, string, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkDrawInsertionCursor <-
function(widget, drawable, area = NULL, location, is.primary, direction, draw.arrow)
{
  checkPtrType(widget, "GtkWidget")
  checkPtrType(drawable, "GdkDrawable")
  if (!is.null( area )) area <- as.GdkRectangle(area)
  location <- as.GdkRectangle(location)
  is.primary <- as.logical(is.primary)
  
  draw.arrow <- as.logical(draw.arrow)

  w <- .RGtkCall("S_gtk_draw_insertion_cursor", widget, drawable, area, location, is.primary, direction, draw.arrow, PACKAGE = "RGtk2")

  return(w)
} 


gtkTableGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_table_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTableNew <-
function(rows = NULL, columns = NULL, homogeneous = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_table_new", rows, columns, homogeneous, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkTableResize <-
function(object, rows, columns)
{
  checkPtrType(object, "GtkTable")
  rows <- as.numeric(rows)
  columns <- as.numeric(columns)

  w <- .RGtkCall("S_gtk_table_resize", object, rows, columns, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableAttach <-
function(object, child, left.attach, right.attach, top.attach, bottom.attach, xoptions = 5, yoptions = 5, xpadding = 0, ypadding = 0)
{
  checkPtrType(object, "GtkTable")
  checkPtrType(child, "GtkWidget")
  left.attach <- as.numeric(left.attach)
  right.attach <- as.numeric(right.attach)
  top.attach <- as.numeric(top.attach)
  bottom.attach <- as.numeric(bottom.attach)
  
  
  xpadding <- as.numeric(xpadding)
  ypadding <- as.numeric(ypadding)

  w <- .RGtkCall("S_gtk_table_attach", object, child, left.attach, right.attach, top.attach, bottom.attach, xoptions, yoptions, xpadding, ypadding, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableAttachDefaults <-
function(object, widget, left.attach, right.attach, top.attach, bottom.attach)
{
  checkPtrType(object, "GtkTable")
  checkPtrType(widget, "GtkWidget")
  left.attach <- as.numeric(left.attach)
  right.attach <- as.numeric(right.attach)
  top.attach <- as.numeric(top.attach)
  bottom.attach <- as.numeric(bottom.attach)

  w <- .RGtkCall("S_gtk_table_attach_defaults", object, widget, left.attach, right.attach, top.attach, bottom.attach, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableSetRowSpacing <-
function(object, row, spacing)
{
  checkPtrType(object, "GtkTable")
  row <- as.numeric(row)
  spacing <- as.numeric(spacing)

  w <- .RGtkCall("S_gtk_table_set_row_spacing", object, row, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableGetRowSpacing <-
function(object, row)
{
  checkPtrType(object, "GtkTable")
  row <- as.numeric(row)

  w <- .RGtkCall("S_gtk_table_get_row_spacing", object, row, PACKAGE = "RGtk2")

  return(w)
} 


gtkTableSetColSpacing <-
function(object, column, spacing)
{
  checkPtrType(object, "GtkTable")
  column <- as.numeric(column)
  spacing <- as.numeric(spacing)

  w <- .RGtkCall("S_gtk_table_set_col_spacing", object, column, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableGetColSpacing <-
function(object, column)
{
  checkPtrType(object, "GtkTable")
  column <- as.numeric(column)

  w <- .RGtkCall("S_gtk_table_get_col_spacing", object, column, PACKAGE = "RGtk2")

  return(w)
} 


gtkTableSetRowSpacings <-
function(object, spacing)
{
  checkPtrType(object, "GtkTable")
  spacing <- as.numeric(spacing)

  w <- .RGtkCall("S_gtk_table_set_row_spacings", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableGetDefaultRowSpacing <-
function(object)
{
  checkPtrType(object, "GtkTable")

  w <- .RGtkCall("S_gtk_table_get_default_row_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTableSetColSpacings <-
function(object, spacing)
{
  checkPtrType(object, "GtkTable")
  spacing <- as.numeric(spacing)

  w <- .RGtkCall("S_gtk_table_set_col_spacings", object, spacing, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableGetDefaultColSpacing <-
function(object)
{
  checkPtrType(object, "GtkTable")

  w <- .RGtkCall("S_gtk_table_get_default_col_spacing", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTableSetHomogeneous <-
function(object, homogeneous)
{
  checkPtrType(object, "GtkTable")
  homogeneous <- as.logical(homogeneous)

  w <- .RGtkCall("S_gtk_table_set_homogeneous", object, homogeneous, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTableGetHomogeneous <-
function(object)
{
  checkPtrType(object, "GtkTable")

  w <- .RGtkCall("S_gtk_table_get_homogeneous", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTearoffMenuItemGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_tearoff_menu_item_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTearoffMenuItemNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_tearoff_menu_item_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkTextBufferGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_buffer_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferNew <-
function(table = NULL)
{
  

  w <- .RGtkCall("S_gtk_text_buffer_new", table, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetLineCount <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_line_count", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetCharCount <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_char_count", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetTagTable <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_tag_table", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferSetText <-
function(object, text, len = -1)
{
  checkPtrType(object, "GtkTextBuffer")
  text <- as.character(text)
  len <- as.integer(len)

  w <- .RGtkCall("S_gtk_text_buffer_set_text", object, text, len, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferInsert <-
function(object, iter, text, len = -1)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  text <- as.character(text)
  len <- as.integer(len)

  w <- .RGtkCall("S_gtk_text_buffer_insert", object, iter, text, len, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferInsertAtCursor <-
function(object, text, len = -1)
{
  checkPtrType(object, "GtkTextBuffer")
  text <- as.character(text)
  len <- as.integer(len)

  w <- .RGtkCall("S_gtk_text_buffer_insert_at_cursor", object, text, len, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferInsertRange <-
function(object, iter, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_insert_range", object, iter, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferInsertRangeInteractive <-
function(object, iter, start, end, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_insert_range_interactive", object, iter, start, end, default.editable, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferDelete <-
function(object, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_delete", object, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferDeleteInteractive <-
function(object, start.iter, end.iter, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(start.iter, "GtkTextIter")
  checkPtrType(end.iter, "GtkTextIter")
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_delete_interactive", object, start.iter, end.iter, default.editable, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetText <-
function(object, start, end, include.hidden.chars = TRUE)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")
  include.hidden.chars <- as.logical(include.hidden.chars)

  w <- .RGtkCall("S_gtk_text_buffer_get_text", object, start, end, include.hidden.chars, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetSlice <-
function(object, start, end, include.hidden.chars = TRUE)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")
  include.hidden.chars <- as.logical(include.hidden.chars)

  w <- .RGtkCall("S_gtk_text_buffer_get_slice", object, start, end, include.hidden.chars, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferInsertPixbuf <-
function(object, iter, pixbuf)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  checkPtrType(pixbuf, "GdkPixbuf")

  w <- .RGtkCall("S_gtk_text_buffer_insert_pixbuf", object, iter, pixbuf, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferInsertChildAnchor <-
function(object, iter, anchor)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  checkPtrType(anchor, "GtkTextChildAnchor")

  w <- .RGtkCall("S_gtk_text_buffer_insert_child_anchor", object, iter, anchor, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferCreateChildAnchor <-
function(object, iter)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_create_child_anchor", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferCreateMark <-
function(object, mark.name = NULL, where, left.gravity = FALSE)
{
  checkPtrType(object, "GtkTextBuffer")
  if (!is.null( mark.name )) mark.name <- as.character(mark.name)
  checkPtrType(where, "GtkTextIter")
  left.gravity <- as.logical(left.gravity)

  w <- .RGtkCall("S_gtk_text_buffer_create_mark", object, mark.name, where, left.gravity, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferMoveMark <-
function(object, mark, where)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(mark, "GtkTextMark")
  checkPtrType(where, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_move_mark", object, mark, where, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferDeleteMark <-
function(object, mark)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(mark, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_buffer_delete_mark", object, mark, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferGetMark <-
function(object, name)
{
  checkPtrType(object, "GtkTextBuffer")
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_text_buffer_get_mark", object, name, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferMoveMarkByName <-
function(object, name, where)
{
  checkPtrType(object, "GtkTextBuffer")
  name <- as.character(name)
  checkPtrType(where, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_move_mark_by_name", object, name, where, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferDeleteMarkByName <-
function(object, name)
{
  checkPtrType(object, "GtkTextBuffer")
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_text_buffer_delete_mark_by_name", object, name, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferGetInsert <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_insert", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetSelectionBound <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_selection_bound", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferPlaceCursor <-
function(object, where)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(where, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_place_cursor", object, where, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferSelectRange <-
function(object, ins, bound)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(ins, "GtkTextIter")
  checkPtrType(bound, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_select_range", object, ins, bound, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferApplyTag <-
function(object, tag, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(tag, "GtkTextTag")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_apply_tag", object, tag, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferRemoveTag <-
function(object, tag, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(tag, "GtkTextTag")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_remove_tag", object, tag, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferApplyTagByName <-
function(object, name, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  name <- as.character(name)
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_apply_tag_by_name", object, name, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferRemoveTagByName <-
function(object, name, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  name <- as.character(name)
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_remove_tag_by_name", object, name, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferRemoveAllTags <-
function(object, start, end)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_buffer_remove_all_tags", object, start, end, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferGetIterAtLineOffset <-
function(object, line.number, char.offset)
{
  checkPtrType(object, "GtkTextBuffer")
  line.number <- as.integer(line.number)
  char.offset <- as.integer(char.offset)

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_line_offset", object, line.number, char.offset, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetIterAtLineIndex <-
function(object, line.number, byte.index)
{
  checkPtrType(object, "GtkTextBuffer")
  line.number <- as.integer(line.number)
  byte.index <- as.integer(byte.index)

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_line_index", object, line.number, byte.index, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetIterAtOffset <-
function(object, char.offset)
{
  checkPtrType(object, "GtkTextBuffer")
  char.offset <- as.integer(char.offset)

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_offset", object, char.offset, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetIterAtLine <-
function(object, line.number)
{
  checkPtrType(object, "GtkTextBuffer")
  line.number <- as.integer(line.number)

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_line", object, line.number, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetStartIter <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_start_iter", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetEndIter <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_end_iter", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetBounds <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_bounds", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferGetIterAtMark <-
function(object, mark)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(mark, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_mark", object, mark, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetIterAtChildAnchor <-
function(object, anchor)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(anchor, "GtkTextChildAnchor")

  w <- .RGtkCall("S_gtk_text_buffer_get_iter_at_child_anchor", object, anchor, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferGetModified <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_modified", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferSetModified <-
function(object, setting)
{
  checkPtrType(object, "GtkTextBuffer")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_text_buffer_set_modified", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferAddSelectionClipboard <-
function(object, clipboard)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(clipboard, "GtkClipboard")

  w <- .RGtkCall("S_gtk_text_buffer_add_selection_clipboard", object, clipboard, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferRemoveSelectionClipboard <-
function(object, clipboard)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(clipboard, "GtkClipboard")

  w <- .RGtkCall("S_gtk_text_buffer_remove_selection_clipboard", object, clipboard, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferCutClipboard <-
function(object, clipboard, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(clipboard, "GtkClipboard")
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_cut_clipboard", object, clipboard, default.editable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferCopyClipboard <-
function(object, clipboard)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(clipboard, "GtkClipboard")

  w <- .RGtkCall("S_gtk_text_buffer_copy_clipboard", object, clipboard, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferPasteClipboard <-
function(object, clipboard, override.location = NULL, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(clipboard, "GtkClipboard")
  if (!is.null( override.location )) checkPtrType(override.location, "GtkTextIter")
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_paste_clipboard", object, clipboard, override.location, default.editable, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferGetSelectionBounds <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_get_selection_bounds", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferDeleteSelection <-
function(object, interactive, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  interactive <- as.logical(interactive)
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_delete_selection", object, interactive, default.editable, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferBeginUserAction <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_begin_user_action", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextBufferEndUserAction <-
function(object)
{
  checkPtrType(object, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_buffer_end_user_action", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextChildAnchorGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_child_anchor_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextChildAnchorNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_child_anchor_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextChildAnchorGetWidgets <-
function(object)
{
  checkPtrType(object, "GtkTextChildAnchor")

  w <- .RGtkCall("S_gtk_text_child_anchor_get_widgets", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextChildAnchorGetDeleted <-
function(object)
{
  checkPtrType(object, "GtkTextChildAnchor")

  w <- .RGtkCall("S_gtk_text_child_anchor_get_deleted", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextBufferBackspace <-
function(object, iter, interactive, default.editable)
{
  checkPtrType(object, "GtkTextBuffer")
  checkPtrType(iter, "GtkTextIter")
  interactive <- as.logical(interactive)
  default.editable <- as.logical(default.editable)

  w <- .RGtkCall("S_gtk_text_buffer_backspace", object, iter, interactive, default.editable, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetBuffer <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_buffer", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterCopy <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_iter_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetOffset <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_offset", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetLineOffset <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_line_offset", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetLineIndex <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_line_index", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetVisibleLineOffset <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_visible_line_offset", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetVisibleLineIndex <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_visible_line_index", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetChar <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_char", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetSlice <-
function(object, end)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_slice", object, end, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetText <-
function(object, end)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_text", object, end, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetVisibleSlice <-
function(object, end)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_visible_slice", object, end, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetVisibleText <-
function(object, end)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_visible_text", object, end, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetPixbuf <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_pixbuf", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetMarks <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_marks", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetChildAnchor <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_child_anchor", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetToggledTags <-
function(object, toggled.on)
{
  checkPtrType(object, "GtkTextIter")
  toggled.on <- as.logical(toggled.on)

  w <- .RGtkCall("S_gtk_text_iter_get_toggled_tags", object, toggled.on, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBeginsTag <-
function(object, tag = NULL)
{
  checkPtrType(object, "GtkTextIter")
  if (!is.null( tag )) checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_begins_tag", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEndsTag <-
function(object, tag = NULL)
{
  checkPtrType(object, "GtkTextIter")
  if (!is.null( tag )) checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_ends_tag", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterTogglesTag <-
function(object, tag = NULL)
{
  checkPtrType(object, "GtkTextIter")
  if (!is.null( tag )) checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_toggles_tag", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterHasTag <-
function(object, tag)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_has_tag", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetTags <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_tags", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEditable <-
function(object, default.setting)
{
  checkPtrType(object, "GtkTextIter")
  default.setting <- as.logical(default.setting)

  w <- .RGtkCall("S_gtk_text_iter_editable", object, default.setting, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterCanInsert <-
function(object, default.editability)
{
  checkPtrType(object, "GtkTextIter")
  default.editability <- as.logical(default.editability)

  w <- .RGtkCall("S_gtk_text_iter_can_insert", object, default.editability, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterStartsWord <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_starts_word", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEndsWord <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_ends_word", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterInsideWord <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_inside_word", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterStartsSentence <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_starts_sentence", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEndsSentence <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_ends_sentence", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterInsideSentence <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_inside_sentence", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterStartsLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_starts_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEndsLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_ends_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterIsCursorPosition <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_is_cursor_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetCharsInLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_chars_in_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetBytesInLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_bytes_in_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetAttributes <-
function(object, values)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(values, "GtkTextAttributes")

  w <- .RGtkCall("S_gtk_text_iter_get_attributes", object, values, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterGetLanguage <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_get_language", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterIsEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_is_end", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterIsStart <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_is_start", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardChar <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_char", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardChar <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_char", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardChars <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_chars", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardChars <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_chars", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardLines <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_lines", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardLines <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_lines", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardWordEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_word_end", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardWordStart <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_word_start", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardWordEnds <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_word_ends", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardWordStarts <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_word_starts", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleLine <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_line", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleLines <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_lines", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleLines <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_lines", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleWordEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_word_end", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleWordStart <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_word_start", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleWordEnds <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_word_ends", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleWordStarts <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_word_starts", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardSentenceEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_sentence_end", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardSentenceStart <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_sentence_start", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardSentenceEnds <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_sentence_ends", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardSentenceStarts <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_sentence_starts", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardCursorPosition <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_cursor_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardCursorPosition <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_cursor_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardCursorPositions <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_cursor_positions", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardCursorPositions <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_cursor_positions", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleCursorPosition <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_cursor_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleCursorPosition <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_cursor_position", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardVisibleCursorPositions <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_forward_visible_cursor_positions", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardVisibleCursorPositions <-
function(object, count)
{
  checkPtrType(object, "GtkTextIter")
  count <- as.integer(count)

  w <- .RGtkCall("S_gtk_text_iter_backward_visible_cursor_positions", object, count, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterSetOffset <-
function(object, char.offset)
{
  checkPtrType(object, "GtkTextIter")
  char.offset <- as.integer(char.offset)

  w <- .RGtkCall("S_gtk_text_iter_set_offset", object, char.offset, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterSetLine <-
function(object, line.number)
{
  checkPtrType(object, "GtkTextIter")
  line.number <- as.integer(line.number)

  w <- .RGtkCall("S_gtk_text_iter_set_line", object, line.number, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterSetLineOffset <-
function(object, char.on.line)
{
  checkPtrType(object, "GtkTextIter")
  char.on.line <- as.integer(char.on.line)

  w <- .RGtkCall("S_gtk_text_iter_set_line_offset", object, char.on.line, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterSetLineIndex <-
function(object, byte.on.line)
{
  checkPtrType(object, "GtkTextIter")
  byte.on.line <- as.integer(byte.on.line)

  w <- .RGtkCall("S_gtk_text_iter_set_line_index", object, byte.on.line, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterForwardToEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_to_end", object, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterForwardToLineEnd <-
function(object)
{
  checkPtrType(object, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_to_line_end", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterSetVisibleLineOffset <-
function(object, char.on.line)
{
  checkPtrType(object, "GtkTextIter")
  char.on.line <- as.integer(char.on.line)

  w <- .RGtkCall("S_gtk_text_iter_set_visible_line_offset", object, char.on.line, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterSetVisibleLineIndex <-
function(object, byte.on.line)
{
  checkPtrType(object, "GtkTextIter")
  byte.on.line <- as.integer(byte.on.line)

  w <- .RGtkCall("S_gtk_text_iter_set_visible_line_index", object, byte.on.line, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextIterForwardToTagToggle <-
function(object, tag = NULL)
{
  checkPtrType(object, "GtkTextIter")
  if (!is.null( tag )) checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_forward_to_tag_toggle", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardToTagToggle <-
function(object, tag = NULL)
{
  checkPtrType(object, "GtkTextIter")
  if (!is.null( tag )) checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_iter_backward_to_tag_toggle", object, tag, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardFindChar <-
function(object, pred, user.data = NULL, limit)
{
  checkPtrType(object, "GtkTextIter")
  pred <- as.function(pred)
  
  checkPtrType(limit, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_find_char", object, pred, user.data, limit, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardFindChar <-
function(object, pred, user.data = NULL, limit)
{
  checkPtrType(object, "GtkTextIter")
  pred <- as.function(pred)
  
  checkPtrType(limit, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_find_char", object, pred, user.data, limit, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterForwardSearch <-
function(object, str, flags, limit = NULL)
{
  checkPtrType(object, "GtkTextIter")
  str <- as.character(str)
  
  if (!is.null( limit )) checkPtrType(limit, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_forward_search", object, str, flags, limit, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterBackwardSearch <-
function(object, str, flags, limit = NULL)
{
  checkPtrType(object, "GtkTextIter")
  str <- as.character(str)
  
  if (!is.null( limit )) checkPtrType(limit, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_backward_search", object, str, flags, limit, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterEqual <-
function(object, rhs)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(rhs, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_equal", object, rhs, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterCompare <-
function(object, rhs)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(rhs, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_compare", object, rhs, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterInRange <-
function(object, start, end)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(start, "GtkTextIter")
  checkPtrType(end, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_in_range", object, start, end, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextIterOrder <-
function(object, second)
{
  checkPtrType(object, "GtkTextIter")
  checkPtrType(second, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_iter_order", object, second, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextMarkGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_mark_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextMarkSetVisible <-
function(object, setting)
{
  checkPtrType(object, "GtkTextMark")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_text_mark_set_visible", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextMarkGetVisible <-
function(object)
{
  checkPtrType(object, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_mark_get_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextMarkGetName <-
function(object)
{
  checkPtrType(object, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_mark_get_name", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextMarkGetDeleted <-
function(object)
{
  checkPtrType(object, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_mark_get_deleted", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextMarkGetBuffer <-
function(object)
{
  checkPtrType(object, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_mark_get_buffer", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextMarkGetLeftGravity <-
function(object)
{
  checkPtrType(object, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_mark_get_left_gravity", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_tag_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagNew <-
function(name = NULL)
{
  

  w <- .RGtkCall("S_gtk_text_tag_new", name, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagGetPriority <-
function(object)
{
  checkPtrType(object, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_tag_get_priority", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagSetPriority <-
function(object, priority)
{
  checkPtrType(object, "GtkTextTag")
  priority <- as.integer(priority)

  w <- .RGtkCall("S_gtk_text_tag_set_priority", object, priority, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextTagEvent <-
function(object, event.object, event, iter)
{
  checkPtrType(object, "GtkTextTag")
  checkPtrType(event.object, "GObject")
  checkPtrType(event, "GdkEvent")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_tag_event", object, event.object, event, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextAttributesNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_attributes_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextAttributesCopy <-
function(object)
{
  checkPtrType(object, "GtkTextAttributes")

  w <- .RGtkCall("S_gtk_text_attributes_copy", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextAttributesCopyValues <-
function(object, dest)
{
  checkPtrType(object, "GtkTextAttributes")
  checkPtrType(dest, "GtkTextAttributes")

  w <- .RGtkCall("S_gtk_text_attributes_copy_values", object, dest, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextAttributesGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_attributes_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagTableGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_tag_table_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagTableNew <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_tag_table_new", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagTableAdd <-
function(object, tag)
{
  checkPtrType(object, "GtkTextTagTable")
  checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_tag_table_add", object, tag, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextTagTableRemove <-
function(object, tag)
{
  checkPtrType(object, "GtkTextTagTable")
  checkPtrType(tag, "GtkTextTag")

  w <- .RGtkCall("S_gtk_text_tag_table_remove", object, tag, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextTagTableLookup <-
function(object, name)
{
  checkPtrType(object, "GtkTextTagTable")
  name <- as.character(name)

  w <- .RGtkCall("S_gtk_text_tag_table_lookup", object, name, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextTagTableForeach <-
function(object, func, data = NULL)
{
  checkPtrType(object, "GtkTextTagTable")
  func <- as.function(func)
  

  w <- .RGtkCall("S_gtk_text_tag_table_foreach", object, func, data, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextTagTableGetSize <-
function(object)
{
  checkPtrType(object, "GtkTextTagTable")

  w <- .RGtkCall("S_gtk_text_tag_table_get_size", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetType <-
function()
{
  

  w <- .RGtkCall("S_gtk_text_view_get_type", PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewNew <-
function(show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_text_view_new", PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkTextViewNewWithBuffer <-
function(buffer = NULL, show = TRUE)
{
  

  w <- .RGtkCall("S_gtk_text_view_new_with_buffer", buffer, PACKAGE = "RGtk2")

  if(show)
    gtkWidgetShowAll(w)

  return(w)
} 


gtkTextViewSetBuffer <-
function(object, buffer)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(buffer, "GtkTextBuffer")

  w <- .RGtkCall("S_gtk_text_view_set_buffer", object, buffer, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetBuffer <-
function(object)
{
  checkPtrType(object, "GtkTextView")

  w <- .RGtkCall("S_gtk_text_view_get_buffer", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewScrollToIter <-
function(object, iter, within.margin, use.align = FALSE, xalign = 0.5, yalign = 0.5)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(iter, "GtkTextIter")
  within.margin <- as.numeric(within.margin)
  use.align <- as.logical(use.align)
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)

  w <- .RGtkCall("S_gtk_text_view_scroll_to_iter", object, iter, within.margin, use.align, xalign, yalign, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewScrollToMark <-
function(object, mark, within.margin, use.align = FALSE, xalign = 0.5, yalign = 0.5)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(mark, "GtkTextMark")
  within.margin <- as.numeric(within.margin)
  use.align <- as.logical(use.align)
  xalign <- as.numeric(xalign)
  yalign <- as.numeric(yalign)

  w <- .RGtkCall("S_gtk_text_view_scroll_to_mark", object, mark, within.margin, use.align, xalign, yalign, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewScrollMarkOnscreen <-
function(object, mark)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(mark, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_view_scroll_mark_onscreen", object, mark, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewMoveMarkOnscreen <-
function(object, mark)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(mark, "GtkTextMark")

  w <- .RGtkCall("S_gtk_text_view_move_mark_onscreen", object, mark, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewPlaceCursorOnscreen <-
function(object)
{
  checkPtrType(object, "GtkTextView")

  w <- .RGtkCall("S_gtk_text_view_place_cursor_onscreen", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetVisibleRect <-
function(object)
{
  checkPtrType(object, "GtkTextView")

  w <- .RGtkCall("S_gtk_text_view_get_visible_rect", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewSetCursorVisible <-
function(object, setting)
{
  checkPtrType(object, "GtkTextView")
  setting <- as.logical(setting)

  w <- .RGtkCall("S_gtk_text_view_set_cursor_visible", object, setting, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetCursorVisible <-
function(object)
{
  checkPtrType(object, "GtkTextView")

  w <- .RGtkCall("S_gtk_text_view_get_cursor_visible", object, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetIterLocation <-
function(object, iter)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_view_get_iter_location", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetIterAtLocation <-
function(object, x, y)
{
  checkPtrType(object, "GtkTextView")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_text_view_get_iter_at_location", object, x, y, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetIterAtPosition <-
function(object, x, y)
{
  checkPtrType(object, "GtkTextView")
  x <- as.integer(x)
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_text_view_get_iter_at_position", object, x, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetLineYrange <-
function(object, iter)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_view_get_line_yrange", object, iter, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetLineAtY <-
function(object, y)
{
  checkPtrType(object, "GtkTextView")
  y <- as.integer(y)

  w <- .RGtkCall("S_gtk_text_view_get_line_at_y", object, y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewBufferToWindowCoords <-
function(object, win, buffer.x, buffer.y)
{
  checkPtrType(object, "GtkTextView")
  
  buffer.x <- as.integer(buffer.x)
  buffer.y <- as.integer(buffer.y)

  w <- .RGtkCall("S_gtk_text_view_buffer_to_window_coords", object, win, buffer.x, buffer.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewWindowToBufferCoords <-
function(object, win, window.x, window.y)
{
  checkPtrType(object, "GtkTextView")
  
  window.x <- as.integer(window.x)
  window.y <- as.integer(window.y)

  w <- .RGtkCall("S_gtk_text_view_window_to_buffer_coords", object, win, window.x, window.y, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetWindow <-
function(object, win)
{
  checkPtrType(object, "GtkTextView")
  

  w <- .RGtkCall("S_gtk_text_view_get_window", object, win, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewGetWindowType <-
function(object, window)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(window, "GdkWindow")

  w <- .RGtkCall("S_gtk_text_view_get_window_type", object, window, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewSetBorderWindowSize <-
function(object, type, size)
{
  checkPtrType(object, "GtkTextView")
  
  size <- as.integer(size)

  w <- .RGtkCall("S_gtk_text_view_set_border_window_size", object, type, size, PACKAGE = "RGtk2")

  return(invisible(w))
} 


gtkTextViewGetBorderWindowSize <-
function(object, type)
{
  checkPtrType(object, "GtkTextView")
  

  w <- .RGtkCall("S_gtk_text_view_get_border_window_size", object, type, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewForwardDisplayLine <-
function(object, iter)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_view_forward_display_line", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewBackwardDisplayLine <-
function(object, iter)
{
  checkPtrType(object, "GtkTextView")
  checkPtrType(iter, "GtkTextIter")

  w <- .RGtkCall("S_gtk_text_view_backward_display_line", object, iter, PACKAGE = "RGtk2")

  return(w)
} 


gtkTextViewForwardDisplayLineEnd <-
function(object, iter)
{
  checkPtrType(object