Nothing
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 <- .RGtkCall("S_g_io_error_enum_get_type", PACKAGE = "RGtk2")
return(w)
}
gAskPasswordFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_ask_password_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gPasswordSaveGetType <-
function()
{
w <- .RGtkCall("S_g_password_save_get_type", PACKAGE = "RGtk2")
return(w)
}
gOutputStreamSpliceFlagsGetType <-
function()
{
w <- .RGtkCall("S_g_output_stream_splice_flags_get_type", PACKAGE = "RGtk2")
return(w)
}
gIoErrorQuark <-
function()
{
w <- .RGtkCall("S_g_io_error_quark", PACKAGE = "RGtk2")
return(w)
}
gIoErrorFromErrno <-
function(err.no)
{
err.no <- as.integer(err.no)
w <- .RGtkCall("S_g_io_error_from_errno", err.no, PACKAGE = "RGtk2")
return(w)
}
gIOModuleGetType <-
function()
{
w <- .RGtkCall("S_g_io_module_get_type", PACKAGE = "RGtk2")
return(w)
}
gIOModuleNew <-
function(filename)
{
filename <- as.character(filename)
w <- .RGtkCall("S_g_io_module_new", filename, PACKAGE = "RGtk2")
return(w)
}
gIOModulesLoadAllInDirectory <-
function(dirname)
{
dirname <- as.character(dirname)
w <- .RGtkCall("S_g_io_modules_load_all_in_directory", dirname, PACKAGE = "RGtk2")
return(w)
}
gIoSchedulerCancelAllJobs <-
function()
{
w <- .RGtkCall("S_g_io_scheduler_cancel_all_jobs", PACKAGE = "RGtk2")
return(w)
}
gIoSchedulerJobSendToMainloop <-
function(object, func, user.data = NULL)
{
checkPtrType(object, "GIOSchedulerJob")
func <- as.function(func)
w <- .RGtkCall("S_g_io_scheduler_job_send_to_mainloop", object, func, user.data, PACKAGE = "RGtk2")
return(w)
}
gIoSchedulerJobSendToMainloopAsync <-
function(object, func, user.data = NULL)
{
checkPtrType(object, "GIOSchedulerJob")
func <- as.function(func)
w <- .RGtkCall("S_g_io_scheduler_job_send_to_mainloop_async", object, func, user.data, PACKAGE = "RGtk2")
return(w)
}
gLoadableIconGetType <-
function()
{
w <- .RGtkCall("S_g_loadable_icon_get_type", PACKAGE = "RGtk2")
return(w)
}
gLoadableIconLoad <-
function(object, size, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GLoadableIcon")
size <- as.integer(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_loadable_icon_load", object, size, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gLoadableIconLoadAsync <-
function(object, size, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GLoadableIcon")
size <- as.integer(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_loadable_icon_load_async", object, size, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gLoadableIconLoadFinish <-
function(object, res, type, .errwarn = TRUE)
{
checkPtrType(object, "GLoadableIcon")
checkPtrType(res, "GAsyncResult")
type <- as.list(as.character(type))
w <- .RGtkCall("S_g_loadable_icon_load_finish", object, res, type, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMemoryInputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_memory_input_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gMemoryInputStreamNew <-
function()
{
w <- .RGtkCall("S_g_memory_input_stream_new", PACKAGE = "RGtk2")
return(w)
}
gMemoryInputStreamNewFromData <-
function(data)
{
data <- as.list(as.raw(data))
w <- .RGtkCall("S_g_memory_input_stream_new_from_data", data, PACKAGE = "RGtk2")
return(w)
}
gMemoryInputStreamAddData <-
function(object, data)
{
checkPtrType(object, "GMemoryInputStream")
data <- as.list(as.raw(data))
w <- .RGtkCall("S_g_memory_input_stream_add_data", object, data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMemoryOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_memory_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gMemoryOutputStreamNew <-
function(len)
{
len <- as.numeric(len)
w <- .RGtkCall("S_g_memory_output_stream_new", len, PACKAGE = "RGtk2")
return(w)
}
gMemoryOutputStreamGetData <-
function(object)
{
checkPtrType(object, "GMemoryOutputStream")
w <- .RGtkCall("S_g_memory_output_stream_get_data", object, PACKAGE = "RGtk2")
return(w)
}
gMemoryOutputStreamGetSize <-
function(object)
{
checkPtrType(object, "GMemoryOutputStream")
w <- .RGtkCall("S_g_memory_output_stream_get_size", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetType <-
function()
{
w <- .RGtkCall("S_g_mount_get_type", PACKAGE = "RGtk2")
return(w)
}
gMountGetRoot <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_root", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetName <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetIcon <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetUuid <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_uuid", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetVolume <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_volume", object, PACKAGE = "RGtk2")
return(w)
}
gMountGetDrive <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_get_drive", object, PACKAGE = "RGtk2")
return(w)
}
gMountCanUnmount <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_can_unmount", object, PACKAGE = "RGtk2")
return(w)
}
gMountCanEject <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_can_eject", object, PACKAGE = "RGtk2")
return(w)
}
gMountUnmount <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_unmount", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountUnmountFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_unmount_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountEject <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_eject", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountEjectFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_eject_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountRemount <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_remount", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountRemountFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_remount_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountOperationGetType <-
function()
{
w <- .RGtkCall("S_g_mount_operation_get_type", PACKAGE = "RGtk2")
return(w)
}
gMountOperationNew <-
function()
{
w <- .RGtkCall("S_g_mount_operation_new", PACKAGE = "RGtk2")
return(w)
}
gMountOperationGetUsername <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_username", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetUsername <-
function(object, username)
{
checkPtrType(object, "GMountOperation")
username <- as.character(username)
w <- .RGtkCall("S_g_mount_operation_set_username", object, username, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationGetPassword <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_password", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetPassword <-
function(object, password)
{
checkPtrType(object, "GMountOperation")
password <- as.character(password)
w <- .RGtkCall("S_g_mount_operation_set_password", object, password, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationGetAnonymous <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_anonymous", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetAnonymous <-
function(object, anonymous)
{
checkPtrType(object, "GMountOperation")
anonymous <- as.logical(anonymous)
w <- .RGtkCall("S_g_mount_operation_set_anonymous", object, anonymous, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationGetDomain <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_domain", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetDomain <-
function(object, domain)
{
checkPtrType(object, "GMountOperation")
domain <- as.character(domain)
w <- .RGtkCall("S_g_mount_operation_set_domain", object, domain, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationGetPasswordSave <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_password_save", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetPasswordSave <-
function(object, save)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_set_password_save", object, save, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationGetChoice <-
function(object)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_get_choice", object, PACKAGE = "RGtk2")
return(w)
}
gMountOperationSetChoice <-
function(object, choice)
{
checkPtrType(object, "GMountOperation")
choice <- as.integer(choice)
w <- .RGtkCall("S_g_mount_operation_set_choice", object, choice, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountOperationReply <-
function(object, result)
{
checkPtrType(object, "GMountOperation")
w <- .RGtkCall("S_g_mount_operation_reply", object, result, PACKAGE = "RGtk2")
return(invisible(w))
}
gNativeVolumeMonitorGetType <-
function()
{
w <- .RGtkCall("S_g_native_volume_monitor_get_type", PACKAGE = "RGtk2")
return(w)
}
gOutputStreamGetType <-
function()
{
w <- .RGtkCall("S_g_output_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gOutputStreamWrite <-
function(object, buffer, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
buffer <- as.list(as.raw(buffer))
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_output_stream_write", object, buffer, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamWriteAll <-
function(object, buffer, bytes.written, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
buffer <- as.list(as.raw(buffer))
bytes.written <- as.list(as.numeric(bytes.written))
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_output_stream_write_all", object, buffer, bytes.written, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamSplice <-
function(object, source, flags = "G_OUTPUT_STREAM_SPLICE_NONE", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
checkPtrType(source, "GInputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_output_stream_splice", object, source, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamFlush <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_output_stream_flush", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamClose <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_output_stream_close", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamWriteAsync <-
function(object, buffer, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GOutputStream")
buffer <- as.list(as.raw(buffer))
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_output_stream_write_async", object, buffer, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(w)
}
gOutputStreamWriteFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_output_stream_write_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamSpliceAsync <-
function(object, source, flags = "G_OUTPUT_STREAM_SPLICE_NONE", io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GOutputStream")
checkPtrType(source, "GInputStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_output_stream_splice_async", object, source, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gOutputStreamSpliceFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_output_stream_splice_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamFlushAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GOutputStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_output_stream_flush_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gOutputStreamFlushFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_output_stream_flush_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamCloseAsync <-
function(object, io.priority = 0, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GOutputStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_output_stream_close_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gOutputStreamCloseFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_output_stream_close_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamIsClosed <-
function(object)
{
checkPtrType(object, "GOutputStream")
w <- .RGtkCall("S_g_output_stream_is_closed", object, PACKAGE = "RGtk2")
return(w)
}
gOutputStreamHasPending <-
function(object)
{
checkPtrType(object, "GOutputStream")
w <- .RGtkCall("S_g_output_stream_has_pending", object, PACKAGE = "RGtk2")
return(w)
}
gOutputStreamSetPending <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GOutputStream")
w <- .RGtkCall("S_g_output_stream_set_pending", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gOutputStreamClearPending <-
function(object)
{
checkPtrType(object, "GOutputStream")
w <- .RGtkCall("S_g_output_stream_clear_pending", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSeekableGetType <-
function()
{
w <- .RGtkCall("S_g_seekable_get_type", PACKAGE = "RGtk2")
return(w)
}
gSeekableTell <-
function(object)
{
checkPtrType(object, "GSeekable")
w <- .RGtkCall("S_g_seekable_tell", object, PACKAGE = "RGtk2")
return(w)
}
gSeekableCanSeek <-
function(object)
{
checkPtrType(object, "GSeekable")
w <- .RGtkCall("S_g_seekable_can_seek", object, PACKAGE = "RGtk2")
return(w)
}
gSeekableSeek <-
function(object, offset, type = "G_SEEK_SET", cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSeekable")
offset <- as.numeric(offset)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_seekable_seek", object, offset, type, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSeekableCanTruncate <-
function(object)
{
checkPtrType(object, "GSeekable")
w <- .RGtkCall("S_g_seekable_can_truncate", object, PACKAGE = "RGtk2")
return(w)
}
gSeekableTruncate <-
function(object, offset, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSeekable")
offset <- as.numeric(offset)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_seekable_truncate", object, offset, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSimpleAsyncResultGetType <-
function()
{
w <- .RGtkCall("S_g_simple_async_result_get_type", PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultNew <-
function(source.object, callback, user.data = NULL, source.tag)
{
checkPtrType(source.object, "GObject")
callback <- as.function(callback)
w <- .RGtkCall("S_g_simple_async_result_new", source.object, callback, user.data, source.tag, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultNewFromError <-
function(source.object, callback, user.data = NULL)
{
checkPtrType(source.object, "GObject")
callback <- as.function(callback)
w <- .RGtkCall("S_g_simple_async_result_new_from_error", source.object, callback, user.data, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultSetOpResGpointer <-
function(object, op.res)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_set_op_res_gpointer", object, op.res, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultGetOpResGpointer <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_get_op_res_gpointer", object, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultSetOpResGssize <-
function(object, op.res)
{
checkPtrType(object, "GSimpleAsyncResult")
op.res <- as.integer(op.res)
w <- .RGtkCall("S_g_simple_async_result_set_op_res_gssize", object, op.res, PACKAGE = "RGtk2")
return(invisible(w))
}
gSimpleAsyncResultGetOpResGssize <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_get_op_res_gssize", object, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultSetOpResGboolean <-
function(object, op.res)
{
checkPtrType(object, "GSimpleAsyncResult")
op.res <- as.logical(op.res)
w <- .RGtkCall("S_g_simple_async_result_set_op_res_gboolean", object, op.res, PACKAGE = "RGtk2")
return(invisible(w))
}
gSimpleAsyncResultGetOpResGboolean <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_get_op_res_gboolean", object, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultGetSourceTag <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_get_source_tag", object, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultSetHandleCancellation <-
function(object, handle.cancellation)
{
checkPtrType(object, "GSimpleAsyncResult")
handle.cancellation <- as.logical(handle.cancellation)
w <- .RGtkCall("S_g_simple_async_result_set_handle_cancellation", object, handle.cancellation, PACKAGE = "RGtk2")
return(invisible(w))
}
gSimpleAsyncResultComplete <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_complete", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSimpleAsyncResultCompleteInIdle <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_complete_in_idle", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSimpleAsyncResultSetFromError <-
function(object)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_set_from_error", object, PACKAGE = "RGtk2")
return(w)
}
gSimpleAsyncResultPropagateError <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSimpleAsyncResult")
w <- .RGtkCall("S_g_simple_async_result_propagate_error", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSimpleAsyncReportGerrorInIdle <-
function(object, callback, user.data = NULL)
{
checkPtrType(object, "GObject")
callback <- as.function(callback)
w <- .RGtkCall("S_g_simple_async_report_gerror_in_idle", object, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gThemedIconGetType <-
function()
{
w <- .RGtkCall("S_g_themed_icon_get_type", PACKAGE = "RGtk2")
return(w)
}
gThemedIconNew <-
function(iconname = NULL)
{
w <- .RGtkCall("S_g_themed_icon_new", iconname, PACKAGE = "RGtk2")
return(w)
}
gThemedIconNewWithDefaultFallbacks <-
function(iconname)
{
iconname <- as.character(iconname)
w <- .RGtkCall("S_g_themed_icon_new_with_default_fallbacks", iconname, PACKAGE = "RGtk2")
return(w)
}
gThemedIconNewFromNames <-
function(iconnames, len)
{
iconnames <- as.list(as.character(iconnames))
len <- as.integer(len)
w <- .RGtkCall("S_g_themed_icon_new_from_names", iconnames, len, PACKAGE = "RGtk2")
return(w)
}
gThemedIconGetNames <-
function(object)
{
checkPtrType(object, "GThemedIcon")
w <- .RGtkCall("S_g_themed_icon_get_names", object, PACKAGE = "RGtk2")
return(w)
}
gThemedIconAppendName <-
function(object, iconname)
{
checkPtrType(object, "GThemedIcon")
iconname <- as.character(iconname)
w <- .RGtkCall("S_g_themed_icon_append_name", object, iconname, PACKAGE = "RGtk2")
return(invisible(w))
}
gVfsGetType <-
function()
{
w <- .RGtkCall("S_g_vfs_get_type", PACKAGE = "RGtk2")
return(w)
}
gVfsIsActive <-
function(object)
{
checkPtrType(object, "GVfs")
w <- .RGtkCall("S_g_vfs_is_active", object, PACKAGE = "RGtk2")
return(w)
}
gVfsGetFileForPath <-
function(object, path)
{
checkPtrType(object, "GVfs")
path <- as.character(path)
w <- .RGtkCall("S_g_vfs_get_file_for_path", object, path, PACKAGE = "RGtk2")
return(w)
}
gVfsGetFileForUri <-
function(object, uri)
{
checkPtrType(object, "GVfs")
uri <- as.character(uri)
w <- .RGtkCall("S_g_vfs_get_file_for_uri", object, uri, PACKAGE = "RGtk2")
return(w)
}
gVfsParseName <-
function(object, parse.name)
{
checkPtrType(object, "GVfs")
parse.name <- as.character(parse.name)
w <- .RGtkCall("S_g_vfs_parse_name", object, parse.name, PACKAGE = "RGtk2")
return(w)
}
gVfsGetDefault <-
function()
{
w <- .RGtkCall("S_g_vfs_get_default", PACKAGE = "RGtk2")
return(w)
}
gVfsGetLocal <-
function()
{
w <- .RGtkCall("S_g_vfs_get_local", PACKAGE = "RGtk2")
return(w)
}
gVfsGetSupportedUriSchemes <-
function(object)
{
checkPtrType(object, "GVfs")
w <- .RGtkCall("S_g_vfs_get_supported_uri_schemes", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetType <-
function()
{
w <- .RGtkCall("S_g_volume_get_type", PACKAGE = "RGtk2")
return(w)
}
gVolumeGetName <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetIcon <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetUuid <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_uuid", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetDrive <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_drive", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetMount <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_mount", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeCanMount <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_can_mount", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeCanEject <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_can_eject", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeShouldAutomount <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_should_automount", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeMount <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GVolume")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_volume_mount", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gVolumeMountFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GVolume")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_volume_mount_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gVolumeEject <-
function(object, flags = "G_MOUNT_UNMOUNT_NONE", cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GVolume")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_volume_eject", object, flags, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gVolumeEjectFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GVolume")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_volume_eject_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gVolumeMonitorGetType <-
function()
{
w <- .RGtkCall("S_g_volume_monitor_get_type", PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGet <-
function()
{
w <- .RGtkCall("S_g_volume_monitor_get", PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGetConnectedDrives <-
function(object)
{
checkPtrType(object, "GVolumeMonitor")
w <- .RGtkCall("S_g_volume_monitor_get_connected_drives", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGetVolumes <-
function(object)
{
checkPtrType(object, "GVolumeMonitor")
w <- .RGtkCall("S_g_volume_monitor_get_volumes", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGetMounts <-
function(object)
{
checkPtrType(object, "GVolumeMonitor")
w <- .RGtkCall("S_g_volume_monitor_get_mounts", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGetVolumeForUuid <-
function(object, uuid)
{
checkPtrType(object, "GVolumeMonitor")
uuid <- as.character(uuid)
w <- .RGtkCall("S_g_volume_monitor_get_volume_for_uuid", object, uuid, PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorGetMountForUuid <-
function(object, uuid)
{
checkPtrType(object, "GVolumeMonitor")
uuid <- as.character(uuid)
w <- .RGtkCall("S_g_volume_monitor_get_mount_for_uuid", object, uuid, PACKAGE = "RGtk2")
return(w)
}
gVolumeMonitorAdoptOrphanMount <-
function(mount)
{
checkPtrType(mount, "GMount")
w <- .RGtkCall("S_g_volume_monitor_adopt_orphan_mount", mount, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointRegister <-
function(name)
{
name <- as.character(name)
w <- .RGtkCall("S_g_io_extension_point_register", name, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointLookup <-
function(name)
{
name <- as.character(name)
w <- .RGtkCall("S_g_io_extension_point_lookup", name, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointSetRequiredType <-
function(object, type)
{
checkPtrType(object, "GIOExtensionPoint")
type <- as.GType(type)
w <- .RGtkCall("S_g_io_extension_point_set_required_type", object, type, PACKAGE = "RGtk2")
return(invisible(w))
}
gIoExtensionPointGetRequiredType <-
function(object)
{
checkPtrType(object, "GIOExtensionPoint")
w <- .RGtkCall("S_g_io_extension_point_get_required_type", object, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointGetExtensions <-
function(object)
{
checkPtrType(object, "GIOExtensionPoint")
w <- .RGtkCall("S_g_io_extension_point_get_extensions", object, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointGetExtensionByName <-
function(object, name)
{
checkPtrType(object, "GIOExtensionPoint")
name <- as.character(name)
w <- .RGtkCall("S_g_io_extension_point_get_extension_by_name", object, name, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionPointImplement <-
function(extension.point.name, type, extension.name, priority)
{
extension.point.name <- as.character(extension.point.name)
type <- as.GType(type)
extension.name <- as.character(extension.name)
priority <- as.integer(priority)
w <- .RGtkCall("S_g_io_extension_point_implement", extension.point.name, type, extension.name, priority, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionGetType <-
function(object)
{
checkPtrType(object, "GIOExtension")
w <- .RGtkCall("S_g_io_extension_get_type", object, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionGetName <-
function(object)
{
checkPtrType(object, "GIOExtension")
w <- .RGtkCall("S_g_io_extension_get_name", object, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionGetPriority <-
function(object)
{
checkPtrType(object, "GIOExtension")
w <- .RGtkCall("S_g_io_extension_get_priority", object, PACKAGE = "RGtk2")
return(w)
}
gIoExtensionRefClass <-
function(object)
{
checkPtrType(object, "GIOExtension")
w <- .RGtkCall("S_g_io_extension_ref_class", object, PACKAGE = "RGtk2")
return(w)
}
gContentTypeFromMimeType <-
function(mime.type)
{
mime.type <- as.character(mime.type)
w <- .RGtkCall("S_g_content_type_from_mime_type", mime.type, PACKAGE = "RGtk2")
return(w)
}
gContentTypeGuessForTree <-
function(root)
{
checkPtrType(root, "GFile")
w <- .RGtkCall("S_g_content_type_guess_for_tree", root, PACKAGE = "RGtk2")
return(w)
}
gEmblemedIconGetType <-
function()
{
w <- .RGtkCall("S_g_emblemed_icon_get_type", PACKAGE = "RGtk2")
return(w)
}
gEmblemedIconNew <-
function(icon, emblem)
{
checkPtrType(icon, "GIcon")
checkPtrType(emblem, "GEmblem")
w <- .RGtkCall("S_g_emblemed_icon_new", icon, emblem, PACKAGE = "RGtk2")
return(w)
}
gEmblemedIconGetIcon <-
function(object)
{
checkPtrType(object, "GEmblemedIcon")
w <- .RGtkCall("S_g_emblemed_icon_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gEmblemedIconGetEmblems <-
function(object)
{
checkPtrType(object, "GEmblemedIcon")
w <- .RGtkCall("S_g_emblemed_icon_get_emblems", object, PACKAGE = "RGtk2")
return(w)
}
gEmblemedIconAddEmblem <-
function(object, emblem)
{
checkPtrType(object, "GEmblemedIcon")
checkPtrType(emblem, "GEmblem")
w <- .RGtkCall("S_g_emblemed_icon_add_emblem", object, emblem, PACKAGE = "RGtk2")
return(invisible(w))
}
gEmblemGetType <-
function()
{
w <- .RGtkCall("S_g_emblem_get_type", PACKAGE = "RGtk2")
return(w)
}
gEmblemNew <-
function(icon = NULL, origin = NULL)
{
w <- .RGtkCall("S_g_emblem_new", icon, origin, PACKAGE = "RGtk2")
return(w)
}
gEmblemNewWithOrigin <-
function(icon, origin)
{
checkPtrType(icon, "GIcon")
w <- .RGtkCall("S_g_emblem_new_with_origin", icon, origin, PACKAGE = "RGtk2")
return(w)
}
gEmblemGetIcon <-
function(object)
{
checkPtrType(object, "GEmblem")
w <- .RGtkCall("S_g_emblem_get_icon", object, PACKAGE = "RGtk2")
return(w)
}
gEmblemGetOrigin <-
function(object)
{
checkPtrType(object, "GEmblem")
w <- .RGtkCall("S_g_emblem_get_origin", object, PACKAGE = "RGtk2")
return(w)
}
gFileQueryFileType <-
function(object, flags, cancellable = NULL)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_query_file_type", object, flags, cancellable, PACKAGE = "RGtk2")
return(w)
}
gFileMakeDirectoryWithParents <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_make_directory_with_parents", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileMonitor <-
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", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMemoryOutputStreamGetDataSize <-
function(object)
{
checkPtrType(object, "GMemoryOutputStream")
w <- .RGtkCall("S_g_memory_output_stream_get_data_size", object, PACKAGE = "RGtk2")
return(w)
}
gMountGuessContentType <-
function(object, force.rescan, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
force.rescan <- as.logical(force.rescan)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_guess_content_type", object, force.rescan, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountGuessContentTypeFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_guess_content_type_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountGuessContentTypeSync <-
function(object, force.rescan, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
force.rescan <- as.logical(force.rescan)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_mount_guess_content_type_sync", object, force.rescan, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gThemedIconPrependName <-
function(object, iconname)
{
checkPtrType(object, "GThemedIcon")
iconname <- as.character(iconname)
w <- .RGtkCall("S_g_themed_icon_prepend_name", object, iconname, PACKAGE = "RGtk2")
return(invisible(w))
}
gVolumeGetIdentifier <-
function(object, kind)
{
checkPtrType(object, "GVolume")
kind <- as.character(kind)
w <- .RGtkCall("S_g_volume_get_identifier", object, kind, PACKAGE = "RGtk2")
return(w)
}
gVolumeEnumerateIdentifiers <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_enumerate_identifiers", object, PACKAGE = "RGtk2")
return(w)
}
gVolumeGetActivationRoot <-
function(object)
{
checkPtrType(object, "GVolume")
w <- .RGtkCall("S_g_volume_get_activation_root", object, PACKAGE = "RGtk2")
return(w)
}
gFileEnumeratorGetContainer <-
function(object)
{
checkPtrType(object, "GFileEnumerator")
w <- .RGtkCall("S_g_file_enumerator_get_container", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoResetTypeAssociations <-
function(content.type)
{
content.type <- as.character(content.type)
w <- .RGtkCall("S_g_app_info_reset_type_associations", content.type, PACKAGE = "RGtk2")
return(w)
}
gAppInfoCanDelete <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_can_delete", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoDelete <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_delete", object, PACKAGE = "RGtk2")
return(w)
}
gAppInfoGetCommandline <-
function(object)
{
checkPtrType(object, "GAppInfo")
w <- .RGtkCall("S_g_app_info_get_commandline", object, PACKAGE = "RGtk2")
return(w)
}
gDataInputStreamReadUntilAsync <-
function(object, stop.chars, io.priority, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDataInputStream")
stop.chars <- as.character(stop.chars)
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_data_input_stream_read_until_async", object, stop.chars, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDataInputStreamReadUntilFinish <-
function(object, result, length, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
checkPtrType(result, "GAsyncResult")
length <- as.list(as.numeric(length))
w <- .RGtkCall("S_g_data_input_stream_read_until_finish", object, result, length, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDataInputStreamReadLineAsync <-
function(object, io.priority, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDataInputStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_data_input_stream_read_line_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDataInputStreamReadLineFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDataInputStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_data_input_stream_read_line_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gIconToString <-
function(object)
{
checkPtrType(object, "GIcon")
w <- .RGtkCall("S_g_icon_to_string", object, PACKAGE = "RGtk2")
return(w)
}
gIconNewForString <-
function(str, .errwarn = TRUE)
{
str <- as.character(str)
w <- .RGtkCall("S_g_icon_new_for_string", str, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountIsShadowed <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_is_shadowed", object, PACKAGE = "RGtk2")
return(w)
}
gMountShadow <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_shadow", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountUnshadow <-
function(object)
{
checkPtrType(object, "GMount")
w <- .RGtkCall("S_g_mount_unshadow", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gFilterInputStreamGetCloseBaseStream <-
function(object)
{
checkPtrType(object, "GFilterInputStream")
w <- .RGtkCall("S_g_filter_input_stream_get_close_base_stream", object, PACKAGE = "RGtk2")
return(w)
}
gFilterInputStreamSetCloseBaseStream <-
function(object, close.base)
{
checkPtrType(object, "GFilterInputStream")
close.base <- as.logical(close.base)
w <- .RGtkCall("S_g_filter_input_stream_set_close_base_stream", object, close.base, PACKAGE = "RGtk2")
return(invisible(w))
}
gFilterOutputStreamGetCloseBaseStream <-
function(object)
{
checkPtrType(object, "GFilterOutputStream")
w <- .RGtkCall("S_g_filter_output_stream_get_close_base_stream", object, PACKAGE = "RGtk2")
return(w)
}
gFilterOutputStreamSetCloseBaseStream <-
function(object, close.base)
{
checkPtrType(object, "GFilterOutputStream")
close.base <- as.logical(close.base)
w <- .RGtkCall("S_g_filter_output_stream_set_close_base_stream", object, close.base, PACKAGE = "RGtk2")
return(invisible(w))
}
gAsyncInitableGetType <-
function()
{
w <- .RGtkCall("S_g_async_initable_get_type", PACKAGE = "RGtk2")
return(w)
}
gAsyncInitableInitAsync <-
function(object, io.priority, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GAsyncInitable")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_async_initable_init_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gAsyncInitableInitFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GAsyncInitable")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_async_initable_init_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gAsyncInitableNewFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GAsyncInitable")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_async_initable_new_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gCancellableDisconnect <-
function(object, handler.id)
{
checkPtrType(object, "GCancellable")
handler.id <- as.numeric(handler.id)
w <- .RGtkCall("S_g_cancellable_disconnect", object, handler.id, PACKAGE = "RGtk2")
return(invisible(w))
}
gCancellableReleaseFd <-
function(object)
{
checkPtrType(object, "GCancellable")
w <- .RGtkCall("S_g_cancellable_release_fd", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gDriveCanStart <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_can_start", object, PACKAGE = "RGtk2")
return(w)
}
gDriveCanStartDegraded <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_can_start_degraded", object, PACKAGE = "RGtk2")
return(w)
}
gDriveCanStop <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_can_stop", object, PACKAGE = "RGtk2")
return(w)
}
gDriveEjectWithOperation <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDrive")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_drive_eject_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDriveEjectWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDrive")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_drive_eject_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDriveGetStartStopType <-
function(object)
{
checkPtrType(object, "GDrive")
w <- .RGtkCall("S_g_drive_get_start_stop_type", object, PACKAGE = "RGtk2")
return(w)
}
gDriveStart <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDrive")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_drive_start", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDriveStartFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDrive")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_drive_start_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gDriveStop <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GDrive")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_drive_stop", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gDriveStopFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GDrive")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_drive_stop_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCreateReadwrite <-
function(object, flags, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_create_readwrite", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileCreateReadwriteAsync <-
function(object, flags, io.priority, 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_readwrite_async", object, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileCreateReadwriteFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_create_readwrite_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileEjectMountableWithOperation <-
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_eject_mountable_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileEjectMountableWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_eject_mountable_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileOpenReadwrite <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_open_readwrite", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileOpenReadwriteAsync <-
function(object, io.priority, 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_open_readwrite_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileOpenReadwriteFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_open_readwrite_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFilePollMountable <-
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_poll_mountable", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFilePollMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_poll_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplaceReadwrite <-
function(object, etag, make.backup, flags, 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_readwrite", object, etag, make.backup, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileReplaceReadwriteAsync <-
function(object, etag, make.backup, flags, io.priority, 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_readwrite_async", object, etag, make.backup, flags, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileReplaceReadwriteFinish <-
function(object, res, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(res, "GAsyncResult")
w <- .RGtkCall("S_g_file_replace_readwrite_finish", object, res, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileStartMountable <-
function(object, flags, start.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFile")
checkPtrType(start.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_file_start_mountable", object, flags, start.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileStartMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_start_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileStopMountable <-
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_stop_mountable", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileStopMountableFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_stop_mountable_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileSupportsThreadContexts <-
function(object)
{
checkPtrType(object, "GFile")
w <- .RGtkCall("S_g_file_supports_thread_contexts", object, PACKAGE = "RGtk2")
return(w)
}
gFileUnmountMountableWithOperation <-
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_unmount_mountable_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileUnmountMountableWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFile")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_unmount_mountable_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileInfoHasNamespace <-
function(object, name.space)
{
checkPtrType(object, "GFileInfo")
name.space <- as.character(name.space)
w <- .RGtkCall("S_g_file_info_has_namespace", object, name.space, PACKAGE = "RGtk2")
return(w)
}
gFileInfoSetAttributeStatus <-
function(object, attribute, status)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_set_attribute_status", object, attribute, status, PACKAGE = "RGtk2")
return(w)
}
gFileInfoGetAttributeStringv <-
function(object, attribute)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
w <- .RGtkCall("S_g_file_info_get_attribute_stringv", object, attribute, PACKAGE = "RGtk2")
return(w)
}
gFileInfoSetAttributeStringv <-
function(object, attribute, attr.value)
{
checkPtrType(object, "GFileInfo")
attribute <- as.character(attribute)
attr.value <- as.list(as.character(attr.value))
w <- .RGtkCall("S_g_file_info_set_attribute_stringv", object, attribute, attr.value, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileIOStreamGetType <-
function()
{
w <- .RGtkCall("S_g_file_io_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gFileIOStreamQueryInfo <-
function(object, attributes, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GFileIOStream")
attributes <- as.character(attributes)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_file_io_stream_query_info", object, attributes, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileIOStreamQueryInfoAsync <-
function(object, attributes, io.priority, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GFileIOStream")
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_io_stream_query_info_async", object, attributes, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gFileIOStreamQueryInfoFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GFileIOStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_file_io_stream_query_info_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gFileIOStreamGetEtag <-
function(object)
{
checkPtrType(object, "GFileIOStream")
w <- .RGtkCall("S_g_file_io_stream_get_etag", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetType <-
function()
{
w <- .RGtkCall("S_g_inet_address_get_type", PACKAGE = "RGtk2")
return(w)
}
gInetAddressNewFromString <-
function(string)
{
string <- as.character(string)
w <- .RGtkCall("S_g_inet_address_new_from_string", string, PACKAGE = "RGtk2")
return(w)
}
gInetAddressNewFromBytes <-
function(bytes, family)
{
bytes <- as.list(as.raw(bytes))
w <- .RGtkCall("S_g_inet_address_new_from_bytes", bytes, family, PACKAGE = "RGtk2")
return(w)
}
gInetAddressNewLoopback <-
function(family)
{
w <- .RGtkCall("S_g_inet_address_new_loopback", family, PACKAGE = "RGtk2")
return(w)
}
gInetAddressNewAny <-
function(family)
{
w <- .RGtkCall("S_g_inet_address_new_any", family, PACKAGE = "RGtk2")
return(w)
}
gInetAddressToString <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_to_string", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressToBytes <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_to_bytes", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetNativeSize <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_native_size", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetFamily <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_family", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsAny <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_any", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsLoopback <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_loopback", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsLinkLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_link_local", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsSiteLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_site_local", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMulticast <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_multicast", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMcGlobal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_mc_global", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMcLinkLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_mc_link_local", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMcNodeLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_mc_node_local", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMcOrgLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_mc_org_local", object, PACKAGE = "RGtk2")
return(w)
}
gInetAddressGetIsMcSiteLocal <-
function(object)
{
checkPtrType(object, "GInetAddress")
w <- .RGtkCall("S_g_inet_address_get_is_mc_site_local", object, PACKAGE = "RGtk2")
return(w)
}
gInitableGetType <-
function()
{
w <- .RGtkCall("S_g_initable_get_type", PACKAGE = "RGtk2")
return(w)
}
gInitableInit <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GInitable")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_initable_init", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gIOStreamGetType <-
function()
{
w <- .RGtkCall("S_g_io_stream_get_type", PACKAGE = "RGtk2")
return(w)
}
gIOStreamGetInputStream <-
function(object)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_get_input_stream", object, PACKAGE = "RGtk2")
return(w)
}
gIOStreamGetOutputStream <-
function(object)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_get_output_stream", object, PACKAGE = "RGtk2")
return(w)
}
gIOStreamClose <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GIOStream")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_io_stream_close", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gIOStreamCloseAsync <-
function(object, io.priority, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GIOStream")
io.priority <- as.integer(io.priority)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_io_stream_close_async", object, io.priority, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gIOStreamCloseFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GIOStream")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_io_stream_close_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gIOStreamIsClosed <-
function(object)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_is_closed", object, PACKAGE = "RGtk2")
return(w)
}
gIOStreamHasPending <-
function(object)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_has_pending", object, PACKAGE = "RGtk2")
return(w)
}
gIOStreamSetPending <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_set_pending", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gIOStreamClearPending <-
function(object)
{
checkPtrType(object, "GIOStream")
w <- .RGtkCall("S_g_io_stream_clear_pending", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountUnmountWithOperation <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_unmount_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountUnmountWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_unmount_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gMountEjectWithOperation <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GMount")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_mount_eject_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gMountEjectWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GMount")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_mount_eject_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gNetworkAddressGetType <-
function()
{
w <- .RGtkCall("S_g_network_address_get_type", PACKAGE = "RGtk2")
return(w)
}
gNetworkAddressNew <-
function(hostname, port)
{
hostname <- as.character(hostname)
port <- as.integer(port)
w <- .RGtkCall("S_g_network_address_new", hostname, port, PACKAGE = "RGtk2")
return(w)
}
gNetworkAddressParse <-
function(host.and.port, default.port, .errwarn = TRUE)
{
host.and.port <- as.character(host.and.port)
default.port <- as.integer(default.port)
w <- .RGtkCall("S_g_network_address_parse", host.and.port, default.port, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gNetworkAddressGetHostname <-
function(object)
{
checkPtrType(object, "GNetworkAddress")
w <- .RGtkCall("S_g_network_address_get_hostname", object, PACKAGE = "RGtk2")
return(w)
}
gNetworkAddressGetPort <-
function(object)
{
checkPtrType(object, "GNetworkAddress")
w <- .RGtkCall("S_g_network_address_get_port", object, PACKAGE = "RGtk2")
return(w)
}
gNetworkServiceGetType <-
function()
{
w <- .RGtkCall("S_g_network_service_get_type", PACKAGE = "RGtk2")
return(w)
}
gNetworkServiceNew <-
function(service, protocol, domain)
{
service <- as.character(service)
protocol <- as.character(protocol)
domain <- as.character(domain)
w <- .RGtkCall("S_g_network_service_new", service, protocol, domain, PACKAGE = "RGtk2")
return(w)
}
gNetworkServiceGetService <-
function(object)
{
checkPtrType(object, "GNetworkService")
w <- .RGtkCall("S_g_network_service_get_service", object, PACKAGE = "RGtk2")
return(w)
}
gNetworkServiceGetProtocol <-
function(object)
{
checkPtrType(object, "GNetworkService")
w <- .RGtkCall("S_g_network_service_get_protocol", object, PACKAGE = "RGtk2")
return(w)
}
gNetworkServiceGetDomain <-
function(object)
{
checkPtrType(object, "GNetworkService")
w <- .RGtkCall("S_g_network_service_get_domain", object, PACKAGE = "RGtk2")
return(w)
}
gResolverGetType <-
function()
{
w <- .RGtkCall("S_g_resolver_get_type", PACKAGE = "RGtk2")
return(w)
}
gResolverGetDefault <-
function()
{
w <- .RGtkCall("S_g_resolver_get_default", PACKAGE = "RGtk2")
return(w)
}
gResolverSetDefault <-
function(object)
{
checkPtrType(object, "GResolver")
w <- .RGtkCall("S_g_resolver_set_default", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gResolverLookupByName <-
function(object, hostname, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
hostname <- as.character(hostname)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_resolver_lookup_by_name", object, hostname, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverLookupByNameAsync <-
function(object, hostname, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GResolver")
hostname <- as.character(hostname)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_resolver_lookup_by_name_async", object, hostname, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gResolverLookupByNameFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_resolver_lookup_by_name_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverFreeAddresses <-
function(addresses)
{
addresses <- as.GList(addresses)
w <- .RGtkCall("S_g_resolver_free_addresses", addresses, PACKAGE = "RGtk2")
return(w)
}
gResolverLookupByAddress <-
function(object, address, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
checkPtrType(address, "GInetAddress")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_resolver_lookup_by_address", object, address, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverLookupByAddressAsync <-
function(object, address, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GResolver")
checkPtrType(address, "GInetAddress")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_resolver_lookup_by_address_async", object, address, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gResolverLookupByAddressFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_resolver_lookup_by_address_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverLookupService <-
function(object, service, protocol, domain, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
service <- as.character(service)
protocol <- as.character(protocol)
domain <- as.character(domain)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_resolver_lookup_service", object, service, protocol, domain, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverLookupServiceAsync <-
function(object, service, protocol, domain, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GResolver")
service <- as.character(service)
protocol <- as.character(protocol)
domain <- as.character(domain)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_resolver_lookup_service_async", object, service, protocol, domain, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gResolverLookupServiceFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GResolver")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_resolver_lookup_service_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gResolverFreeTargets <-
function(targets)
{
targets <- as.GList(targets)
w <- .RGtkCall("S_g_resolver_free_targets", targets, PACKAGE = "RGtk2")
return(w)
}
gResolverErrorQuark <-
function()
{
w <- .RGtkCall("S_g_resolver_error_quark", PACKAGE = "RGtk2")
return(w)
}
gSocketAddressEnumeratorGetType <-
function()
{
w <- .RGtkCall("S_g_socket_address_enumerator_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketAddressEnumeratorNext <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketAddressEnumerator")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_address_enumerator_next", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketAddressEnumeratorNextAsync <-
function(object, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketAddressEnumerator")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_address_enumerator_next_async", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketAddressEnumeratorNextFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketAddressEnumerator")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_address_enumerator_next_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketAddressGetType <-
function()
{
w <- .RGtkCall("S_g_socket_address_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketAddressGetFamily <-
function(object)
{
checkPtrType(object, "GSocketAddress")
w <- .RGtkCall("S_g_socket_address_get_family", object, PACKAGE = "RGtk2")
return(w)
}
gSocketAddressNewFromNative <-
function(native, len)
{
len <- as.numeric(len)
w <- .RGtkCall("S_g_socket_address_new_from_native", native, len, PACKAGE = "RGtk2")
return(w)
}
gSocketAddressToNative <-
function(object, dest, destlen, .errwarn = TRUE)
{
checkPtrType(object, "GSocketAddress")
destlen <- as.numeric(destlen)
w <- .RGtkCall("S_g_socket_address_to_native", object, dest, destlen, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketAddressGetNativeSize <-
function(object)
{
checkPtrType(object, "GSocketAddress")
w <- .RGtkCall("S_g_socket_address_get_native_size", object, PACKAGE = "RGtk2")
return(w)
}
gSocketClientGetType <-
function()
{
w <- .RGtkCall("S_g_socket_client_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketClientNew <-
function()
{
w <- .RGtkCall("S_g_socket_client_new", PACKAGE = "RGtk2")
return(w)
}
gSocketClientGetFamily <-
function(object)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_get_family", object, PACKAGE = "RGtk2")
return(w)
}
gSocketClientSetFamily <-
function(object, family)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_set_family", object, family, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientGetSocketType <-
function(object)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_get_socket_type", object, PACKAGE = "RGtk2")
return(w)
}
gSocketClientSetSocketType <-
function(object, type)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_set_socket_type", object, type, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientGetProtocol <-
function(object)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_get_protocol", object, PACKAGE = "RGtk2")
return(w)
}
gSocketClientSetProtocol <-
function(object, protocol)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_set_protocol", object, protocol, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientGetLocalAddress <-
function(object)
{
checkPtrType(object, "GSocketClient")
w <- .RGtkCall("S_g_socket_client_get_local_address", object, PACKAGE = "RGtk2")
return(w)
}
gSocketClientSetLocalAddress <-
function(object, address)
{
checkPtrType(object, "GSocketClient")
checkPtrType(address, "GSocketAddress")
w <- .RGtkCall("S_g_socket_client_set_local_address", object, address, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientConnect <-
function(object, connectable, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
checkPtrType(connectable, "GSocketConnectable")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_client_connect", object, connectable, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClientConnectToHost <-
function(object, host.and.port, default.port, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
host.and.port <- as.character(host.and.port)
default.port <- as.integer(default.port)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_client_connect_to_host", object, host.and.port, default.port, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClientConnectToService <-
function(object, domain, service, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
domain <- as.character(domain)
service <- as.character(service)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_client_connect_to_service", object, domain, service, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClientConnectAsync <-
function(object, connectable, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketClient")
checkPtrType(connectable, "GSocketConnectable")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_client_connect_async", object, connectable, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientConnectFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_client_connect_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClientConnectToHostAsync <-
function(object, host.and.port, default.port, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketClient")
host.and.port <- as.character(host.and.port)
default.port <- as.integer(default.port)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_client_connect_to_host_async", object, host.and.port, default.port, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientConnectToHostFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_client_connect_to_host_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClientConnectToServiceAsync <-
function(object, domain, service, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketClient")
domain <- as.character(domain)
service <- as.character(service)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_client_connect_to_service_async", object, domain, service, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketClientConnectToServiceFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketClient")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_client_connect_to_service_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketConnectableGetType <-
function()
{
w <- .RGtkCall("S_g_socket_connectable_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketConnectableEnumerate <-
function(object)
{
checkPtrType(object, "GSocketConnectable")
w <- .RGtkCall("S_g_socket_connectable_enumerate", object, PACKAGE = "RGtk2")
return(w)
}
gSocketConnectionGetType <-
function()
{
w <- .RGtkCall("S_g_socket_connection_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketConnectionGetSocket <-
function(object)
{
checkPtrType(object, "GSocketConnection")
w <- .RGtkCall("S_g_socket_connection_get_socket", object, PACKAGE = "RGtk2")
return(w)
}
gSocketConnectionGetLocalAddress <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocketConnection")
w <- .RGtkCall("S_g_socket_connection_get_local_address", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketConnectionGetRemoteAddress <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocketConnection")
w <- .RGtkCall("S_g_socket_connection_get_remote_address", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketConnectionFactoryRegisterType <-
function(g.type, family, type, protocol)
{
g.type <- as.GType(g.type)
protocol <- as.integer(protocol)
w <- .RGtkCall("S_g_socket_connection_factory_register_type", g.type, family, type, protocol, PACKAGE = "RGtk2")
return(w)
}
gSocketConnectionFactoryLookupType <-
function(family, type, protocol.id)
{
protocol.id <- as.integer(protocol.id)
w <- .RGtkCall("S_g_socket_connection_factory_lookup_type", family, type, protocol.id, PACKAGE = "RGtk2")
return(w)
}
gSocketConnectionFactoryCreateConnection <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_connection_factory_create_connection", object, PACKAGE = "RGtk2")
return(w)
}
gSocketControlMessageGetType <-
function()
{
w <- .RGtkCall("S_g_socket_control_message_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketControlMessageGetSize <-
function(object)
{
checkPtrType(object, "GSocketControlMessage")
w <- .RGtkCall("S_g_socket_control_message_get_size", object, PACKAGE = "RGtk2")
return(w)
}
gSocketControlMessageGetLevel <-
function(object)
{
checkPtrType(object, "GSocketControlMessage")
w <- .RGtkCall("S_g_socket_control_message_get_level", object, PACKAGE = "RGtk2")
return(w)
}
gSocketControlMessageGetMsgType <-
function(object)
{
checkPtrType(object, "GSocketControlMessage")
w <- .RGtkCall("S_g_socket_control_message_get_msg_type", object, PACKAGE = "RGtk2")
return(w)
}
gSocketControlMessageSerialize <-
function(object, data)
{
checkPtrType(object, "GSocketControlMessage")
w <- .RGtkCall("S_g_socket_control_message_serialize", object, data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketControlMessageDeserialize <-
function(level, type, size, data)
{
level <- as.integer(level)
type <- as.integer(type)
size <- as.numeric(size)
w <- .RGtkCall("S_g_socket_control_message_deserialize", level, type, size, data, PACKAGE = "RGtk2")
return(w)
}
gSocketGetType <-
function()
{
w <- .RGtkCall("S_g_socket_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketNew <-
function(family, type, protocol, .errwarn = TRUE)
{
w <- .RGtkCall("S_g_socket_new", family, type, protocol, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketNewFromFd <-
function(fd, .errwarn = TRUE)
{
fd <- as.integer(fd)
w <- .RGtkCall("S_g_socket_new_from_fd", fd, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketGetFd <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_fd", object, PACKAGE = "RGtk2")
return(w)
}
gSocketGetFamily <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_family", object, PACKAGE = "RGtk2")
return(w)
}
gSocketGetSocketType <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_socket_type", object, PACKAGE = "RGtk2")
return(w)
}
gSocketGetProtocol <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_protocol", object, PACKAGE = "RGtk2")
return(w)
}
gSocketGetLocalAddress <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_local_address", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketGetRemoteAddress <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_remote_address", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketSetBlocking <-
function(object, blocking)
{
checkPtrType(object, "GSocket")
blocking <- as.logical(blocking)
w <- .RGtkCall("S_g_socket_set_blocking", object, blocking, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketGetBlocking <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_blocking", object, PACKAGE = "RGtk2")
return(w)
}
gSocketSetKeepalive <-
function(object, keepalive)
{
checkPtrType(object, "GSocket")
keepalive <- as.logical(keepalive)
w <- .RGtkCall("S_g_socket_set_keepalive", object, keepalive, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketGetKeepalive <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_keepalive", object, PACKAGE = "RGtk2")
return(w)
}
gSocketGetListenBacklog <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_get_listen_backlog", object, PACKAGE = "RGtk2")
return(w)
}
gSocketSetListenBacklog <-
function(object, backlog)
{
checkPtrType(object, "GSocket")
backlog <- as.integer(backlog)
w <- .RGtkCall("S_g_socket_set_listen_backlog", object, backlog, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketIsConnected <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_is_connected", object, PACKAGE = "RGtk2")
return(w)
}
gSocketBind <-
function(object, address, allow.reuse, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
checkPtrType(address, "GSocketAddress")
allow.reuse <- as.logical(allow.reuse)
w <- .RGtkCall("S_g_socket_bind", object, address, allow.reuse, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketConnect <-
function(object, address, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
checkPtrType(address, "GSocketAddress")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_connect", object, address, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketCheckConnectResult <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_check_connect_result", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketConditionCheck <-
function(object, condition)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_condition_check", object, condition, PACKAGE = "RGtk2")
return(w)
}
gSocketConditionWait <-
function(object, condition, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_condition_wait", object, condition, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketAccept <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_accept", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListen <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_listen", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketReceive <-
function(object, size, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
size <- as.numeric(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_receive", object, size, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketReceiveFrom <-
function(object, size, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
size <- as.numeric(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_receive_from", object, size, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketSend <-
function(object, buffer, size, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
buffer <- as.character(buffer)
size <- as.numeric(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_send", object, buffer, size, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketSendTo <-
function(object, address, buffer, size, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
checkPtrType(address, "GSocketAddress")
buffer <- as.character(buffer)
size <- as.numeric(size)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_send_to", object, address, buffer, size, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketReceiveMessage <-
function(object, flags = 0, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
flags <- as.list(as.integer(flags))
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_receive_message", object, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketSendMessage <-
function(object, address, vectors, messages = NULL, flags = 0, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
checkPtrType(address, "GSocketAddress")
vectors <- lapply(vectors, function(x) { checkPtrType(x, "GOutputVector"); x })
messages <- lapply(messages, function(x) { checkPtrType(x, "GSocketControlMessage"); x })
flags <- as.integer(flags)
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_send_message", object, address, vectors, messages, flags, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketClose <-
function(object, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_close", object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketShutdown <-
function(object, shutdown.read, shutdown.write, .errwarn = TRUE)
{
checkPtrType(object, "GSocket")
shutdown.read <- as.logical(shutdown.read)
shutdown.write <- as.logical(shutdown.write)
w <- .RGtkCall("S_g_socket_shutdown", object, shutdown.read, shutdown.write, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketIsClosed <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_is_closed", object, PACKAGE = "RGtk2")
return(w)
}
gSocketCreateSource <-
function(object, condition, cancellable = NULL)
{
checkPtrType(object, "GSocket")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_create_source", object, condition, cancellable, PACKAGE = "RGtk2")
return(w)
}
gSocketSpeaksIpv4 <-
function(object)
{
checkPtrType(object, "GSocket")
w <- .RGtkCall("S_g_socket_speaks_ipv4", object, PACKAGE = "RGtk2")
return(w)
}
gSocketListenerGetType <-
function()
{
w <- .RGtkCall("S_g_socket_listener_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketListenerNew <-
function()
{
w <- .RGtkCall("S_g_socket_listener_new", PACKAGE = "RGtk2")
return(w)
}
gSocketListenerSetBacklog <-
function(object, listen.backlog)
{
checkPtrType(object, "GSocketListener")
listen.backlog <- as.integer(listen.backlog)
w <- .RGtkCall("S_g_socket_listener_set_backlog", object, listen.backlog, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketListenerAddSocket <-
function(object, socket, source.object, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
checkPtrType(socket, "GSocket")
checkPtrType(source.object, "GObject")
w <- .RGtkCall("S_g_socket_listener_add_socket", object, socket, source.object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAddAddress <-
function(object, address, type, protocol, source.object = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
checkPtrType(address, "GSocketAddress")
if (!is.null( source.object )) checkPtrType(source.object, "GObject")
w <- .RGtkCall("S_g_socket_listener_add_address", object, address, type, protocol, source.object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAddInetPort <-
function(object, port, source.object, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
port <- as.integer(port)
checkPtrType(source.object, "GObject")
w <- .RGtkCall("S_g_socket_listener_add_inet_port", object, port, source.object, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAcceptSocket <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_listener_accept_socket", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAcceptSocketAsync <-
function(object, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketListener")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_listener_accept_socket_async", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketListenerAcceptSocketFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_listener_accept_socket_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAccept <-
function(object, cancellable = NULL, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
w <- .RGtkCall("S_g_socket_listener_accept", object, cancellable, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerAcceptAsync <-
function(object, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GSocketListener")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_socket_listener_accept_async", object, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketListenerAcceptFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GSocketListener")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_socket_listener_accept_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gSocketListenerClose <-
function(object)
{
checkPtrType(object, "GSocketListener")
w <- .RGtkCall("S_g_socket_listener_close", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketServiceGetType <-
function()
{
w <- .RGtkCall("S_g_socket_service_get_type", PACKAGE = "RGtk2")
return(w)
}
gSocketServiceNew <-
function()
{
w <- .RGtkCall("S_g_socket_service_new", PACKAGE = "RGtk2")
return(w)
}
gSocketServiceStart <-
function(object)
{
checkPtrType(object, "GSocketService")
w <- .RGtkCall("S_g_socket_service_start", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketServiceStop <-
function(object)
{
checkPtrType(object, "GSocketService")
w <- .RGtkCall("S_g_socket_service_stop", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSocketServiceIsActive <-
function(object)
{
checkPtrType(object, "GSocketService")
w <- .RGtkCall("S_g_socket_service_is_active", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetGetType <-
function()
{
w <- .RGtkCall("S_g_srv_target_get_type", PACKAGE = "RGtk2")
return(w)
}
gSrvTargetNew <-
function(hostname, port, priority, weight)
{
hostname <- as.character(hostname)
port <- as.integer(port)
priority <- as.integer(priority)
weight <- as.integer(weight)
w <- .RGtkCall("S_g_srv_target_new", hostname, port, priority, weight, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetCopy <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_copy", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetFree <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_free", object, PACKAGE = "RGtk2")
return(invisible(w))
}
gSrvTargetGetHostname <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_get_hostname", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetGetPort <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_get_port", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetGetPriority <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_get_priority", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetGetWeight <-
function(object)
{
checkPtrType(object, "GSrvTarget")
w <- .RGtkCall("S_g_srv_target_get_weight", object, PACKAGE = "RGtk2")
return(w)
}
gSrvTargetListSort <-
function(targets)
{
targets <- as.GList(targets)
w <- .RGtkCall("S_g_srv_target_list_sort", targets, PACKAGE = "RGtk2")
return(w)
}
gThreadedSocketServiceGetType <-
function()
{
w <- .RGtkCall("S_g_threaded_socket_service_get_type", PACKAGE = "RGtk2")
return(w)
}
gThreadedSocketServiceNew <-
function(max.threads)
{
max.threads <- as.integer(max.threads)
w <- .RGtkCall("S_g_threaded_socket_service_new", max.threads, PACKAGE = "RGtk2")
return(w)
}
gVolumeEjectWithOperation <-
function(object, flags, mount.operation, cancellable = NULL, callback, user.data = NULL)
{
checkPtrType(object, "GVolume")
checkPtrType(mount.operation, "GMountOperation")
if (!is.null( cancellable )) checkPtrType(cancellable, "GCancellable")
callback <- as.function(callback)
w <- .RGtkCall("S_g_volume_eject_with_operation", object, flags, mount.operation, cancellable, callback, user.data, PACKAGE = "RGtk2")
return(invisible(w))
}
gVolumeEjectWithOperationFinish <-
function(object, result, .errwarn = TRUE)
{
checkPtrType(object, "GVolume")
checkPtrType(result, "GAsyncResult")
w <- .RGtkCall("S_g_volume_eject_with_operation_finish", object, result, PACKAGE = "RGtk2")
w <- handleError(w, .errwarn)
return(w)
}
gInetSocketAddressNew <-
function(address, port)
{
checkPtrType(address, "GInetAddress")
port <- as.integer(port)
w <- .RGtkCall("S_g_inet_socket_address_new", address, port, PACKAGE = "RGtk2")
return(w)
}
gInetSocketAddressGetAddress <-
function(object)
{
checkPtrType(object, "GInetSocketAddress")
w <- .RGtkCall("S_g_inet_socket_address_get_address", object, PACKAGE = "RGtk2")
return(w)
}
gInetSocketAddressGetPort <-
function(object)
{
checkPtrType(object, "GInetSocketAddress")
w <- .RGtkCall("S_g_inet_socket_address_get_port", object, PACKAGE = "RGtk2")
return(w)
}
gTcpConnectionGetType <-
function()
{
w <- .RGtkCall("S_g_tcp_connection_get_type", PACKAGE = "RGtk2")
return(w)
}
gTcpConnectionSetGracefulDisconnect <-
function(object, graceful.disconnect)
{
checkPtrType(object, "GTcpConnection")
graceful.disconnect <- as.logical(graceful.disconnect)
w <- .RGtkCall("S_g_tcp_connection_set_graceful_disconnect", object, graceful.disconnect, PACKAGE = "RGtk2")
return(invisible(w))
}
gTcpConnectionGetGracefulDisconnect <-
function(object)
{
checkPtrType(object, "GTcpConnection")
w <- .RGtkCall("S_g_tcp_connection_get_graceful_disconnect", object, PACKAGE = "RGtk2")
return(w)
}
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.