gAppInfoGetType <-
function()
{
w <- .RGtkCall("S_g_app_info_get_type", PACKAGE = "RGtk2")
return(w)
}
gAppInfoLaunchDefaultForUri <-
function(uri, launch.context, .errwarn = TRUE)
{
uri <- as.character(uri)
checkPtrType(launch.context, "GAppLaunchContext")
w <- .RGtkCall("S_g_app_info_launch_default_for_uri", uri, launch.context, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppLaunchContextGetType <-
function()
{
w <- .RGtkCall("S_g_app_launch_context_get_type", PACKAGE = "RGtk2")
return(w)
}
gAppInfoCreateFromCommandline <-
function(commandline, application.name = NULL, flags = "G_APP_INFO_CREATE_NONE", .errwarn = TRUE)
{
commandline <- as.character(commandline)
if (!is.null( application.name )) application.name <- as.character(application.name)
w <- .RGtkCall("S_g_app_info_create_from_commandline", commandline, application.name, flags, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoDup <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_dup", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoEqual <-
function(object, appinfo2)
{
checkPtrType(object, "GAppInfo")
checkPtrType(appinfo2, "GAppInfo")
w <- .RGtkCall("S_g_app_info_equal", object, appinfo2, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetId <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_id", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetName <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetDescription <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_description", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetExecutable <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_executable", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetIcon <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoLaunch <-
function(object, files, launch.context, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
files <- as.GList(files)
checkPtrType(launch.context, "GAppLaunchContext")
w <- .RGtkCall("S_g_app_info_launch", object, files, launch.context, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoSupportsUris <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_supports_uris", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoSupportsFiles <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_supports_files", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoLaunchUris <-
function(object, uris, launch.context, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
uris <- as.GList(uris)
checkPtrType(launch.context, "GAppLaunchContext")
w <- .RGtkCall("S_g_app_info_launch_uris", object, uris, launch.context, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoShouldShow <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_should_show", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoSetAsDefaultForType <-
function(object, content.type, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_app_info_set_as_default_for_type", object, content.type, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoSetAsDefaultForExtension <-
function(object, extension, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
extension <- as.character(extension)
w <- .RGtkCall("S_g_app_info_set_as_default_for_extension", object, extension, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoAddSupportsType <-
function(object, content.type, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_app_info_add_supports_type", object, content.type, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoCanRemoveSupportsType <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_can_remove_supports_type", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoRemoveSupportsType <-
function(object, content.type, .errwarn = TRUE)
{
checkPtrType(object, "GAppInfo")
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_app_info_remove_supports_type", object, content.type, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAppInfoGetAll <-
function()
{
w <- .RGtkCall("S_g_app_info_get_all", PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetAllForType <-
function(content.type)
{
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_app_info_get_all_for_type", content.type, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetDefaultForType <-
function(content.type, must.support.uris)
{
content.type <- as.character(content.type)
must.support.uris <- as.logical(must.support.uris)
w <- .RGtkCall("S_g_app_info_get_default_for_type", content.type, must.support.uris, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetDefaultForUriScheme <-
function(uri.scheme)
{
uri.scheme <- as.character(uri.scheme)
w <- .RGtkCall("S_g_app_info_get_default_for_uri_scheme", uri.scheme, PACKAGE = "RGtk2")
return(w)
}
gAppLaunchContextNew <-
function()
{
w <- .RGtkCall("S_g_app_launch_context_new", PACKAGE = "RGtk2")
return(w)
}
gAppLaunchContextGetDisplay <-
function(object, info, files)
{
checkPtrType(object, "GAppLaunchContext")
checkPtrType(info, "GAppInfo")
files <- as.GList(files)
w <- .RGtkCall("S_g_app_launch_context_get_display", object, info, files, PACKAGE = "RGtk2")
return(w)
}
gAppLaunchContextGetStartupNotifyId <-
function(object, info, files)
{
checkPtrType(object, "GAppLaunchContext")
checkPtrType(info, "GAppInfo")
files <- as.GList(files)
w <- .RGtkCall("S_g_app_launch_context_get_startup_notify_id", object, info, files, PACKAGE = "RGtk2")
return(w)
}
gAppLaunchContextLaunchFailed <-
function(object, startup.notify.id)
{
checkPtrType(object, "GAppLaunchContext")
startup.notify.id <- as.character(startup.notify.id)
w <- .RGtkCall("S_g_app_launch_context_launch_failed", object, startup.notify.id, PACKAGE = "RGtk2")
return(invisible(w))
}
gAsyncResultGetType <-
function()
{
w <- .RGtkCall("S_g_async_result_get_type", PACKAGE = "RGtk2")
return(w)
}
gAsyncResultGetUserData <-
function(object)
{
checkPtrType(object, "GAsyncResult")
w <- .RGtkCall("S_g_async_result_get_user_data", object, PACKAGE = "RGtk2")
return(w)
}
gAsyncResultGetSourceObject <-
function(object)
{
checkPtrType(object, "GAsyncResult")
w <- .RGtkCall("S_g_async_result_get_source_object", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_buffered_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamNew <-
function(base.stream = NULL)
{
w <- .RGtkCall("S_g_buffered_input_stream_new", base.stream, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamNewSized <-
function(base.stream, size)
{
checkPtrType(base.stream, "GInputStream")
size <- as.numeric(size)
w <- .RGtkCall("S_g_buffered_input_stream_new_sized", base.stream, size, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamGetBufferSize <-
function(object)
{
checkPtrType(object, "GBufferedInputStream")
w <- .RGtkCall("S_g_buffered_input_stream_get_buffer_size", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamSetBufferSize <-
function(object, size)
{
checkPtrType(object, "GBufferedInputStream")
size <- as.numeric(size)
w <- .RGtkCall("S_g_buffered_input_stream_set_buffer_size", object, size, PACKAGE = "RGtk2")
return(invisible(w))
}
gBufferedInputStreamGetAvailable <-
function(object)
{
checkPtrType(object, "GBufferedInputStream")
w <- .RGtkCall("S_g_buffered_input_stream_get_available", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamPeekBuffer <-
function(object)
{
checkPtrType(object, "GBufferedInputStream")
w <- .RGtkCall("S_g_buffered_input_stream_peek_buffer", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedInputStreamFill <-
function(object, count, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GBufferedInputStream")
count <- as.integer(count)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_buffered_input_stream_fill", object, count, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gBufferedInputStreamFillAsync <-
function(object, count, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GBufferedInputStream")
count <- as.integer(count)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_buffered_input_stream_fill_async", object, count, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gBufferedInputStreamFillFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GBufferedInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_buffered_input_stream_fill_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gBufferedInputStreamReadByte <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GBufferedInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_buffered_input_stream_read_byte", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gBufferedOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_buffered_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gBufferedOutputStreamNew <-
function(base.stream = NULL)
{
w <- .RGtkCall("S_g_buffered_output_stream_new", base.stream, PACKAGE = "RGtk2")
return(w)
}
gBufferedOutputStreamNewSized <-
function(base.stream, size)
{
checkPtrType(base.stream, "GOutputStream")
size <- as.numeric(size)
w <- .RGtkCall("S_g_buffered_output_stream_new_sized", base.stream, size, PACKAGE = "RGtk2")
return(w)
}
gBufferedOutputStreamGetBufferSize <-
function(object)
{
checkPtrType(object, "GBufferedOutputStream")
w <- .RGtkCall("S_g_buffered_output_stream_get_buffer_size", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedOutputStreamSetBufferSize <-
function(object, size)
{
checkPtrType(object, "GBufferedOutputStream")
size <- as.numeric(size)
w <- .RGtkCall("S_g_buffered_output_stream_set_buffer_size", object, size, PACKAGE = "RGtk2")
return(invisible(w))
}
gBufferedOutputStreamGetAutoGrow <-
function(object)
{
checkPtrType(object, "GBufferedOutputStream")
w <- .RGtkCall("S_g_buffered_output_stream_get_auto_grow", object, PACKAGE = "RGtk2")
return(w)
}
gBufferedOutputStreamSetAutoGrow <-
function(object, auto.grow)
{
checkPtrType(object, "GBufferedOutputStream")
auto.grow <- as.logical(auto.grow)
w <- .RGtkCall("S_g_buffered_output_stream_set_auto_grow", object, auto.grow, PACKAGE = "RGtk2")
return(invisible(w))
}
gCancellableGetType <-
function()
{
w <- .RGtkCall("S_g_cancellable_get_type", PACKAGE = "RGtk2")
return(w)
}
gCancellableNew <-
function()
{
w <- .RGtkCall("S_g_cancellable_new", PACKAGE = "RGtk2")
return(w)
}
gCancellableIsCancelled <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_is_cancelled", object, PACKAGE = "RGtk2")
return(w)
}
gCancellableSetErrorIfCancelled <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_set_error_if_cancelled", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gCancellableGetFd <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_get_fd", object, PACKAGE = "RGtk2")
return(w)
}
gCancellableGetCurrent <-
function()
{
w <- .RGtkCall("S_g_cancellable_get_current", PACKAGE = "RGtk2")
return(w)
}
gCancellablePushCurrent <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_push_current", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gCancellablePopCurrent <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_pop_current", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gCancellableReset <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_reset", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gCancellableCancel <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_cancel", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gContentTypeEquals <-
function(type1, type2)
{
type1 <- as.character(type1)
type2 <- as.character(type2)
w <- .RGtkCall("S_g_content_type_equals", type1, type2, PACKAGE = "RGtk2")
return(w)
}
gContentTypeIsA <-
function(type, supertype)
{
type <- as.character(type)
supertype <- as.character(supertype)
w <- .RGtkCall("S_g_content_type_is_a", type, supertype, PACKAGE = "RGtk2")
return(w)
}
gContentTypeIsUnknown <-
function(type)
{
type <- as.character(type)
w <- .RGtkCall("S_g_content_type_is_unknown", type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeGetDescription <-
function(type)
{
type <- as.character(type)
w <- .RGtkCall("S_g_content_type_get_description", type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeGetMimeType <-
function(type)
{
type <- as.character(type)
w <- .RGtkCall("S_g_content_type_get_mime_type", type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeGetIcon <-
function(type)
{
type <- as.character(type)
w <- .RGtkCall("S_g_content_type_get_icon", type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeCanBeExecutable <-
function(type)
{
type <- as.character(type)
w <- .RGtkCall("S_g_content_type_can_be_executable", type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeGuess <-
function(filename, data)
{
filename <- as.character(filename)
data <- as.list(as.raw(data))
w <- .RGtkCall("S_g_content_type_guess", filename, data, PACKAGE = "RGtk2")
return(w)
}
gContentTypesGetRegistered <-
function()
{
w <- .RGtkCall("S_g_content_types_get_registered", PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_data_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamNew <-
function(base.stream = NULL)
{
w <- .RGtkCall("S_g_data_input_stream_new", base.stream, PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamSetByteOrder <-
function(object, order)
{
checkPtrType(object, "GDataInputStream")
w <- .RGtkCall("S_g_data_input_stream_set_byte_order", object, order, PACKAGE = "RGtk2")
return(invisible(w))
}
gDataInputStreamGetByteOrder <-
function(object)
{
checkPtrType(object, "GDataInputStream")
w <- .RGtkCall("S_g_data_input_stream_get_byte_order", object, PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamSetNewlineType <-
function(object, type)
{
checkPtrType(object, "GDataInputStream")
w <- .RGtkCall("S_g_data_input_stream_set_newline_type", object, type, PACKAGE = "RGtk2")
return(invisible(w))
}
gDataInputStreamGetNewlineType <-
function(object)
{
checkPtrType(object, "GDataInputStream")
w <- .RGtkCall("S_g_data_input_stream_get_newline_type", object, PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamReadByte <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_byte", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadInt16 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_int16", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadUint16 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_uint16", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadInt32 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_int32", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadUint32 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_uint32", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadInt64 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_int64", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadUint64 <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_uint64", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadLine <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_line", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadUntil <-
function(object, stop.chars, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
stop.chars <- as.character(stop.chars)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_input_stream_read_until", object, stop.chars, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_data_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gDataOutputStreamNew <-
function(base.stream = NULL)
{
w <- .RGtkCall("S_g_data_output_stream_new", base.stream, PACKAGE = "RGtk2")
return(w)
}
gDataOutputStreamSetByteOrder <-
function(object, order)
{
checkPtrType(object, "GDataOutputStream")
w <- .RGtkCall("S_g_data_output_stream_set_byte_order", object, order, PACKAGE = "RGtk2")
return(invisible(w))
}
gDataOutputStreamGetByteOrder <-
function(object)
{
checkPtrType(object, "GDataOutputStream")
w <- .RGtkCall("S_g_data_output_stream_get_byte_order", object, PACKAGE = "RGtk2")
return(w)
}
gDataOutputStreamPutByte <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.raw(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_byte", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutInt16 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.integer(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_int16", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutUint16 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.integer(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_uint16", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutInt32 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.integer(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_int32", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutUint32 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.numeric(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_uint32", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutInt64 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.numeric(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_int64", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutUint64 <-
function(object, data, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
data <- as.numeric(data)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_uint64", object, data, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataOutputStreamPutString <-
function(object, str, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GDataOutputStream")
str <- as.character(str)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_data_output_stream_put_string", object, str, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDriveGetType <-
function()
{
w <- .RGtkCall("S_g_drive_get_type", PACKAGE = "RGtk2")
return(w)
}
gDriveGetName <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gDriveGetIcon <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gDriveHasVolumes <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_has_volumes", object, PACKAGE = "RGtk2")
return(w)
}
gDriveGetVolumes <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_get_volumes", object, PACKAGE = "RGtk2")
return(w)
}
gDriveIsMediaRemovable <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_is_media_removable", object, PACKAGE = "RGtk2")
return(w)
}
gDriveHasMedia <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_has_media", object, PACKAGE = "RGtk2")
return(w)
}
gDriveIsMediaCheckAutomatic <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_is_media_check_automatic", object, PACKAGE = "RGtk2")
return(w)
}
gDriveCanPollForMedia <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_can_poll_for_media", object, PACKAGE = "RGtk2")
return(w)
}
gDriveCanEject <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_can_eject", object, PACKAGE = "RGtk2")
return(w)
}
gDriveEject <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDrive")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_drive_eject", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDriveEjectFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDrive")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_drive_eject_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDrivePollForMedia <-
function(object, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDrive")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_drive_poll_for_media", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDrivePollForMediaFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDrive")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_drive_poll_for_media_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDriveGetIdentifier <-
function(object, kind)
{
checkPtrType(object, "GDrive")
kind <- as.character(kind)
w <- .RGtkCall("S_g_drive_get_identifier", object, kind, PACKAGE = "RGtk2")
return(w)
}
gDriveEnumerateIdentifiers <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_enumerate_identifiers", object, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeInfoListNew <-
function()
{
w <- .RGtkCall("S_g_file_attribute_info_list_new", PACKAGE = "RGtk2")
return(w)
}
gFileAttributeInfoListLookup <-
function(object, name)
{
checkPtrType(object, "GFileAttributeInfoList")
name <- as.character(name)
w <- .RGtkCall("S_g_file_attribute_info_list_lookup", object, name, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeInfoListAdd <-
function(object, name, type, flags = "G_FILE_ATTRIBUTE_INFO_NONE")
{
checkPtrType(object, "GFileAttributeInfoList")
name <- as.character(name)
w <- .RGtkCall("S_g_file_attribute_info_list_add", object, name, type, flags, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEnumeratorGetType <-
function()
{
w <- .RGtkCall("S_g_file_enumerator_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileEnumeratorNextFile <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFileEnumerator")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_enumerator_next_file", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumeratorClose <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFileEnumerator")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_enumerator_close", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumeratorNextFilesAsync <-
function(object, num.files, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFileEnumerator")
num.files <- as.integer(num.files)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_enumerator_next_files_async", object, num.files, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEnumeratorNextFilesFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFileEnumerator")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_enumerator_next_files_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumeratorCloseAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFileEnumerator")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_enumerator_close_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEnumeratorCloseFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFileEnumerator")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_enumerator_close_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumeratorIsClosed <-
function(object)
{
checkPtrType(object, "GFileEnumerator")
w <- .RGtkCall("S_g_file_enumerator_is_closed", object, PACKAGE = "RGtk2")
return(w)
}
gFileEnumeratorHasPending <-
function(object)
{
checkPtrType(object, "GFileEnumerator")
w <- .RGtkCall("S_g_file_enumerator_has_pending", object, PACKAGE = "RGtk2")
return(w)
}
gFileEnumeratorSetPending <-
function(object, pending)
{
checkPtrType(object, "GFileEnumerator")
pending <- as.logical(pending)
w <- .RGtkCall("S_g_file_enumerator_set_pending", object, pending, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileGetType <-
function()
{
w <- .RGtkCall("S_g_file_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileNewForPath <-
function(path)
{
path <- as.character(path)
w <- .RGtkCall("S_g_file_new_for_path", path, PACKAGE = "RGtk2")
return(w)
}
gFileNewForUri <-
function(uri)
{
uri <- as.character(uri)
w <- .RGtkCall("S_g_file_new_for_uri", uri, PACKAGE = "RGtk2")
return(w)
}
gFileNewForCommandlineArg <-
function(arg)
{
arg <- as.character(arg)
w <- .RGtkCall("S_g_file_new_for_commandline_arg", arg, PACKAGE = "RGtk2")
return(w)
}
gFileParseName <-
function(parse.name)
{
parse.name <- as.character(parse.name)
w <- .RGtkCall("S_g_file_parse_name", parse.name, PACKAGE = "RGtk2")
return(w)
}
gFileDup <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_dup", object, PACKAGE = "RGtk2")
return(w)
}
gFileHash <-
function(file)
{
w <- .RGtkCall("S_g_file_hash", file, PACKAGE = "RGtk2")
return(w)
}
gFileEqual <-
function(object, file2)
{
checkPtrType(object, "GFile")
checkPtrType(file2, "GFile")
w <- .RGtkCall("S_g_file_equal", object, file2, PACKAGE = "RGtk2")
return(w)
}
gFileGetBasename <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_basename", object, PACKAGE = "RGtk2")
return(w)
}
gFileGetPath <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_path", object, PACKAGE = "RGtk2")
return(w)
}
gFileGetUri <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_uri", object, PACKAGE = "RGtk2")
return(w)
}
gFileGetParseName <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_parse_name", object, PACKAGE = "RGtk2")
return(w)
}
gFileGetParent <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_parent", object, PACKAGE = "RGtk2")
return(w)
}
gFileGetChild <-
function(object, name)
{
checkPtrType(object, "GFile")
name <- as.character(name)
w <- .RGtkCall("S_g_file_get_child", object, name, PACKAGE = "RGtk2")
return(w)
}
gFileGetChildForDisplayName <-
function(object, display.name, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
display.name <- as.character(display.name)
w <- .RGtkCall("S_g_file_get_child_for_display_name", object, display.name, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileHasPrefix <-
function(object, descendant)
{
checkPtrType(object, "GFile")
checkPtrType(descendant, "GFile")
w <- .RGtkCall("S_g_file_has_prefix", object, descendant, PACKAGE = "RGtk2")
return(w)
}
gFileGetRelativePath <-
function(object, descendant)
{
checkPtrType(object, "GFile")
checkPtrType(descendant, "GFile")
w <- .RGtkCall("S_g_file_get_relative_path", object, descendant, PACKAGE = "RGtk2")
return(w)
}
gFileResolveRelativePath <-
function(object, relative.path)
{
checkPtrType(object, "GFile")
relative.path <- as.character(relative.path)
w <- .RGtkCall("S_g_file_resolve_relative_path", object, relative.path, PACKAGE = "RGtk2")
return(w)
}
gFileIsNative <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_is_native", object, PACKAGE = "RGtk2")
return(w)
}
gFileHasUriScheme <-
function(object, uri.scheme)
{
checkPtrType(object, "GFile")
uri.scheme <- as.character(uri.scheme)
w <- .RGtkCall("S_g_file_has_uri_scheme", object, uri.scheme, PACKAGE = "RGtk2")
return(w)
}
gFileGetUriScheme <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_get_uri_scheme", object, PACKAGE = "RGtk2")
return(w)
}
gFileRead <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_read", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReadAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_read_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileReadFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_read_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileAppendTo <-
function(object, flags = "G_FILE_CREATE_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_append_to", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCreate <-
function(object, flags = "G_FILE_CREATE_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_create", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplace <-
function(object, etag, make.backup, flags = "G_FILE_CREATE_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
etag <- as.character(etag)
make.backup <- as.logical(make.backup)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_replace", object, etag, make.backup, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileAppendToAsync <-
function(object, flags = "G_FILE_CREATE_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_append_to_async", object, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileAppendToFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_append_to_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCreateAsync <-
function(object, flags = "G_FILE_CREATE_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_create_async", object, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileCreateFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_create_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplaceAsync <-
function(object, etag, make.backup, flags = "G_FILE_CREATE_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
etag <- as.character(etag)
make.backup <- as.logical(make.backup)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_replace_async", object, etag, make.backup, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileReplaceFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_replace_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryExists <-
function(object, cancellable = NULL)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_exists", object, cancellable, PACKAGE = "RGtk2")
return(w)
}
gFileQueryInfo <-
function(object, attributes, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_info", object, attributes, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryInfoAsync <-
function(object, attributes, flags = "G_FILE_QUERY_INFO_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_query_info_async", object, attributes, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileQueryInfoFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_query_info_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryFilesystemInfo <-
function(object, attributes, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_filesystem_info", object, attributes, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryFilesystemInfoAsync <-
function(object, attributes, io.priority, cancellable, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
io.priority <- as.integer(io.priority)
checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_query_filesystem_info_async", object, attributes, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileQueryFilesystemInfoFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_query_filesystem_info_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileFindEnclosingMount <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_find_enclosing_mount", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileFindEnclosingMountAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_find_enclosing_mount_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileFindEnclosingMountFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_find_enclosing_mount_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumerateChildren <-
function(object, attributes, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_enumerate_children", object, attributes, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEnumerateChildrenAsync <-
function(object, attributes, flags = "G_FILE_QUERY_INFO_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
attributes <- as.character(attributes)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_enumerate_children_async", object, attributes, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEnumerateChildrenFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_enumerate_children_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetDisplayName <-
function(object, display.name, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
display.name <- as.character(display.name)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_display_name", object, display.name, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetDisplayNameAsync <-
function(object, display.name, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
display.name <- as.character(display.name)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_set_display_name_async", object, display.name, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileSetDisplayNameFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_set_display_name_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileDelete <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_delete", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileTrash <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_trash", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCopy <-
function(object, destination, flags = "G_FILE_COPY_NONE", cancellable = NULL, progress.callback, progress.callback.data, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(destination, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
progress.callback <- as.function(progress.callback)
w <- .RGtkCall("S_g_file_copy", object, destination, flags, cancellable, progress.callback, progress.callback.data, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCopyAsync <-
function(object, destination, flags = "G_FILE_COPY_NONE", io.priority = 0, cancellable = NULL, progress.callback, progress.callback.data, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
checkPtrType(destination, "GFile")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
progress.callback <- as.function(progress.callback)
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_copy_async", object, destination, flags, io.priority, cancellable, progress.callback, progress.callback.data, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileCopyFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_copy_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMove <-
function(object, destination, flags = "G_FILE_COPY_NONE", cancellable = NULL, progress.callback, progress.callback.data, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(destination, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
progress.callback <- as.function(progress.callback)
w <- .RGtkCall("S_g_file_move", object, destination, flags, cancellable, progress.callback, progress.callback.data, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMakeDirectory <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_make_directory", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMakeSymbolicLink <-
function(object, symlink.value, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
symlink.value <- as.character(symlink.value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_make_symbolic_link", object, symlink.value, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQuerySettableAttributes <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_settable_attributes", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryWritableNamespaces <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_writable_namespaces", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttribute <-
function(object, attribute, type, value.p, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute", object, attribute, type, value.p, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributesFromInfo <-
function(object, info, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(info, "GFileInfo")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attributes_from_info", object, info, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributesAsync <-
function(object, info, flags = "G_FILE_QUERY_INFO_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
checkPtrType(info, "GFileInfo")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_set_attributes_async", object, info, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileSetAttributesFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_set_attributes_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeString <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.character(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_string", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeByteString <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.character(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_byte_string", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeUint32 <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.numeric(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_uint32", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeInt32 <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.integer(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_int32", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeUint64 <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.numeric(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_uint64", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSetAttributeInt64 <-
function(object, attribute, value, flags = "G_FILE_QUERY_INFO_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
attribute <- as.character(attribute)
value <- as.numeric(value)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_set_attribute_int64", object, attribute, value, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMountEnclosingVolume <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_mount_enclosing_volume", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileMountEnclosingVolumeFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_mount_enclosing_volume_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMountMountable <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_mount_mountable", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileMountMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_mount_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileUnmountMountable <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_unmount_mountable", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileUnmountMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_unmount_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEjectMountable <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_eject_mountable", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEjectMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_eject_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCopyAttributes <-
function(object, destination, flags = "G_FILE_COPY_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(destination, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_copy_attributes", object, destination, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMonitorDirectory <-
function(object, flags = "G_FILE_MONITOR_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_monitor_directory", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMonitorFile <-
function(object, flags = "G_FILE_MONITOR_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_monitor_file", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileQueryDefaultHandler <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_default_handler", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileLoadContents <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_load_contents", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileLoadContentsAsync <-
function(object, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_load_contents_async", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileLoadContentsFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_load_contents_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileLoadPartialContentsFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_load_partial_contents_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplaceContents <-
function(object, contents, length, etag, make.backup, flags = "G_FILE_CREATE_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
contents <- as.character(contents)
length <- as.numeric(length)
etag <- as.character(etag)
make.backup <- as.logical(make.backup)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_replace_contents", object, contents, length, etag, make.backup, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplaceContentsAsync <-
function(object, contents, length, etag, make.backup, flags = "G_FILE_CREATE_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
contents <- as.character(contents)
length <- as.numeric(length)
etag <- as.character(etag)
make.backup <- as.logical(make.backup)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_replace_contents_async", object, contents, length, etag, make.backup, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileReplaceContentsFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_replace_contents_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileIconGetType <-
function()
{
w <- .RGtkCall("S_g_file_icon_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileIconNew <-
function(file)
{
checkPtrType(file, "GFile")
w <- .RGtkCall("S_g_file_icon_new", file, PACKAGE = "RGtk2")
return(w)
}
gFileIconGetFile <-
function(object)
{
checkPtrType(object, "GFileIcon")
w <- .RGtkCall("S_g_file_icon_get_file", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetType <-
function()
{
w <- .RGtkCall("S_g_file_info_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileInfoNew <-
function()
{
w <- .RGtkCall("S_g_file_info_new", PACKAGE = "RGtk2")
return(w)
}
gFileInfoDup <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_dup", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoCopyInto <-
function(object, dest.info)
{
checkPtrType(object, "GFileInfo")
checkPtrType(dest.info, "GFileInfo")
w <- .RGtkCall("S_g_file_info_copy_into", object, dest.info, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoHasAttribute <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_has_attribute", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoListAttributes <-
function(object, name.space)
{
checkPtrType(object, "GFileInfo")
name.space <- as.character(name.space)
w <- .RGtkCall("S_g_file_info_list_attributes", object, name.space, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeData <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_data", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeType <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_type", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoRemoveAttribute <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_remove_attribute", object, attribute, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoGetAttributeStatus <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_status", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeAsString <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_as_string", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeString <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_string", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeByteString <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_byte_string", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeBoolean <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_boolean", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeUint32 <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_uint32", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeInt32 <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_int32", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeUint64 <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_uint64", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeInt64 <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_int64", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeObject <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_object", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoSetAttribute <-
function(object, attribute, type, value.p)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_set_attribute", object, attribute, type, value.p, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeString <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.character(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_string", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeByteString <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.character(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_byte_string", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeBoolean <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.logical(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_boolean", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeUint32 <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.numeric(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_uint32", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeInt32 <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.integer(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_int32", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeUint64 <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.numeric(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_uint64", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeInt64 <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.numeric(attr.value)
w <- .RGtkCall("S_g_file_info_set_attribute_int64", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetAttributeObject <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
checkPtrType(attr.value, "GObject")
w <- .RGtkCall("S_g_file_info_set_attribute_object", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoClearStatus <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_clear_status", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoGetFileType <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_file_type", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetIsHidden <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_is_hidden", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetIsBackup <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_is_backup", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetIsSymlink <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_is_symlink", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetName <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetDisplayName <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_display_name", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetEditName <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_edit_name", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetIcon <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetContentType <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_content_type", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetSize <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_size", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetModificationTime <-
function(object, result)
{
checkPtrType(object, "GFileInfo")
result <- as.GTimeVal(result)
w <- .RGtkCall("S_g_file_info_get_modification_time", object, result, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoGetSymlinkTarget <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_symlink_target", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetEtag <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_etag", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetSortOrder <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_get_sort_order", object, PACKAGE = "RGtk2")
return(w)
}
gFileInfoSetAttributeMask <-
function(object, mask)
{
checkPtrType(object, "GFileInfo")
checkPtrType(mask, "GFileAttributeMatcher")
w <- .RGtkCall("S_g_file_info_set_attribute_mask", object, mask, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoUnsetAttributeMask <-
function(object)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_unset_attribute_mask", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetFileType <-
function(object, type)
{
checkPtrType(object, "GFileInfo")
w <- .RGtkCall("S_g_file_info_set_file_type", object, type, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetIsHidden <-
function(object, is.hidden)
{
checkPtrType(object, "GFileInfo")
is.hidden <- as.logical(is.hidden)
w <- .RGtkCall("S_g_file_info_set_is_hidden", object, is.hidden, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetIsSymlink <-
function(object, is.symlink)
{
checkPtrType(object, "GFileInfo")
is.symlink <- as.logical(is.symlink)
w <- .RGtkCall("S_g_file_info_set_is_symlink", object, is.symlink, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetName <-
function(object, name)
{
checkPtrType(object, "GFileInfo")
name <- as.character(name)
w <- .RGtkCall("S_g_file_info_set_name", object, name, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetDisplayName <-
function(object, display.name)
{
checkPtrType(object, "GFileInfo")
display.name <- as.character(display.name)
w <- .RGtkCall("S_g_file_info_set_display_name", object, display.name, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetEditName <-
function(object, edit.name)
{
checkPtrType(object, "GFileInfo")
edit.name <- as.character(edit.name)
w <- .RGtkCall("S_g_file_info_set_edit_name", object, edit.name, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetIcon <-
function(object, icon)
{
checkPtrType(object, "GFileInfo")
checkPtrType(icon, "GIcon")
w <- .RGtkCall("S_g_file_info_set_icon", object, icon, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetContentType <-
function(object, content.type)
{
checkPtrType(object, "GFileInfo")
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_file_info_set_content_type", object, content.type, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetSize <-
function(object, size)
{
checkPtrType(object, "GFileInfo")
size <- as.numeric(size)
w <- .RGtkCall("S_g_file_info_set_size", object, size, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetModificationTime <-
function(object, mtime)
{
checkPtrType(object, "GFileInfo")
mtime <- as.GTimeVal(mtime)
w <- .RGtkCall("S_g_file_info_set_modification_time", object, mtime, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetSymlinkTarget <-
function(object, symlink.target)
{
checkPtrType(object, "GFileInfo")
symlink.target <- as.character(symlink.target)
w <- .RGtkCall("S_g_file_info_set_symlink_target", object, symlink.target, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInfoSetSortOrder <-
function(object, sort.order)
{
checkPtrType(object, "GFileInfo")
sort.order <- as.integer(sort.order)
w <- .RGtkCall("S_g_file_info_set_sort_order", object, sort.order, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileAttributeMatcherNew <-
function(attributes)
{
attributes <- as.character(attributes)
w <- .RGtkCall("S_g_file_attribute_matcher_new", attributes, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeMatcherMatches <-
function(object, attribute)
{
checkPtrType(object, "GFileAttributeMatcher")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_attribute_matcher_matches", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeMatcherMatchesOnly <-
function(object, attribute)
{
checkPtrType(object, "GFileAttributeMatcher")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_attribute_matcher_matches_only", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeMatcherEnumerateNamespace <-
function(object, ns)
{
checkPtrType(object, "GFileAttributeMatcher")
ns <- as.character(ns)
w <- .RGtkCall("S_g_file_attribute_matcher_enumerate_namespace", object, ns, PACKAGE = "RGtk2")
return(w)
}
gFileAttributeMatcherEnumerateNext <-
function(object)
{
checkPtrType(object, "GFileAttributeMatcher")
w <- .RGtkCall("S_g_file_attribute_matcher_enumerate_next", object, PACKAGE = "RGtk2")
return(w)
}
gFileInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_file_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileInputStreamQueryInfo <-
function(object, attributes, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFileInputStream")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_input_stream_query_info", object, attributes, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileInputStreamQueryInfoAsync <-
function(object, attributes, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFileInputStream")
attributes <- as.character(attributes)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_input_stream_query_info_async", object, attributes, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileInputStreamQueryInfoFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFileInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_input_stream_query_info_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMonitorGetType <-
function()
{
w <- .RGtkCall("S_g_file_monitor_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileMonitorCancel <-
function(object)
{
checkPtrType(object, "GFileMonitor")
w <- .RGtkCall("S_g_file_monitor_cancel", object, PACKAGE = "RGtk2")
return(w)
}
gFileMonitorIsCancelled <-
function(object)
{
checkPtrType(object, "GFileMonitor")
w <- .RGtkCall("S_g_file_monitor_is_cancelled", object, PACKAGE = "RGtk2")
return(w)
}
gFileMonitorSetRateLimit <-
function(object, limit.msecs)
{
checkPtrType(object, "GFileMonitor")
limit.msecs <- as.integer(limit.msecs)
w <- .RGtkCall("S_g_file_monitor_set_rate_limit", object, limit.msecs, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileMonitorEmitEvent <-
function(object, file, other.file, event.type)
{
checkPtrType(object, "GFileMonitor")
checkPtrType(file, "GFile")
checkPtrType(other.file, "GFile")
w <- .RGtkCall("S_g_file_monitor_emit_event", object, file, other.file, event.type, PACKAGE = "RGtk2")
return(invisible(w))
}
gFilenameCompleterGetType <-
function()
{
w <- .RGtkCall("S_g_filename_completer_get_type", PACKAGE = "RGtk2")
return(w)
}
gFilenameCompleterNew <-
function()
{
w <- .RGtkCall("S_g_filename_completer_new", PACKAGE = "RGtk2")
return(w)
}
gFilenameCompleterGetCompletionSuffix <-
function(object, initial.text)
{
checkPtrType(object, "GFilenameCompleter")
initial.text <- as.character(initial.text)
w <- .RGtkCall("S_g_filename_completer_get_completion_suffix", object, initial.text, PACKAGE = "RGtk2")
return(w)
}
gFilenameCompleterGetCompletions <-
function(object, initial.text)
{
checkPtrType(object, "GFilenameCompleter")
initial.text <- as.character(initial.text)
w <- .RGtkCall("S_g_filename_completer_get_completions", object, initial.text, PACKAGE = "RGtk2")
return(w)
}
gFilenameCompleterSetDirsOnly <-
function(object, dirs.only)
{
checkPtrType(object, "GFilenameCompleter")
dirs.only <- as.logical(dirs.only)
w <- .RGtkCall("S_g_filename_completer_set_dirs_only", object, dirs.only, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_file_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileOutputStreamQueryInfo <-
function(object, attributes, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFileOutputStream")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_output_stream_query_info", object, attributes, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileOutputStreamQueryInfoAsync <-
function(object, attributes, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFileOutputStream")
attributes <- as.character(attributes)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_output_stream_query_info_async", object, attributes, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileOutputStreamQueryInfoFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFileOutputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_output_stream_query_info_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileOutputStreamGetEtag <-
function(object)
{
checkPtrType(object, "GFileOutputStream")
w <- .RGtkCall("S_g_file_output_stream_get_etag", object, PACKAGE = "RGtk2")
return(w)
}
gFilterInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_filter_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gFilterInputStreamGetBaseStream <-
function(object)
{
checkPtrType(object, "GFilterInputStream")
w <- .RGtkCall("S_g_filter_input_stream_get_base_stream", object, PACKAGE = "RGtk2")
return(w)
}
gFilterOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_filter_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gFilterOutputStreamGetBaseStream <-
function(object)
{
checkPtrType(object, "GFilterOutputStream")
w <- .RGtkCall("S_g_filter_output_stream_get_base_stream", object, PACKAGE = "RGtk2")
return(w)
}
gIconGetType <-
function()
{
w <- .RGtkCall("S_g_icon_get_type", PACKAGE = "RGtk2")
return(w)
}
gIconHash <-
function(icon)
{
w <- .RGtkCall("S_g_icon_hash", icon, PACKAGE = "RGtk2")
return(w)
}
gIconEqual <-
function(object, icon2)
{
checkPtrType(object, "GIcon")
checkPtrType(icon2, "GIcon")
w <- .RGtkCall("S_g_icon_equal", object, icon2, PACKAGE = "RGtk2")
return(w)
}
gInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gInputStreamRead <-
function(object, count, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
count <- as.numeric(count)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_input_stream_read", object, count, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamReadAll <-
function(object, count, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
count <- as.numeric(count)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_input_stream_read_all", object, count, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamSkip <-
function(object, count, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
count <- as.numeric(count)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_input_stream_skip", object, count, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamClose <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_input_stream_close", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamReadAsync <-
function(object, count, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GInputStream")
count <- as.numeric(count)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_input_stream_read_async", object, count, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(w)
}
gInputStreamReadFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_input_stream_read_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamSkipAsync <-
function(object, count, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GInputStream")
count <- as.numeric(count)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_input_stream_skip_async", object, count, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gInputStreamSkipFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_input_stream_skip_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamCloseAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GInputStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_input_stream_close_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gInputStreamCloseFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_input_stream_close_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamIsClosed <-
function(object)
{
checkPtrType(object, "GInputStream")
w <- .RGtkCall("S_g_input_stream_is_closed", object, PACKAGE = "RGtk2")
return(w)
}
gInputStreamHasPending <-
function(object)
{
checkPtrType(object, "GInputStream")
w <- .RGtkCall("S_g_input_stream_has_pending", object, PACKAGE = "RGtk2")
return(w)
}
gInputStreamSetPending <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GInputStream")
w <- .RGtkCall("S_g_input_stream_set_pending", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInputStreamClearPending <-
function(object)
{
checkPtrType(object, "GInputStream")
w <- .RGtkCall("S_g_input_stream_clear_pending", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gAppInfoCreateFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_app_info_create_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gDataStreamByteOrderGetType <-
function()
{
w <- .RGtkCall("S_g_data_stream_byte_order_get_type", PACKAGE = "RGtk2")
return(w)
}
gDataStreamNewlineTypeGetType <-
function()
{
w <- .RGtkCall("S_g_data_stream_newline_type_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileQueryInfoFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_file_query_info_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileCreateFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_file_create_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileCopyFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_file_copy_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileMonitorFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_file_monitor_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileAttributeTypeGetType <-
function()
{
w <- .RGtkCall("S_g_file_attribute_type_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileAttributeInfoFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_file_attribute_info_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileAttributeStatusGetType <-
function()
{
w <- .RGtkCall("S_g_file_attribute_status_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileTypeGetType <-
function()
{
w <- .RGtkCall("S_g_file_type_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileMonitorEventGetType <-
function()
{
w <- .RGtkCall("S_g_file_monitor_event_get_type", PACKAGE = "RGtk2")
return(w)
}
gIoErrorEnumGetType <-
function()
{
w