R/gioFuncs.R

Defines functions gSocketSendTo gSocketSend gSocketReceiveFrom gSocketReceive gSocketListen gSocketAccept gSocketConditionWait gSocketConditionCheck gSocketCheckConnectResult gSocketConnect gSocketBind gSocketIsConnected gSocketSetListenBacklog gSocketGetListenBacklog gSocketGetKeepalive gSocketSetKeepalive gSocketGetBlocking gSocketSetBlocking gSocketGetRemoteAddress gSocketGetLocalAddress gSocketGetProtocol gSocketGetSocketType gSocketGetFamily gSocketGetFd gSocketNewFromFd gSocketNew gSocketGetType gSocketControlMessageDeserialize gSocketControlMessageSerialize gSocketControlMessageGetMsgType gSocketControlMessageGetLevel gSocketControlMessageGetSize gSocketControlMessageGetType gSocketConnectionFactoryCreateConnection gSocketConnectionFactoryLookupType gSocketConnectionFactoryRegisterType gSocketConnectionGetRemoteAddress gSocketConnectionGetLocalAddress gSocketConnectionGetSocket gSocketConnectionGetType gSocketConnectableEnumerate gSocketConnectableGetType gSocketClientConnectToServiceFinish gSocketClientConnectToServiceAsync gSocketClientConnectToHostFinish gSocketClientConnectToHostAsync gSocketClientConnectFinish gSocketClientConnectAsync gSocketClientConnectToService gSocketClientConnectToHost gSocketClientConnect gSocketClientSetLocalAddress gSocketClientGetLocalAddress gSocketClientSetProtocol gSocketClientGetProtocol gSocketClientSetSocketType gSocketClientGetSocketType gSocketClientSetFamily gSocketClientGetFamily gSocketClientNew gSocketClientGetType gSocketAddressGetNativeSize gSocketAddressToNative gSocketAddressNewFromNative gSocketAddressGetFamily gSocketAddressGetType gSocketAddressEnumeratorNextFinish gSocketAddressEnumeratorNextAsync gSocketAddressEnumeratorNext gSocketAddressEnumeratorGetType gResolverErrorQuark gResolverFreeTargets gResolverLookupServiceFinish gResolverLookupServiceAsync gResolverLookupService gResolverLookupByAddressFinish gResolverLookupByAddressAsync gResolverLookupByAddress gResolverFreeAddresses gResolverLookupByNameFinish gResolverLookupByNameAsync gResolverLookupByName gResolverSetDefault gResolverGetDefault gResolverGetType gNetworkServiceGetDomain gNetworkServiceGetProtocol gNetworkServiceGetService gNetworkServiceNew gNetworkServiceGetType gNetworkAddressGetPort gNetworkAddressGetHostname gNetworkAddressParse gNetworkAddressNew gNetworkAddressGetType gMountEjectWithOperationFinish gMountEjectWithOperation gMountUnmountWithOperationFinish gMountUnmountWithOperation gIOStreamClearPending gIOStreamSetPending gIOStreamHasPending gIOStreamIsClosed gIOStreamCloseFinish gIOStreamCloseAsync gIOStreamClose gIOStreamGetOutputStream gIOStreamGetInputStream gIOStreamGetType gInitableInit gInitableGetType gInetAddressGetIsMcSiteLocal gInetAddressGetIsMcOrgLocal gInetAddressGetIsMcNodeLocal gInetAddressGetIsMcLinkLocal gInetAddressGetIsMcGlobal gInetAddressGetIsMulticast gInetAddressGetIsSiteLocal gInetAddressGetIsLinkLocal gInetAddressGetIsLoopback gInetAddressGetIsAny gInetAddressGetFamily gInetAddressGetNativeSize gInetAddressToBytes gInetAddressToString gInetAddressNewAny gInetAddressNewLoopback gInetAddressNewFromBytes gInetAddressNewFromString gInetAddressGetType gFileIOStreamGetEtag gFileIOStreamQueryInfoFinish gFileIOStreamQueryInfoAsync gFileIOStreamQueryInfo gFileIOStreamGetType gFileInfoSetAttributeStringv gFileInfoGetAttributeStringv gFileInfoSetAttributeStatus gFileInfoHasNamespace gFileUnmountMountableWithOperationFinish gFileUnmountMountableWithOperation gFileSupportsThreadContexts gFileStopMountableFinish gFileStopMountable gFileStartMountableFinish gFileStartMountable gFileReplaceReadwriteFinish gFileReplaceReadwriteAsync gFileReplaceReadwrite gFilePollMountableFinish gFilePollMountable gFileOpenReadwriteFinish gFileOpenReadwriteAsync gFileOpenReadwrite gFileEjectMountableWithOperationFinish gFileEjectMountableWithOperation gFileCreateReadwriteFinish gFileCreateReadwriteAsync gFileCreateReadwrite gDriveStopFinish gDriveStop gDriveStartFinish gDriveStart gDriveGetStartStopType gDriveEjectWithOperationFinish gDriveEjectWithOperation gDriveCanStop gDriveCanStartDegraded gDriveCanStart gCancellableReleaseFd gCancellableDisconnect gAsyncInitableNewFinish gAsyncInitableInitFinish gAsyncInitableInitAsync gAsyncInitableGetType gFilterOutputStreamSetCloseBaseStream gFilterOutputStreamGetCloseBaseStream gFilterInputStreamSetCloseBaseStream gFilterInputStreamGetCloseBaseStream gMountUnshadow gMountShadow gMountIsShadowed gIconNewForString gIconToString gDataInputStreamReadLineFinish gDataInputStreamReadLineAsync gDataInputStreamReadUntilFinish gDataInputStreamReadUntilAsync gAppInfoGetCommandline gAppInfoDelete gAppInfoCanDelete gAppInfoResetTypeAssociations gFileEnumeratorGetContainer gVolumeGetActivationRoot gVolumeEnumerateIdentifiers gVolumeGetIdentifier gThemedIconPrependName gMountGuessContentTypeSync gMountGuessContentTypeFinish gMountGuessContentType gMemoryOutputStreamGetDataSize gFileMonitor gFileMakeDirectoryWithParents gFileQueryFileType gEmblemGetOrigin gEmblemGetIcon gEmblemNewWithOrigin gEmblemNew gEmblemGetType gEmblemedIconAddEmblem gEmblemedIconGetEmblems gEmblemedIconGetIcon gEmblemedIconNew gEmblemedIconGetType gContentTypeGuessForTree gContentTypeFromMimeType gSeekableTell gSeekableGetType gOutputStreamClearPending gOutputStreamSetPending gOutputStreamHasPending gOutputStreamIsClosed gOutputStreamCloseFinish gOutputStreamCloseAsync gOutputStreamFlushFinish gOutputStreamFlushAsync gOutputStreamSpliceFinish gOutputStreamSpliceAsync gOutputStreamWriteFinish gOutputStreamWriteAsync gOutputStreamClose gOutputStreamFlush gOutputStreamSplice gOutputStreamWriteAll gOutputStreamWrite gOutputStreamGetType gNativeVolumeMonitorGetType gMountOperationReply gMountOperationSetChoice gMountOperationGetChoice gMountOperationSetPasswordSave gMountOperationGetPasswordSave gMountOperationSetDomain gMountOperationGetDomain gMountOperationSetAnonymous gMountOperationGetAnonymous gMountOperationSetPassword gMountOperationGetPassword gMountOperationSetUsername gMountOperationGetUsername gMountOperationNew gMountOperationGetType gMountRemountFinish gMountRemount gMountEjectFinish gMountEject gMountUnmountFinish gMountUnmount gMountCanEject gMountCanUnmount gMountGetDrive gMountGetVolume gMountGetUuid gMountGetIcon gMountGetName gMountGetRoot gMountGetType gMemoryOutputStreamGetSize gMemoryOutputStreamGetData gMemoryOutputStreamNew gMemoryOutputStreamGetType gMemoryInputStreamAddData gMemoryInputStreamNewFromData gMemoryInputStreamNew gMemoryInputStreamGetType gLoadableIconLoadFinish gLoadableIconLoadAsync gLoadableIconLoad gLoadableIconGetType gIoSchedulerJobSendToMainloopAsync gIoSchedulerJobSendToMainloop gIoSchedulerCancelAllJobs gIOModulesLoadAllInDirectory gIOModuleNew gIOModuleGetType gIoErrorFromErrno gIoErrorQuark gOutputStreamSpliceFlagsGetType gPasswordSaveGetType gAskPasswordFlagsGetType gIoErrorEnumGetType gFileMonitorEventGetType gFileTypeGetType gFileAttributeStatusGetType gFileAttributeInfoFlagsGetType gFileAttributeTypeGetType gFileMonitorFlagsGetType gFileCopyFlagsGetType gFileCreateFlagsGetType gFileQueryInfoFlagsGetType gDataStreamNewlineTypeGetType gDataStreamByteOrderGetType gAppInfoCreateFlagsGetType gInputStreamClearPending gInputStreamSetPending gInputStreamHasPending gInputStreamIsClosed gInputStreamCloseFinish gInputStreamCloseAsync gInputStreamSkipFinish gInputStreamSkipAsync gInputStreamReadFinish gInputStreamReadAsync gInputStreamClose gInputStreamSkip gInputStreamReadAll gInputStreamRead gInputStreamGetType gIconEqual gIconHash gIconGetType gFilterOutputStreamGetBaseStream gFilterOutputStreamGetType gFilterInputStreamGetBaseStream gFilterInputStreamGetType gFileOutputStreamGetEtag gFileOutputStreamQueryInfoFinish gFileOutputStreamQueryInfoAsync gFileOutputStreamQueryInfo gFileOutputStreamGetType gFilenameCompleterSetDirsOnly gFilenameCompleterGetCompletions gFilenameCompleterGetCompletionSuffix gFilenameCompleterNew gFilenameCompleterGetType gFileMonitorEmitEvent gFileMonitorSetRateLimit gFileMonitorIsCancelled gFileMonitorCancel gFileMonitorGetType gFileInputStreamQueryInfoFinish gFileInputStreamQueryInfoAsync gFileInputStreamQueryInfo gFileInputStreamGetType gFileAttributeMatcherEnumerateNext gFileAttributeMatcherEnumerateNamespace gFileAttributeMatcherMatchesOnly gFileAttributeMatcherMatches gFileAttributeMatcherNew gFileInfoSetSortOrder gFileInfoSetSymlinkTarget gFileInfoSetModificationTime gFileInfoSetSize gFileInfoSetContentType gFileInfoSetIcon gFileInfoSetEditName gFileInfoSetDisplayName gFileInfoSetName gFileInfoSetIsSymlink gFileInfoSetIsHidden gFileInfoSetFileType gFileInfoUnsetAttributeMask gFileInfoSetAttributeMask gFileInfoGetSortOrder gTcpConnectionGetGracefulDisconnect gTcpConnectionSetGracefulDisconnect gTcpConnectionGetType gInetSocketAddressGetPort gInetSocketAddressGetAddress gInetSocketAddressNew gVolumeEjectWithOperationFinish gVolumeEjectWithOperation gThreadedSocketServiceNew gThreadedSocketServiceGetType gSrvTargetListSort gSrvTargetGetWeight gSrvTargetGetPriority gSrvTargetGetPort gSrvTargetGetHostname gSrvTargetFree gSrvTargetCopy gSrvTargetNew gSrvTargetGetType gSocketServiceIsActive gSocketServiceStop gSocketServiceStart gSocketServiceNew gSocketServiceGetType gSocketListenerClose gSocketListenerAcceptFinish gSocketListenerAcceptAsync gSocketListenerAccept gSocketListenerAcceptSocketFinish gSocketListenerAcceptSocketAsync gSocketListenerAcceptSocket gSocketListenerAddInetPort gSocketListenerAddAddress gSocketListenerAddSocket gSocketListenerSetBacklog gSocketListenerNew gSocketListenerGetType gSocketSpeaksIpv4 gSocketCreateSource gSocketIsClosed gSocketShutdown gSocketClose gSocketSendMessage gSocketReceiveMessage gFileInfoGetEtag gFileInfoGetSymlinkTarget gFileInfoGetModificationTime gFileInfoGetSize gFileInfoGetContentType gFileInfoGetIcon gFileInfoGetEditName gFileInfoGetDisplayName gFileInfoGetName gFileInfoGetIsSymlink gFileInfoGetIsBackup gFileInfoGetIsHidden gFileInfoGetFileType gFileInfoClearStatus gFileInfoSetAttributeObject gFileInfoSetAttributeInt64 gFileInfoSetAttributeUint64 gFileInfoSetAttributeInt32 gFileInfoSetAttributeUint32 gFileInfoSetAttributeBoolean gFileInfoSetAttributeByteString gFileInfoSetAttributeString gFileInfoSetAttribute gFileInfoGetAttributeObject gFileInfoGetAttributeInt64 gFileInfoGetAttributeUint64 gFileInfoGetAttributeInt32 gFileInfoGetAttributeUint32 gFileInfoGetAttributeBoolean gFileInfoGetAttributeByteString gFileInfoGetAttributeString gFileInfoGetAttributeAsString gFileInfoGetAttributeStatus gFileInfoRemoveAttribute gFileInfoGetAttributeType gFileInfoGetAttributeData gFileInfoListAttributes gFileInfoHasAttribute gFileInfoCopyInto gFileInfoDup gFileInfoNew gFileInfoGetType gFileIconGetFile gFileIconNew gFileIconGetType gFileReplaceContentsFinish gFileReplaceContentsAsync gFileReplaceContents gFileLoadPartialContentsFinish gFileLoadContentsFinish gFileLoadContentsAsync gFileLoadContents gFileQueryDefaultHandler gFileMonitorFile gFileMonitorDirectory gFileCopyAttributes gFileEjectMountableFinish gFileEjectMountable gFileUnmountMountableFinish gFileUnmountMountable gFileMountMountableFinish gFileMountMountable gFileMountEnclosingVolumeFinish gFileMountEnclosingVolume gFileSetAttributeInt64 gFileSetAttributeUint64 gFileSetAttributeInt32 gFileSetAttributeUint32 gFileSetAttributeByteString gFileSetAttributeString gFileSetAttributesFinish gFileSetAttributesAsync gFileSetAttributesFromInfo gFileSetAttribute gFileQueryWritableNamespaces gFileQuerySettableAttributes gFileMakeSymbolicLink gFileMakeDirectory gFileMove gFileCopyFinish gFileCopyAsync gFileCopy gFileTrash gFileDelete gFileSetDisplayNameFinish gFileSetDisplayNameAsync gFileSetDisplayName gFileEnumerateChildrenFinish gFileEnumerateChildrenAsync gFileEnumerateChildren gFileFindEnclosingMountFinish gFileFindEnclosingMountAsync gFileFindEnclosingMount gFileQueryFilesystemInfoFinish gFileQueryFilesystemInfoAsync gFileQueryFilesystemInfo gFileQueryInfoFinish gFileQueryInfoAsync gFileQueryInfo gFileQueryExists gFileReplaceFinish gFileReplaceAsync gFileCreateFinish gFileCreateAsync gFileAppendToFinish gFileAppendToAsync gFileReplace gFileCreate gFileAppendTo gFileReadFinish gFileReadAsync gFileRead gFileGetUriScheme gFileHasUriScheme gFileIsNative gFileResolveRelativePath gFileGetRelativePath gFileHasPrefix gFileGetChildForDisplayName gFileGetChild gFileGetParent gFileGetParseName gFileGetUri gFileGetPath gFileGetBasename gFileEqual gFileHash gFileDup gFileParseName gFileNewForCommandlineArg gFileNewForUri gFileNewForPath gFileGetType gFileEnumeratorSetPending gFileEnumeratorHasPending gFileEnumeratorIsClosed gFileEnumeratorCloseFinish gFileEnumeratorCloseAsync gFileEnumeratorNextFilesFinish gFileEnumeratorNextFilesAsync gFileEnumeratorClose gFileEnumeratorNextFile gFileEnumeratorGetType gFileAttributeInfoListAdd gFileAttributeInfoListLookup gFileAttributeInfoListNew gDriveEnumerateIdentifiers gDriveGetIdentifier gDrivePollForMediaFinish gDrivePollForMedia gDriveEjectFinish gDriveEject gDriveCanEject gDriveCanPollForMedia gDriveIsMediaCheckAutomatic gDriveHasMedia gDriveIsMediaRemovable gDriveGetVolumes gDriveHasVolumes gDriveGetIcon gDriveGetName gDriveGetType gDataOutputStreamPutString gDataOutputStreamPutUint64 gDataOutputStreamPutInt64 gDataOutputStreamPutUint32 gDataOutputStreamPutInt32 gDataOutputStreamPutUint16 gDataOutputStreamPutInt16 gDataOutputStreamPutByte gDataOutputStreamGetByteOrder gDataOutputStreamSetByteOrder gDataOutputStreamNew gDataOutputStreamGetType gDataInputStreamReadUntil gDataInputStreamReadLine gDataInputStreamReadUint64 gDataInputStreamReadInt64 gDataInputStreamReadUint32 gDataInputStreamReadInt32 gDataInputStreamReadUint16 gDataInputStreamReadInt16 gDataInputStreamReadByte gDataInputStreamGetNewlineType gDataInputStreamSetNewlineType gDataInputStreamGetByteOrder gDataInputStreamSetByteOrder gDataInputStreamNew gDataInputStreamGetType gContentTypesGetRegistered gContentTypeGuess gContentTypeCanBeExecutable gContentTypeGetIcon gContentTypeGetMimeType gContentTypeGetDescription gContentTypeIsUnknown gContentTypeIsA gContentTypeEquals gCancellableCancel gCancellableReset gCancellablePopCurrent gCancellablePushCurrent gCancellableGetCurrent gCancellableGetFd gCancellableSetErrorIfCancelled gCancellableIsCancelled gCancellableNew gCancellableGetType gBufferedOutputStreamSetAutoGrow gBufferedOutputStreamGetAutoGrow gBufferedOutputStreamSetBufferSize gBufferedOutputStreamGetBufferSize gBufferedOutputStreamNewSized gBufferedOutputStreamNew gBufferedOutputStreamGetType gBufferedInputStreamReadByte gIoExtensionRefClass gIoExtensionGetPriority gIoExtensionGetName gIoExtensionGetType gIoExtensionPointImplement gIoExtensionPointGetExtensionByName gIoExtensionPointGetExtensions gIoExtensionPointGetRequiredType gIoExtensionPointSetRequiredType gIoExtensionPointLookup gIoExtensionPointRegister gVolumeMonitorAdoptOrphanMount gVolumeMonitorGetMountForUuid gVolumeMonitorGetVolumeForUuid gVolumeMonitorGetMounts gVolumeMonitorGetVolumes gVolumeMonitorGetConnectedDrives gVolumeMonitorGet gVolumeMonitorGetType gVolumeEjectFinish gVolumeEject gVolumeMountFinish gVolumeMount gVolumeShouldAutomount gVolumeCanEject gVolumeCanMount gVolumeGetMount gVolumeGetDrive gVolumeGetUuid gVolumeGetIcon gVolumeGetName gVolumeGetType gVfsGetSupportedUriSchemes gVfsGetLocal gVfsGetDefault gVfsParseName gVfsGetFileForUri gVfsGetFileForPath gVfsIsActive gVfsGetType gThemedIconAppendName gThemedIconGetNames gThemedIconNewFromNames gThemedIconNewWithDefaultFallbacks gThemedIconNew gThemedIconGetType gSimpleAsyncReportGerrorInIdle gSimpleAsyncResultPropagateError gSimpleAsyncResultSetFromError gSimpleAsyncResultCompleteInIdle gSimpleAsyncResultComplete gSimpleAsyncResultSetHandleCancellation gSimpleAsyncResultGetSourceTag gSimpleAsyncResultGetOpResGboolean gSimpleAsyncResultSetOpResGboolean gSimpleAsyncResultGetOpResGssize gSimpleAsyncResultSetOpResGssize gSimpleAsyncResultGetOpResGpointer gSimpleAsyncResultSetOpResGpointer gSimpleAsyncResultNewFromError gSimpleAsyncResultNew gSimpleAsyncResultGetType gSeekableTruncate gSeekableCanTruncate gSeekableSeek gSeekableCanSeek gBufferedInputStreamFillFinish gBufferedInputStreamFillAsync gBufferedInputStreamFill gBufferedInputStreamPeekBuffer gBufferedInputStreamGetAvailable gBufferedInputStreamSetBufferSize gBufferedInputStreamGetBufferSize gBufferedInputStreamNewSized gBufferedInputStreamNew gBufferedInputStreamGetType gAsyncResultGetSourceObject gAsyncResultGetUserData gAsyncResultGetType gAppLaunchContextLaunchFailed gAppLaunchContextGetStartupNotifyId gAppLaunchContextGetDisplay gAppLaunchContextNew gAppInfoGetDefaultForUriScheme gAppInfoGetDefaultForType gAppInfoGetAllForType gAppInfoGetAll gAppInfoRemoveSupportsType gAppInfoCanRemoveSupportsType gAppInfoAddSupportsType gAppInfoSetAsDefaultForExtension gAppInfoSetAsDefaultForType gAppInfoShouldShow gAppInfoLaunchUris gAppInfoSupportsFiles gAppInfoSupportsUris gAppInfoLaunch gAppInfoGetIcon gAppInfoGetExecutable gAppInfoGetDescription gAppInfoGetName gAppInfoGetId gAppInfoEqual gAppInfoDup gAppInfoCreateFromCommandline gAppLaunchContextGetType gAppInfoLaunchDefaultForUri gAppInfoGetType

Documented in gAppInfoAddSupportsType gAppInfoCanDelete gAppInfoCanRemoveSupportsType gAppInfoCreateFlagsGetType gAppInfoCreateFromCommandline gAppInfoDelete gAppInfoDup gAppInfoEqual gAppInfoGetAll gAppInfoGetAllForType gAppInfoGetCommandline gAppInfoGetDefaultForType gAppInfoGetDefaultForUriScheme gAppInfoGetDescription gAppInfoGetExecutable gAppInfoGetIcon gAppInfoGetId gAppInfoGetName gAppInfoGetType gAppInfoLaunch gAppInfoLaunchDefaultForUri gAppInfoLaunchUris gAppInfoRemoveSupportsType gAppInfoResetTypeAssociations gAppInfoSetAsDefaultForExtension gAppInfoSetAsDefaultForType gAppInfoShouldShow gAppInfoSupportsFiles gAppInfoSupportsUris gAppLaunchContextGetDisplay gAppLaunchContextGetStartupNotifyId gAppLaunchContextGetType gAppLaunchContextLaunchFailed gAppLaunchContextNew gAskPasswordFlagsGetType gAsyncInitableGetType gAsyncInitableInitAsync gAsyncInitableInitFinish gAsyncInitableNewFinish gAsyncResultGetSourceObject gAsyncResultGetType gAsyncResultGetUserData gBufferedInputStreamFill gBufferedInputStreamFillAsync gBufferedInputStreamFillFinish gBufferedInputStreamGetAvailable gBufferedInputStreamGetBufferSize gBufferedInputStreamGetType gBufferedInputStreamNew gBufferedInputStreamNewSized gBufferedInputStreamPeekBuffer gBufferedInputStreamReadByte gBufferedInputStreamSetBufferSize gBufferedOutputStreamGetAutoGrow gBufferedOutputStreamGetBufferSize gBufferedOutputStreamGetType gBufferedOutputStreamNew gBufferedOutputStreamNewSized gBufferedOutputStreamSetAutoGrow gBufferedOutputStreamSetBufferSize gCancellableCancel gCancellableDisconnect gCancellableGetCurrent gCancellableGetFd gCancellableGetType gCancellableIsCancelled gCancellableNew gCancellablePopCurrent gCancellablePushCurrent gCancellableReleaseFd gCancellableReset gCancellableSetErrorIfCancelled gContentTypeCanBeExecutable gContentTypeEquals gContentTypeFromMimeType gContentTypeGetDescription gContentTypeGetIcon gContentTypeGetMimeType gContentTypeGuess gContentTypeGuessForTree gContentTypeIsA gContentTypeIsUnknown gContentTypesGetRegistered gDataInputStreamGetByteOrder gDataInputStreamGetNewlineType gDataInputStreamGetType gDataInputStreamNew gDataInputStreamReadByte gDataInputStreamReadInt16 gDataInputStreamReadInt32 gDataInputStreamReadInt64 gDataInputStreamReadLine gDataInputStreamReadLineAsync gDataInputStreamReadLineFinish gDataInputStreamReadUint16 gDataInputStreamReadUint32 gDataInputStreamReadUint64 gDataInputStreamReadUntil gDataInputStreamReadUntilAsync gDataInputStreamReadUntilFinish gDataInputStreamSetByteOrder gDataInputStreamSetNewlineType gDataOutputStreamGetByteOrder gDataOutputStreamGetType gDataOutputStreamNew gDataOutputStreamPutByte gDataOutputStreamPutInt16 gDataOutputStreamPutInt32 gDataOutputStreamPutInt64 gDataOutputStreamPutString gDataOutputStreamPutUint16 gDataOutputStreamPutUint32 gDataOutputStreamPutUint64 gDataOutputStreamSetByteOrder gDataStreamByteOrderGetType gDataStreamNewlineTypeGetType gDriveCanEject gDriveCanPollForMedia gDriveCanStart gDriveCanStartDegraded gDriveCanStop gDriveEject gDriveEjectFinish gDriveEjectWithOperation gDriveEjectWithOperationFinish gDriveEnumerateIdentifiers gDriveGetIcon gDriveGetIdentifier gDriveGetName gDriveGetStartStopType gDriveGetType gDriveGetVolumes gDriveHasMedia gDriveHasVolumes gDriveIsMediaCheckAutomatic gDriveIsMediaRemovable gDrivePollForMedia gDrivePollForMediaFinish gDriveStart gDriveStartFinish gDriveStop gDriveStopFinish gEmblemedIconAddEmblem gEmblemedIconGetEmblems gEmblemedIconGetIcon gEmblemedIconGetType gEmblemedIconNew gEmblemGetIcon gEmblemGetOrigin gEmblemGetType gEmblemNew gEmblemNewWithOrigin gFileAppendTo gFileAppendToAsync gFileAppendToFinish gFileAttributeInfoFlagsGetType gFileAttributeInfoListAdd gFileAttributeInfoListLookup gFileAttributeInfoListNew gFileAttributeMatcherEnumerateNamespace gFileAttributeMatcherEnumerateNext gFileAttributeMatcherMatches gFileAttributeMatcherMatchesOnly gFileAttributeMatcherNew gFileAttributeStatusGetType gFileAttributeTypeGetType gFileCopy gFileCopyAsync gFileCopyAttributes gFileCopyFinish gFileCopyFlagsGetType gFileCreate gFileCreateAsync gFileCreateFinish gFileCreateFlagsGetType gFileCreateReadwrite gFileCreateReadwriteAsync gFileCreateReadwriteFinish gFileDelete gFileDup gFileEjectMountable gFileEjectMountableFinish gFileEjectMountableWithOperation gFileEjectMountableWithOperationFinish gFileEnumerateChildren gFileEnumerateChildrenAsync gFileEnumerateChildrenFinish gFileEnumeratorClose gFileEnumeratorCloseAsync gFileEnumeratorCloseFinish gFileEnumeratorGetContainer gFileEnumeratorGetType gFileEnumeratorHasPending gFileEnumeratorIsClosed gFileEnumeratorNextFile gFileEnumeratorNextFilesAsync gFileEnumeratorNextFilesFinish gFileEnumeratorSetPending gFileEqual gFileFindEnclosingMount gFileFindEnclosingMountAsync gFileFindEnclosingMountFinish gFileGetBasename gFileGetChild gFileGetChildForDisplayName gFileGetParent gFileGetParseName gFileGetPath gFileGetRelativePath gFileGetType gFileGetUri gFileGetUriScheme gFileHash gFileHasPrefix gFileHasUriScheme gFileIconGetFile gFileIconGetType gFileIconNew gFileInfoClearStatus gFileInfoCopyInto gFileInfoDup gFileInfoGetAttributeAsString gFileInfoGetAttributeBoolean gFileInfoGetAttributeByteString gFileInfoGetAttributeData gFileInfoGetAttributeInt32 gFileInfoGetAttributeInt64 gFileInfoGetAttributeObject gFileInfoGetAttributeStatus gFileInfoGetAttributeString gFileInfoGetAttributeStringv gFileInfoGetAttributeType gFileInfoGetAttributeUint32 gFileInfoGetAttributeUint64 gFileInfoGetContentType gFileInfoGetDisplayName gFileInfoGetEditName gFileInfoGetEtag gFileInfoGetFileType gFileInfoGetIcon gFileInfoGetIsBackup gFileInfoGetIsHidden gFileInfoGetIsSymlink gFileInfoGetModificationTime gFileInfoGetName gFileInfoGetSize gFileInfoGetSortOrder gFileInfoGetSymlinkTarget gFileInfoGetType gFileInfoHasAttribute gFileInfoHasNamespace gFileInfoListAttributes gFileInfoNew gFileInfoRemoveAttribute gFileInfoSetAttribute gFileInfoSetAttributeBoolean gFileInfoSetAttributeByteString gFileInfoSetAttributeInt32 gFileInfoSetAttributeInt64 gFileInfoSetAttributeMask gFileInfoSetAttributeObject gFileInfoSetAttributeStatus gFileInfoSetAttributeString gFileInfoSetAttributeStringv gFileInfoSetAttributeUint32 gFileInfoSetAttributeUint64 gFileInfoSetContentType gFileInfoSetDisplayName gFileInfoSetEditName gFileInfoSetFileType gFileInfoSetIcon gFileInfoSetIsHidden gFileInfoSetIsSymlink gFileInfoSetModificationTime gFileInfoSetName gFileInfoSetSize gFileInfoSetSortOrder gFileInfoSetSymlinkTarget gFileInfoUnsetAttributeMask gFileInputStreamGetType gFileInputStreamQueryInfo gFileInputStreamQueryInfoAsync gFileInputStreamQueryInfoFinish gFileIOStreamGetEtag gFileIOStreamGetType gFileIOStreamQueryInfo gFileIOStreamQueryInfoAsync gFileIOStreamQueryInfoFinish gFileIsNative gFileLoadContents gFileLoadContentsAsync gFileLoadContentsFinish gFileLoadPartialContentsFinish gFileMakeDirectory gFileMakeDirectoryWithParents gFileMakeSymbolicLink gFileMonitor gFileMonitorCancel gFileMonitorDirectory gFileMonitorEmitEvent gFileMonitorEventGetType gFileMonitorFile gFileMonitorFlagsGetType gFileMonitorGetType gFileMonitorIsCancelled gFileMonitorSetRateLimit gFileMountEnclosingVolume gFileMountEnclosingVolumeFinish gFileMountMountable gFileMountMountableFinish gFileMove gFilenameCompleterGetCompletions gFilenameCompleterGetCompletionSuffix gFilenameCompleterGetType gFilenameCompleterNew gFilenameCompleterSetDirsOnly gFileNewForCommandlineArg gFileNewForPath gFileNewForUri gFileOpenReadwrite gFileOpenReadwriteAsync gFileOpenReadwriteFinish gFileOutputStreamGetEtag gFileOutputStreamGetType gFileOutputStreamQueryInfo gFileOutputStreamQueryInfoAsync gFileOutputStreamQueryInfoFinish gFileParseName gFilePollMountable gFilePollMountableFinish gFileQueryDefaultHandler gFileQueryExists gFileQueryFilesystemInfo gFileQueryFilesystemInfoAsync gFileQueryFilesystemInfoFinish gFileQueryFileType gFileQueryInfo gFileQueryInfoAsync gFileQueryInfoFinish gFileQueryInfoFlagsGetType gFileQuerySettableAttributes gFileQueryWritableNamespaces gFileRead gFileReadAsync gFileReadFinish gFileReplace gFileReplaceAsync gFileReplaceContents gFileReplaceContentsAsync gFileReplaceContentsFinish gFileReplaceFinish gFileReplaceReadwrite gFileReplaceReadwriteAsync gFileReplaceReadwriteFinish gFileResolveRelativePath gFileSetAttribute gFileSetAttributeByteString gFileSetAttributeInt32 gFileSetAttributeInt64 gFileSetAttributesAsync gFileSetAttributesFinish gFileSetAttributesFromInfo gFileSetAttributeString gFileSetAttributeUint32 gFileSetAttributeUint64 gFileSetDisplayName gFileSetDisplayNameAsync gFileSetDisplayNameFinish gFileStartMountable gFileStartMountableFinish gFileStopMountable gFileStopMountableFinish gFileSupportsThreadContexts gFileTrash gFileTypeGetType gFileUnmountMountable gFileUnmountMountableFinish gFileUnmountMountableWithOperation gFileUnmountMountableWithOperationFinish gFilterInputStreamGetBaseStream gFilterInputStreamGetCloseBaseStream gFilterInputStreamGetType gFilterInputStreamSetCloseBaseStream gFilterOutputStreamGetBaseStream gFilterOutputStreamGetCloseBaseStream gFilterOutputStreamGetType gFilterOutputStreamSetCloseBaseStream gIconEqual gIconGetType gIconHash gIconNewForString gIconToString gInetAddressGetFamily gInetAddressGetIsAny gInetAddressGetIsLinkLocal gInetAddressGetIsLoopback gInetAddressGetIsMcGlobal gInetAddressGetIsMcLinkLocal gInetAddressGetIsMcNodeLocal gInetAddressGetIsMcOrgLocal gInetAddressGetIsMcSiteLocal gInetAddressGetIsMulticast gInetAddressGetIsSiteLocal gInetAddressGetNativeSize gInetAddressGetType gInetAddressNewAny gInetAddressNewFromBytes gInetAddressNewFromString gInetAddressNewLoopback gInetAddressToBytes gInetAddressToString gInetSocketAddressGetAddress gInetSocketAddressGetPort gInetSocketAddressNew gInitableGetType gInitableInit gInputStreamClearPending gInputStreamClose gInputStreamCloseAsync gInputStreamCloseFinish gInputStreamGetType gInputStreamHasPending gInputStreamIsClosed gInputStreamRead gInputStreamReadAll gInputStreamReadAsync gInputStreamReadFinish gInputStreamSetPending gInputStreamSkip gInputStreamSkipAsync gInputStreamSkipFinish gIoErrorEnumGetType gIoErrorFromErrno gIoErrorQuark gIoExtensionGetName gIoExtensionGetPriority gIoExtensionGetType gIoExtensionPointGetExtensionByName gIoExtensionPointGetExtensions gIoExtensionPointGetRequiredType gIoExtensionPointImplement gIoExtensionPointLookup gIoExtensionPointRegister gIoExtensionPointSetRequiredType gIoExtensionRefClass gIOModuleGetType gIOModuleNew gIOModulesLoadAllInDirectory gIoSchedulerCancelAllJobs gIoSchedulerJobSendToMainloop gIoSchedulerJobSendToMainloopAsync gIOStreamClearPending gIOStreamClose gIOStreamCloseAsync gIOStreamCloseFinish gIOStreamGetInputStream gIOStreamGetOutputStream gIOStreamGetType gIOStreamHasPending gIOStreamIsClosed gIOStreamSetPending gLoadableIconGetType gLoadableIconLoad gLoadableIconLoadAsync gLoadableIconLoadFinish gMemoryInputStreamAddData gMemoryInputStreamGetType gMemoryInputStreamNew gMemoryInputStreamNewFromData gMemoryOutputStreamGetData gMemoryOutputStreamGetDataSize gMemoryOutputStreamGetSize gMemoryOutputStreamGetType gMemoryOutputStreamNew gMountCanEject gMountCanUnmount gMountEject gMountEjectFinish gMountEjectWithOperation gMountEjectWithOperationFinish gMountGetDrive gMountGetIcon gMountGetName gMountGetRoot gMountGetType gMountGetUuid gMountGetVolume gMountGuessContentType gMountGuessContentTypeFinish gMountGuessContentTypeSync gMountIsShadowed gMountOperationGetAnonymous gMountOperationGetChoice gMountOperationGetDomain gMountOperationGetPassword gMountOperationGetPasswordSave gMountOperationGetType gMountOperationGetUsername gMountOperationNew gMountOperationReply gMountOperationSetAnonymous gMountOperationSetChoice gMountOperationSetDomain gMountOperationSetPassword gMountOperationSetPasswordSave gMountOperationSetUsername gMountRemount gMountRemountFinish gMountShadow gMountUnmount gMountUnmountFinish gMountUnmountWithOperation gMountUnmountWithOperationFinish gMountUnshadow gNativeVolumeMonitorGetType gNetworkAddressGetHostname gNetworkAddressGetPort gNetworkAddressGetType gNetworkAddressNew gNetworkAddressParse gNetworkServiceGetDomain gNetworkServiceGetProtocol gNetworkServiceGetService gNetworkServiceGetType gNetworkServiceNew gOutputStreamClearPending gOutputStreamClose gOutputStreamCloseAsync gOutputStreamCloseFinish gOutputStreamFlush gOutputStreamFlushAsync gOutputStreamFlushFinish gOutputStreamGetType gOutputStreamHasPending gOutputStreamIsClosed gOutputStreamSetPending gOutputStreamSplice gOutputStreamSpliceAsync gOutputStreamSpliceFinish gOutputStreamSpliceFlagsGetType gOutputStreamWrite gOutputStreamWriteAll gOutputStreamWriteAsync gOutputStreamWriteFinish gPasswordSaveGetType gResolverErrorQuark gResolverFreeAddresses gResolverFreeTargets gResolverGetDefault gResolverGetType gResolverLookupByAddress gResolverLookupByAddressAsync gResolverLookupByAddressFinish gResolverLookupByName gResolverLookupByNameAsync gResolverLookupByNameFinish gResolverLookupService gResolverLookupServiceAsync gResolverLookupServiceFinish gResolverSetDefault gSeekableCanSeek gSeekableCanTruncate gSeekableGetType gSeekableSeek gSeekableTell gSeekableTruncate gSimpleAsyncReportGerrorInIdle gSimpleAsyncResultComplete gSimpleAsyncResultCompleteInIdle gSimpleAsyncResultGetOpResGboolean gSimpleAsyncResultGetOpResGpointer gSimpleAsyncResultGetOpResGssize gSimpleAsyncResultGetSourceTag gSimpleAsyncResultGetType gSimpleAsyncResultNew gSimpleAsyncResultNewFromError gSimpleAsyncResultPropagateError gSimpleAsyncResultSetFromError gSimpleAsyncResultSetHandleCancellation gSimpleAsyncResultSetOpResGboolean gSimpleAsyncResultSetOpResGpointer gSimpleAsyncResultSetOpResGssize gSocketAccept gSocketAddressEnumeratorGetType gSocketAddressEnumeratorNext gSocketAddressEnumeratorNextAsync gSocketAddressEnumeratorNextFinish gSocketAddressGetFamily gSocketAddressGetNativeSize gSocketAddressGetType gSocketAddressNewFromNative gSocketAddressToNative gSocketBind gSocketCheckConnectResult gSocketClientConnect gSocketClientConnectAsync gSocketClientConnectFinish gSocketClientConnectToHost gSocketClientConnectToHostAsync gSocketClientConnectToHostFinish gSocketClientConnectToService gSocketClientConnectToServiceAsync gSocketClientConnectToServiceFinish gSocketClientGetFamily gSocketClientGetLocalAddress gSocketClientGetProtocol gSocketClientGetSocketType gSocketClientGetType gSocketClientNew gSocketClientSetFamily gSocketClientSetLocalAddress gSocketClientSetProtocol gSocketClientSetSocketType gSocketClose gSocketConditionCheck gSocketConditionWait gSocketConnect gSocketConnectableEnumerate gSocketConnectableGetType gSocketConnectionFactoryCreateConnection gSocketConnectionFactoryLookupType gSocketConnectionFactoryRegisterType gSocketConnectionGetLocalAddress gSocketConnectionGetRemoteAddress gSocketConnectionGetSocket gSocketConnectionGetType gSocketControlMessageDeserialize gSocketControlMessageGetLevel gSocketControlMessageGetMsgType gSocketControlMessageGetSize gSocketControlMessageGetType gSocketControlMessageSerialize gSocketCreateSource gSocketGetBlocking gSocketGetFamily gSocketGetFd gSocketGetKeepalive gSocketGetListenBacklog gSocketGetLocalAddress gSocketGetProtocol gSocketGetRemoteAddress gSocketGetSocketType gSocketGetType gSocketIsClosed gSocketIsConnected gSocketListen gSocketListenerAccept gSocketListenerAcceptAsync gSocketListenerAcceptFinish gSocketListenerAcceptSocket gSocketListenerAcceptSocketAsync gSocketListenerAcceptSocketFinish gSocketListenerAddAddress gSocketListenerAddInetPort gSocketListenerAddSocket gSocketListenerClose gSocketListenerGetType gSocketListenerNew gSocketListenerSetBacklog gSocketNew gSocketNewFromFd gSocketReceive gSocketReceiveFrom gSocketReceiveMessage gSocketSend gSocketSendMessage gSocketSendTo gSocketServiceGetType gSocketServiceIsActive gSocketServiceNew gSocketServiceStart gSocketServiceStop gSocketSetBlocking gSocketSetKeepalive gSocketSetListenBacklog gSocketShutdown gSocketSpeaksIpv4 gSrvTargetCopy gSrvTargetFree gSrvTargetGetHostname gSrvTargetGetPort gSrvTargetGetPriority gSrvTargetGetType gSrvTargetGetWeight gSrvTargetListSort gSrvTargetNew gTcpConnectionGetGracefulDisconnect gTcpConnectionGetType gTcpConnectionSetGracefulDisconnect gThemedIconAppendName gThemedIconGetNames gThemedIconGetType gThemedIconNew gThemedIconNewFromNames gThemedIconNewWithDefaultFallbacks gThemedIconPrependName gThreadedSocketServiceGetType gThreadedSocketServiceNew gVfsGetDefault gVfsGetFileForPath gVfsGetFileForUri gVfsGetLocal gVfsGetSupportedUriSchemes gVfsGetType gVfsIsActive gVfsParseName gVolumeCanEject gVolumeCanMount gVolumeEject gVolumeEjectFinish gVolumeEjectWithOperation gVolumeEjectWithOperationFinish gVolumeEnumerateIdentifiers gVolumeGetActivationRoot gVolumeGetDrive gVolumeGetIcon gVolumeGetIdentifier gVolumeGetMount gVolumeGetName gVolumeGetType gVolumeGetUuid gVolumeMonitorAdoptOrphanMount gVolumeMonitorGet gVolumeMonitorGetConnectedDrives gVolumeMonitorGetMountForUuid gVolumeMonitorGetMounts gVolumeMonitorGetType gVolumeMonitorGetVolumeForUuid gVolumeMonitorGetVolumes gVolumeMount gVolumeMountFinish gVolumeShouldAutomount

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