gio

package
v0.0.0-...-f05e200 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 29, 2013 License: BSD-3-Clause Imports: 5 Imported by: 0

Documentation

Overview

Package gio provides API definitions for accessing libgio-2.0-0.dll.

Index

Constants

This section is empty.

Variables

View Source 
var (
	KeyfileSettingsBackendNew func(
		filename string,
		rootPath string,
		rootGroup string) *SettingsBackend

	UnixSocketAddressTypeGetType func() O.Type
)
View Source 
var (
	ActionGetType func() O.Type

	ActionGetName func(a *Action) string

	ActionActivate         func(a *Action, parameter *L.Variant)
	ActionGetEnabled       func(a *Action) bool
	ActionGetParameterType func(a *Action) *L.VariantType
	ActionGetState         func(a *Action) *L.Variant
	ActionGetStateHint     func(a *Action) *L.Variant
	ActionGetStateType     func(a *Action) *L.VariantType
	ActionSetState         func(a *Action, value *L.Variant)
)
View Source 
var (
	ActionGroupGetType func() O.Type

	ActionGroupActionAdded            func(a *ActionGroup, actionName string)
	ActionGroupActionEnabledChanged   func(a *ActionGroup, actionName string, enabled bool)
	ActionGroupActionRemoved          func(a *ActionGroup, actionName string)
	ActionGroupActionStateChanged     func(a *ActionGroup, actionName string, state *L.Variant)
	ActionGroupActivateAction         func(a *ActionGroup, actionName string, parameter *L.Variant)
	ActionGroupChangeActionState      func(a *ActionGroup, actionName string, value *L.Variant)
	ActionGroupGetActionEnabled       func(a *ActionGroup, actionName string) bool
	ActionGroupGetActionParameterType func(a *ActionGroup, actionName string) *L.VariantType
	ActionGroupGetActionState         func(a *ActionGroup, actionName string) *L.Variant
	ActionGroupGetActionStateHint     func(a *ActionGroup, actionName string) *L.Variant
	ActionGroupGetActionStateType     func(a *ActionGroup, actionName string) *L.VariantType
	ActionGroupHasAction              func(a *ActionGroup, actionName string) bool
	ActionGroupListActions            func(a *ActionGroup) []string
)
View Source 
var (
	AppInfoGetType func() O.Type

	AppInfoGetAll                 func() *L.List
	AppInfoGetAllForType          func(contentType string) *L.List
	AppInfoGetRecommendedForType  func(contentType string) *L.List
	AppInfoGetFallbackForType     func(contentType string) *L.List
	AppInfoResetTypeAssociations  func(contentType string)
	AppInfoGetDefaultForType      func(contentType string, mustSupportUris bool) *AppInfo
	AppInfoGetDefaultForUriScheme func(uriScheme string) *AppInfo
	AppInfoLaunchDefaultForUri    func(uri string, launchContext *AppLaunchContext, err **L.Error) bool
	AppInfoCreateFromCommandline  func(commandline string, applicationName string, flags AppInfoCreateFlags, err **L.Error) *AppInfo

	AppInfoAddSupportsType          func(a *AppInfo, contentType string, err **L.Error) bool
	AppInfoCanDelete                func(a *AppInfo) bool
	AppInfoCanRemoveSupportsType    func(a *AppInfo) bool
	AppInfoDelete                   func(a *AppInfo) bool
	AppInfoDup                      func(a *AppInfo) *AppInfo
	AppInfoEqual                    func(a *AppInfo, appinfo2 *AppInfo) bool
	AppInfoGetCommandline           func(a *AppInfo) string
	AppInfoGetDescription           func(a *AppInfo) string
	AppInfoGetDisplayName           func(a *AppInfo) string
	AppInfoGetExecutable            func(a *AppInfo) string
	AppInfoGetIcon                  func(a *AppInfo) *Icon
	AppInfoGetId                    func(a *AppInfo) string
	AppInfoGetName                  func(a *AppInfo) string
	AppInfoLaunch                   func(a *AppInfo, files *L.List, launchContext *AppLaunchContext, err **L.Error) bool
	AppInfoLaunchUris               func(a *AppInfo, uris *L.List, launchContext *AppLaunchContext, err **L.Error) bool
	AppInfoRemoveSupportsType       func(a *AppInfo, contentType string, err **L.Error) bool
	AppInfoSetAsDefaultForExtension func(a *AppInfo, extension string, err **L.Error) bool
	AppInfoSetAsDefaultForType      func(a *AppInfo, contentType string, err **L.Error) bool
	AppInfoSetAsLastUsedForType     func(a *AppInfo, contentType string, err **L.Error) bool
	AppInfoShouldShow               func(a *AppInfo) bool
	AppInfoSupportsFiles            func(a *AppInfo) bool
	AppInfoSupportsUris             func(a *AppInfo) bool
)
View Source 
var (
	AppLaunchContextGetType func() O.Type

	AppLaunchContextNew func() *AppLaunchContext

	AppLaunchContextGetDisplay         func(a *AppLaunchContext, info *AppInfo, files *L.List) string
	AppLaunchContextGetStartupNotifyId func(a *AppLaunchContext, info *AppInfo, files *L.List) string
	AppLaunchContextLaunchFailed       func(a *AppLaunchContext, startupNotifyId string)
)
View Source 
var (
	ApplicationGetType func() O.Type

	ApplicationIdIsValid func(applicationId string) bool
	ApplicationNew       func(applicationId string, flags ApplicationFlags) *Application

	ApplicationActivate             func(a *Application)
	ApplicationGetApplicationId     func(a *Application) string
	ApplicationGetFlags             func(a *Application) ApplicationFlags
	ApplicationGetInactivityTimeout func(a *Application) uint
	ApplicationGetIsRegistered      func(a *Application) bool
	ApplicationGetIsRemote          func(a *Application) bool
	ApplicationHold                 func(a *Application)
	ApplicationOpen                 func(a *Application, files **File, nFiles int, hint string)
	ApplicationRegister             func(a *Application, cancellable *Cancellable, err **L.Error) bool
	ApplicationRelease              func(a *Application)
	ApplicationRun                  func(a *Application, argc int, argv **T.Char) int
	ApplicationSetActionGroup       func(a *Application, ag *ActionGroup)
	ApplicationSetApplicationId     func(a *Application, applicationId string)
	ApplicationSetFlags             func(a *Application, flags ApplicationFlags)
	ApplicationSetInactivityTimeout func(a *Application, inactivityTimeout uint)
)
View Source 
var (
	ApplicationCommandLineGetType func() O.Type

	ApplicationCommandLineGetArguments    func(a *ApplicationCommandLine, argc *int) []string
	ApplicationCommandLineGetCwd          func(a *ApplicationCommandLine) string
	ApplicationCommandLineGetenv          func(a *ApplicationCommandLine, name string) string
	ApplicationCommandLineGetEnviron      func(a *ApplicationCommandLine) []string
	ApplicationCommandLineGetExitStatus   func(a *ApplicationCommandLine) int
	ApplicationCommandLineGetIsRemote     func(a *ApplicationCommandLine) bool
	ApplicationCommandLineGetPlatformData func(a *ApplicationCommandLine) *L.Variant
	ApplicationCommandLinePrint           func(a *ApplicationCommandLine, format string, v ...VArg)
	ApplicationCommandLinePrinterr        func(a *ApplicationCommandLine, format string, v ...VArg)
	ApplicationCommandLineSetExitStatus   func(a *ApplicationCommandLine, exitStatus int)
)
View Source 
var (
	AsyncInitableGetType func() O.Type

	AsyncInitableNewAsync       func(objectType O.Type, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer, firstPropertyName string, v ...VArg)
	AsyncInitableNewvAsync      func(objectType O.Type, nParameters uint, parameters *O.Parameter, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	AsyncInitableNewValistAsync func(objectType O.Type, firstPropertyName string, varArgs VAList, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

	AsyncInitableInitAsync  func(a *AsyncInitable, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	AsyncInitableInitFinish func(a *AsyncInitable, res *AsyncResult, err **L.Error) bool
	AsyncInitableNewFinish  func(a *AsyncInitable, res *AsyncResult, err **L.Error) *O.Object
)
View Source 
var (
	AsyncResultGetType func() O.Type

	AsyncResultGetSourceObject func(a *AsyncResult) *O.Object
	AsyncResultGetUserData     func(a *AsyncResult) T.Gpointer
)
View Source 
var (
	BufferedInputStreamGetType  func() O.Type
	BufferedInputStreamNew      func(baseStream *InputStream) *InputStream
	BufferedInputStreamNewSized func(baseStream *InputStream, size T.Gsize) *InputStream

	BufferedInputStreamFill          func(b *BufferedInputStream, count T.Gssize, cancellable *Cancellable, err **L.Error) T.Gssize
	BufferedInputStreamFillAsync     func(b *BufferedInputStream, count T.Gssize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	BufferedInputStreamFillFinish    func(b *BufferedInputStream, result *AsyncResult, err **L.Error) T.Gssize
	BufferedInputStreamGetAvailable  func(b *BufferedInputStream) T.Gsize
	BufferedInputStreamGetBufferSize func(b *BufferedInputStream) T.Gsize
	BufferedInputStreamPeek          func(b *BufferedInputStream, buffer *T.Void, offset, count T.Gsize) T.Gsize
	BufferedInputStreamPeekBuffer    func(b *BufferedInputStream, count *T.Gsize) *T.Void
	BufferedInputStreamReadByte      func(b *BufferedInputStream, cancellable *Cancellable, err **L.Error) int
	BufferedInputStreamSetBufferSize func(b *BufferedInputStream, size T.Gsize)
)
View Source 
var (
	BufferedOutputStreamGetType  func() O.Type
	BufferedOutputStreamNew      func(baseStream *OutputStream) *OutputStream
	BufferedOutputStreamNewSized func(baseStream *OutputStream, size T.Gsize) *OutputStream

	BufferedOutputStreamGetAutoGrow   func(b *BufferedOutputStream) bool
	BufferedOutputStreamGetBufferSize func(b *BufferedOutputStream) T.Gsize
	BufferedOutputStreamSetAutoGrow   func(b *BufferedOutputStream, autoGrow bool)
	BufferedOutputStreamSetBufferSize func(b *BufferedOutputStream, size T.Gsize)
)
View Source 
var (
	BusOwnNameOnConnection               func(b *DBusConnection, name string, flags BusNameOwnerFlags, nameAcquiredHandler BusNameAcquiredCallback, nameLostHandler BusNameLostCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	BusOwnNameOnConnectionWithClosures   func(b *DBusConnection, name string, flags BusNameOwnerFlags, nameAcquiredClosure, nameLostClosure *O.Closure) uint
	BusWatchNameOnConnection             func(b *DBusConnection, name string, flags BusNameWatcherFlags, nameAppearedHandler BusNameAppearedCallback, nameVanishedHandler BusNameVanishedCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	BusWatchNameOnConnectionWithClosures func(b *DBusConnection, name string, flags BusNameWatcherFlags, nameAppearedClosure, nameVanishedClosure *O.Closure) uint
)
View Source 
var (
	BusTypeGetType func() O.Type
	BusGetFinish   func(res *AsyncResult, err **L.Error) *DBusConnection
	BusUnownName   func(ownerId uint)
	BusUnwatchName func(watcherId uint)

	BusGet                   func(b BusType, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	BusGetSync               func(b BusType, cancellable *Cancellable, err **L.Error) *DBusConnection
	BusOwnName               func(b BusType, name string, flags BusNameOwnerFlags, busAcquiredHandler BusAcquiredCallback, nameAcquiredHandler BusNameAcquiredCallback, nameLostHandler BusNameLostCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	BusOwnNameWithClosures   func(b BusType, name string, flags BusNameOwnerFlags, busAcquiredClosure, nameAcquiredClosure, nameLostClosure *O.Closure) uint
	BusWatchName             func(b BusType, name string, flags BusNameWatcherFlags, nameAppearedHandler BusNameAppearedCallback, nameVanishedHandler BusNameVanishedCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	BusWatchNameWithClosures func(b BusType, name string, flags BusNameWatcherFlags, nameAppearedClosure, nameVanishedClosure *O.Closure) uint
)
View Source 
var (
	CancellableGetType func() O.Type
	CancellableNew     func() *Cancellable

	CancellableGetCurrent func() *Cancellable

	CancellableCancel              func(c *Cancellable)
	CancellableConnect             func(c *Cancellable, callback O.Callback, data T.Gpointer, dataDestroyFunc O.DestroyNotify) T.Gulong
	CancellableDisconnect          func(c *Cancellable, handlerId T.Gulong)
	CancellableGetFd               func(c *Cancellable) int
	CancellableIsCancelled         func(c *Cancellable) bool
	CancellableMakePollfd          func(c *Cancellable, pollfd *T.GPollFD) bool
	CancellablePopCurrent          func(c *Cancellable)
	CancellablePushCurrent         func(c *Cancellable)
	CancellableReleaseFd           func(c *Cancellable)
	CancellableReset               func(c *Cancellable)
	CancellableSetErrorIfCancelled func(c *Cancellable, err **L.Error) bool
	CancellableSourceNew           func(c *Cancellable) *O.Source
)
View Source 
var (
	CharsetConverterGetType func() O.Type
	CharsetConverterNew     func(toCharset string, fromCharset string, err **L.Error) *CharsetConverter

	CharsetConverterGetNumFallbacks func(c *CharsetConverter) uint
	CharsetConverterGetUseFallback  func(c *CharsetConverter) bool
	CharsetConverterSetUseFallback  func(c *CharsetConverter, useFallback bool)
)
View Source 
var (
	ContentTypeCanBeExecutable func(typ string) bool
	ContentTypeEquals          func(type1 string, type2 string) bool
	ContentTypeFromMimeType    func(mimeType string) string
	ContentTypeGetDescription  func(typ string) string
	ContentTypeGetIcon         func(typ string) *Icon
	ContentTypeGetMimeType     func(typ string) string
	ContentTypeGuess           func(filename string, data *T.Guchar, dataSize T.Gsize, resultUncertain *bool) string
	ContentTypeGuessForTree    func(root *File) []string
	ContentTypeIsA             func(typ string, supertype string) bool
	ContentTypeIsUnknown       func(typ string) bool
	ContentTypesGetRegistered  func() *L.List
)
View Source 
var (
	ConverterGetType func() O.Type

	ConverterConvert func(c *Converter, inbuf *T.Void, inbufSize T.Gsize, outbuf *T.Void, outbufSize T.Gsize, flags ConverterFlags, bytesRead, bytesWritten *T.Gsize, err **L.Error) ConverterResult
	ConverterReset   func(c *Converter)
)
View Source 
var (
	ConverterInputStreamGetType func() O.Type
	ConverterInputStreamNew     func(baseStream *InputStream, converter *Converter) *InputStream

	ConverterInputStreamGetConverter func(c *ConverterInputStream) *Converter
)
View Source 
var (
	ConverterOutputStreamGetType func() O.Type
	ConverterOutputStreamNew     func(baseStream *OutputStream, converter *Converter) *OutputStream

	ConverterOutputStreamGetConverter func(c *ConverterOutputStream) *Converter
)
View Source 
var (
	CredentialsGetType func() O.Type
	CredentialsNew     func() *Credentials

	CredentialsGetNative  func(c *Credentials, nativeType CredentialsType) T.Gpointer
	CredentialsIsSameUser func(c *Credentials, otherCredentials *Credentials, err **L.Error) bool
	CredentialsSetNative  func(c *Credentials, nativeType CredentialsType, native T.Gpointer)
	CredentialsToString   func(c *Credentials) string
)
View Source 
var (
	DataInputStreamGetType func() O.Type
	DataInputStreamNew     func(baseStream *InputStream) *DataInputStream

	DataInputStreamGetByteOrder    func(d *DataInputStream) DataStreamByteOrder
	DataInputStreamGetNewlineType  func(d *DataInputStream) DataStreamNewlineType
	DataInputStreamReadByte        func(d *DataInputStream, cancellable *Cancellable, err **L.Error) T.Guchar
	DataInputStreamReadInt16       func(d *DataInputStream, cancellable *Cancellable, err **L.Error) int16
	DataInputStreamReadInt32       func(d *DataInputStream, cancellable *Cancellable, err **L.Error) T.GInt32
	DataInputStreamReadInt64       func(d *DataInputStream, cancellable *Cancellable, err **L.Error) int64
	DataInputStreamReadLine        func(d *DataInputStream, length *T.Gsize, cancellable *Cancellable, err **L.Error) string
	DataInputStreamReadLineAsync   func(d *DataInputStream, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DataInputStreamReadLineFinish  func(d *DataInputStream, result *AsyncResult, length *T.Gsize, err **L.Error) string
	DataInputStreamReadUint16      func(d *DataInputStream, cancellable *Cancellable, err **L.Error) uint16
	DataInputStreamReadUint32      func(d *DataInputStream, cancellable *Cancellable, err **L.Error) T.GUint32
	DataInputStreamReadUint64      func(d *DataInputStream, cancellable *Cancellable, err **L.Error) uint64
	DataInputStreamReadUntil       func(d *DataInputStream, stopChars string, length *T.Gsize, cancellable *Cancellable, err **L.Error) string
	DataInputStreamReadUntilAsync  func(d *DataInputStream, stopChars string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DataInputStreamReadUntilFinish func(d *DataInputStream, result *AsyncResult, length *T.Gsize, err **L.Error) string
	DataInputStreamReadUpto        func(d *DataInputStream, stopChars string, stopCharsLen T.Gssize, length *T.Gsize, cancellable *Cancellable, err **L.Error) string
	DataInputStreamReadUptoAsync   func(d *DataInputStream, stopChars string, stopCharsLen T.Gssize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DataInputStreamReadUptoFinish  func(d *DataInputStream, result *AsyncResult, length *T.Gsize, err **L.Error) string
	DataInputStreamSetByteOrder    func(d *DataInputStream, order DataStreamByteOrder)
	DataInputStreamSetNewlineType  func(d *DataInputStream, typ DataStreamNewlineType)
)
View Source 
var (
	DataOutputStreamGetType func() O.Type
	DataOutputStreamNew     func(baseStream *OutputStream) *DataOutputStream

	DataOutputStreamGetByteOrder func(d *DataOutputStream) DataStreamByteOrder
	DataOutputStreamPutByte      func(d *DataOutputStream, data T.Guchar, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutInt16     func(d *DataOutputStream, data int16, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutInt32     func(d *DataOutputStream, data T.GInt32, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutInt64     func(d *DataOutputStream, data int64, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutString    func(d *DataOutputStream, str string, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutUint16    func(d *DataOutputStream, data uint16, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutUint32    func(d *DataOutputStream, data T.GUint32, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamPutUint64    func(d *DataOutputStream, data uint64, cancellable *Cancellable, err **L.Error) bool
	DataOutputStreamSetByteOrder func(d *DataOutputStream, order DataStreamByteOrder)
)
View Source 
var (
	DBusAddressGetForBusSync   func(busType BusType, cancellable *Cancellable, err **L.Error) string
	DBusAddressGetStream       func(address string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusAddressGetStreamFinish func(res *AsyncResult, outGuid **T.Gchar, err **L.Error) *IOStream
	DBusAddressGetStreamSync   func(address string, outGuid **T.Gchar, cancellable *Cancellable, err **L.Error) *IOStream
)
View Source 
var (
	DBusAnnotationInfoGetType func() O.Type

	DBusAnnotationInfoLookup func(annotations **DBusAnnotationInfo, name string) string

	DBusAnnotationInfoRef   func(d *DBusAnnotationInfo) *DBusAnnotationInfo
	DBusAnnotationInfoUnref func(d *DBusAnnotationInfo)
)
View Source 
var (
	DBusArgInfoGetType func() O.Type

	DBusArgInfoRef   func(d *DBusArgInfo) *DBusArgInfo
	DBusArgInfoUnref func(d *DBusArgInfo)
)
View Source 
var (
	DBusAuthObserverGetType func() O.Type
	DBusAuthObserverNew     func() *DBusAuthObserver

	DBusAuthObserverAuthorizeAuthenticatedPeer func(d *DBusAuthObserver, stream *IOStream, credentials *Credentials) bool
)
View Source 
var (
	DBusConnectionGetType             func() O.Type
	DBusConnectionNew                 func(d *IOStream, guid string, flags DBusConnectionFlags, observer *DBusAuthObserver, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionNewFinish           func(res *AsyncResult, err **L.Error) *DBusConnection
	DBusConnectionNewForAddress       func(address string, flags DBusConnectionFlags, observer *DBusAuthObserver, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionNewForAddressFinish func(res *AsyncResult, err **L.Error) *DBusConnection
	DBusConnectionNewForAddressSync   func(address string, flags DBusConnectionFlags, observer *DBusAuthObserver, cancellable *Cancellable, err **L.Error) *DBusConnection
	DBusConnectionNewSync             func(d *IOStream, guid string, flags DBusConnectionFlags, observer *DBusAuthObserver, cancellable *Cancellable, err **L.Error) *DBusConnection

	DBusConnectionAddFilter                  func(d *DBusConnection, filterFunction DBusMessageFilterFunction, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	DBusConnectionCall                       func(d *DBusConnection, busName, objectPath, interfaceName, methodName string, parameters *L.Variant, replyType *L.VariantType, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionCallFinish                 func(d *DBusConnection, res *AsyncResult, err **L.Error) *L.Variant
	DBusConnectionCallSync                   func(d *DBusConnection, busName, objectPath, interfaceName, methodName string, parameters *L.Variant, replyType *L.VariantType, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, err **L.Error) *L.Variant
	DBusConnectionClose                      func(d *DBusConnection, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionCloseFinish                func(d *DBusConnection, res *AsyncResult, err **L.Error) bool
	DBusConnectionCloseSync                  func(d *DBusConnection, cancellable *Cancellable, err **L.Error) bool
	DBusConnectionEmitSignal                 func(d *DBusConnection, destinationBusName, objectPath, interfaceName string, signalName string, parameters *L.Variant, err **L.Error) bool
	DBusConnectionFlush                      func(d *DBusConnection, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionFlushFinish                func(d *DBusConnection, res *AsyncResult, err **L.Error) bool
	DBusConnectionFlushSync                  func(d *DBusConnection, cancellable *Cancellable, err **L.Error) bool
	DBusConnectionGetCapabilities            func(d *DBusConnection) DBusCapabilityFlags
	DBusConnectionGetExitOnClose             func(d *DBusConnection) bool
	DBusConnectionGetGuid                    func(d *DBusConnection) string
	DBusConnectionGetPeerCredentials         func(d *DBusConnection) *Credentials
	DBusConnectionGetStream                  func(d *DBusConnection) *IOStream
	DBusConnectionGetUniqueName              func(d *DBusConnection) string
	DBusConnectionIsClosed                   func(d *DBusConnection) bool
	DBusConnectionRegisterObject             func(d *DBusConnection, objectPath string, interfaceInfo *DBusInterfaceInfo, vtable *DBusInterfaceVTable, userData T.Gpointer, userDataFreeFunc O.DestroyNotify, err **L.Error) uint
	DBusConnectionRegisterSubtree            func(d *DBusConnection, objectPath string, vtable *DBusSubtreeVTable, flags DBusSubtreeFlags, userData T.Gpointer, userDataFreeFunc O.DestroyNotify, err **L.Error) uint
	DBusConnectionRemoveFilter               func(d *DBusConnection, filterId uint)
	DBusConnectionSendMessage                func(d *DBusConnection, message *DBusMessage, flags DBusSendMessageFlags, outSerial *T.GUint32, err **L.Error) bool
	DBusConnectionSendMessageWithReply       func(d *DBusConnection, message *DBusMessage, flags DBusSendMessageFlags, timeoutMsec int, outSerial *T.GUint32, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusConnectionSendMessageWithReplyFinish func(d *DBusConnection, res *AsyncResult, err **L.Error) *DBusMessage
	DBusConnectionSendMessageWithReplySync   func(d *DBusConnection, message *DBusMessage, flags DBusSendMessageFlags, timeoutMsec int, outSerial *T.GUint32, cancellable *Cancellable, err **L.Error) *DBusMessage
	DBusConnectionSetExitOnClose             func(d *DBusConnection, exitOnClose bool)
	DBusConnectionSignalSubscribe            func(d *DBusConnection, sender, interfaceName, member, objectPath, arg0 string, flags DBusSignalFlags, callback DBusSignalCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint
	DBusConnectionSignalUnsubscribe          func(d *DBusConnection, subscriptionId uint)
	DBusConnectionStartMessageProcessing     func(d *DBusConnection)
	DBusConnectionUnregisterObject           func(d *DBusConnection, registrationId uint) bool
	DBusConnectionUnregisterSubtree          func(d *DBusConnection, registrationId uint) bool
)
View Source 
var (
	DBusErrorEncodeGerror        func(err *L.Error) string
	DBusErrorGetRemoteError      func(err *L.Error) string
	DBusErrorIsRemoteError       func(err *L.Error) bool
	DBusErrorNewForDBusError     func(dbusErrorName string, dbusErrorMessage string) *L.Error
	DBusErrorQuark               func() L.Quark
	DBusErrorRegisterError       func(errorDomain L.Quark, errorCode int, dbusErrorName string) bool
	DBusErrorRegisterErrorDomain func(errorDomainQuarkName string, quarkVolatile *T.Gsize, entries *DBusErrorEntry, numEntries uint)
	DBusErrorSetDBusError        func(e **L.Error, dbusErrorName, dbusErrorMessage, format string, v ...VArg)
	DBusErrorSetDBusErrorValist  func(err **L.Error, dbusErrorName string, dbusErrorMessage string, format string, varArgs VAList)
	DBusErrorStripRemoteError    func(err *L.Error) bool
	DBusErrorUnregisterError     func(errorDomain L.Quark, errorCode int, dbusErrorName string) bool
)
View Source 
var (
	DBusInterfaceInfoGetType func() O.Type

	DBusInterfaceInfoGenerateXml    func(d *DBusInterfaceInfo, indent uint, stringBuilder *L.String)
	DBusInterfaceInfoLookupMethod   func(d *DBusInterfaceInfo, name string) *DBusMethodInfo
	DBusInterfaceInfoLookupProperty func(d *DBusInterfaceInfo, name string) *DBusPropertyInfo
	DBusInterfaceInfoLookupSignal   func(d *DBusInterfaceInfo, name string) *DBusSignalInfo
	DBusInterfaceInfoRef            func(d *DBusInterfaceInfo) *DBusInterfaceInfo
	DBusInterfaceInfoUnref          func(d *DBusInterfaceInfo)
)
View Source 
var (
	DBusIsAddress          func(string string) bool
	DBusIsGuid             func(string string) bool
	DBusIsInterfaceName    func(string string) bool
	DBusIsMemberName       func(string string) bool
	DBusIsName             func(string string) bool
	DBusIsSupportedAddress func(string string, err **L.Error) bool
	DBusIsUniqueName       func(string string) bool
)
View Source 
var (
	DBusMessageGetType       func() O.Type
	DBusMessageNew           func() *DBusMessage
	DBusMessageNewFromBlob   func(blob *T.Guchar, blobLen T.Gsize, capabilities DBusCapabilityFlags, err **L.Error) *DBusMessage
	DBusMessageNewMethodCall func(name string, path string, interface_ string, method string) *DBusMessage
	DBusMessageNewSignal     func(path string, interface_ string, signal string) *DBusMessage

	DBusMessageBytesNeeded func(blob *T.Guchar, blobLen T.Gsize, err **L.Error) T.Gssize

	DBusMessageCopy                  func(d *DBusMessage, err **L.Error) *DBusMessage
	DBusMessageGetArg0               func(d *DBusMessage) string
	DBusMessageGetBody               func(d *DBusMessage) *L.Variant
	DBusMessageGetByteOrder          func(d *DBusMessage) DBusMessageByteOrder
	DBusMessageGetDestination        func(d *DBusMessage) string
	DBusMessageGetErrorName          func(d *DBusMessage) string
	DBusMessageGetFlags              func(d *DBusMessage) DBusMessageFlags
	DBusMessageGetHeader             func(d *DBusMessage, headerField DBusMessageHeaderField) *L.Variant
	DBusMessageGetHeaderFields       func(d *DBusMessage) *T.Guchar
	DBusMessageGetInterface          func(d *DBusMessage) string
	DBusMessageGetLocked             func(d *DBusMessage) bool
	DBusMessageGetMember             func(d *DBusMessage) string
	DBusMessageGetMessageType        func(d *DBusMessage) DBusMessageType
	DBusMessageGetNumUnixFds         func(d *DBusMessage) T.GUint32
	DBusMessageGetPath               func(d *DBusMessage) string
	DBusMessageGetReplySerial        func(d *DBusMessage) T.GUint32
	DBusMessageGetSender             func(d *DBusMessage) string
	DBusMessageGetSerial             func(d *DBusMessage) T.GUint32
	DBusMessageGetSignature          func(d *DBusMessage) string
	DBusMessageGetUnixFdList         func(d *DBusMessage) *T.GUnixFDList
	DBusMessageLock                  func(d *DBusMessage)
	DBusMessageNewMethodError        func(d *DBusMessage, errorName, errorMessageFormat string, v ...VArg) *DBusMessage
	DBusMessageNewMethodErrorLiteral func(d *DBusMessage, errorName, errorMessage string) *DBusMessage
	DBusMessageNewMethodErrorValist  func(d *DBusMessage, errorName, errorMessageFormat string, varArgs VAList) *DBusMessage
	DBusMessageNewMethodReply        func(d *DBusMessage) *DBusMessage
	DBusMessagePrint                 func(d *DBusMessage, indent uint) string
	DBusMessageSetBody               func(d *DBusMessage, body *L.Variant)
	DBusMessageSetByteOrder          func(d *DBusMessage, byteOrder DBusMessageByteOrder)
	DBusMessageSetDestination        func(d *DBusMessage, value string)
	DBusMessageSetErrorName          func(d *DBusMessage, value string)
	DBusMessageSetFlags              func(d *DBusMessage, flags DBusMessageFlags)
	DBusMessageSetHeader             func(d *DBusMessage, headerField DBusMessageHeaderField, value *L.Variant)
	DBusMessageSetInterface          func(d *DBusMessage, value string)
	DBusMessageSetMember             func(d *DBusMessage, value string)
	DBusMessageSetMessageType        func(d *DBusMessage, typ DBusMessageType)
	DBusMessageSetNumUnixFds         func(d *DBusMessage, value T.GUint32)
	DBusMessageSetPath               func(d *DBusMessage, value string)
	DBusMessageSetReplySerial        func(d *DBusMessage, value T.GUint32)
	DBusMessageSetSender             func(d *DBusMessage, value string)
	DBusMessageSetSerial             func(d *DBusMessage, serial T.GUint32)
	DBusMessageSetSignature          func(d *DBusMessage, value string)
	DBusMessageSetUnixFdList         func(d *DBusMessage, fdList *T.GUnixFDList)
	DBusMessageToBlob                func(d *DBusMessage, outSize *T.Gsize, capabilities DBusCapabilityFlags, err **L.Error) *T.Guchar
	DBusMessageToGerror              func(d *DBusMessage, err **L.Error) bool
)
View Source 
var (
	DBusMethodInfoGetType func() O.Type

	DBusMethodInfoRef   func(d *DBusMethodInfo) *DBusMethodInfo
	DBusMethodInfoUnref func(d *DBusMethodInfo)
)
View Source 
var (
	DBusMethodInvocationGetType func() O.Type

	DBusMethodInvocationGetConnection      func(d *DBusMethodInvocation) *DBusConnection
	DBusMethodInvocationGetInterfaceName   func(d *DBusMethodInvocation) string
	DBusMethodInvocationGetMessage         func(d *DBusMethodInvocation) *DBusMessage
	DBusMethodInvocationGetMethodInfo      func(d *DBusMethodInvocation) *DBusMethodInfo
	DBusMethodInvocationGetMethodName      func(d *DBusMethodInvocation) string
	DBusMethodInvocationGetObjectPath      func(d *DBusMethodInvocation) string
	DBusMethodInvocationGetParameters      func(d *DBusMethodInvocation) *L.Variant
	DBusMethodInvocationGetSender          func(d *DBusMethodInvocation) string
	DBusMethodInvocationGetUserData        func(d *DBusMethodInvocation) T.Gpointer
	DBusMethodInvocationReturnDBusError    func(d *DBusMethodInvocation, errorName, errorMessage string)
	DBusMethodInvocationReturnError        func(d *DBusMethodInvocation, domain L.Quark, code int, format string, v ...VArg)
	DBusMethodInvocationReturnErrorLiteral func(d *DBusMethodInvocation, domain L.Quark, code int, message string)
	DBusMethodInvocationReturnErrorValist  func(d *DBusMethodInvocation, domain L.Quark, code int, format string, varArgs VAList)
	DBusMethodInvocationReturnGerror       func(d *DBusMethodInvocation, err *L.Error)
	DBusMethodInvocationReturnValue        func(d *DBusMethodInvocation, parameters *L.Variant)
)
View Source 
var (
	DBusNodeInfoGetType   func() O.Type
	DBusNodeInfoNewForXml func(xmlData string, err **L.Error) *DBusNodeInfo

	DBusNodeInfoGenerateXml     func(d *DBusNodeInfo, indent uint, stringBuilder *L.String)
	DBusNodeInfoLookupInterface func(d *DBusNodeInfo, name string) *DBusInterfaceInfo
	DBusNodeInfoRef             func(d *DBusNodeInfo) *DBusNodeInfo
	DBusNodeInfoUnref           func(d *DBusNodeInfo)
)
View Source 
var (
	DBusPropertyInfoGetType func() O.Type

	DBusPropertyInfoRef   func(d *DBusPropertyInfo) *DBusPropertyInfo
	DBusPropertyInfoUnref func(d *DBusPropertyInfo)
)
View Source 
var (
	DBusProxyGetType         func() O.Type
	DBusProxyNew             func(d *DBusConnection, flags DBusProxyFlags, info *DBusInterfaceInfo, name string, objectPath string, interfaceName string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusProxyNewFinish       func(res *AsyncResult, err **L.Error) *DBusProxy
	DBusProxyNewForBus       func(busType BusType, flags DBusProxyFlags, info *DBusInterfaceInfo, name string, objectPath string, interfaceName string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusProxyNewForBusFinish func(res *AsyncResult, err **L.Error) *DBusProxy
	DBusProxyNewForBusSync   func(busType BusType, flags DBusProxyFlags, info *DBusInterfaceInfo, name string, objectPath string, interfaceName string, cancellable *Cancellable, err **L.Error) *DBusProxy
	DBusProxyNewSync         func(d *DBusConnection, flags DBusProxyFlags, info *DBusInterfaceInfo, name string, objectPath string, interfaceName string, cancellable *Cancellable, err **L.Error) *DBusProxy

	DBusProxyCall                   func(d *DBusProxy, methodName string, parameters *L.Variant, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DBusProxyCallFinish             func(d *DBusProxy, res *AsyncResult, err **L.Error) *L.Variant
	DBusProxyCallSync               func(d *DBusProxy, methodName string, parameters *L.Variant, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, err **L.Error) *L.Variant
	DBusProxyGetCachedProperty      func(d *DBusProxy, propertyName string) *L.Variant
	DBusProxyGetCachedPropertyNames func(d *DBusProxy) []string
	DBusProxyGetConnection          func(d *DBusProxy) *DBusConnection
	DBusProxyGetDefaultTimeout      func(d *DBusProxy) int
	DBusProxyGetFlags               func(d *DBusProxy) DBusProxyFlags
	DBusProxyGetInterfaceInfo       func(d *DBusProxy) *DBusInterfaceInfo
	DBusProxyGetInterfaceName       func(d *DBusProxy) string
	DBusProxyGetName                func(d *DBusProxy) string
	DBusProxyGetNameOwner           func(d *DBusProxy) string
	DBusProxyGetObjectPath          func(d *DBusProxy) string
	DBusProxySetCachedProperty      func(d *DBusProxy, propertyName string, value *L.Variant)
	DBusProxySetDefaultTimeout      func(d *DBusProxy, timeoutMsec int)
	DBusProxySetInterfaceInfo       func(d *DBusProxy, info *DBusInterfaceInfo)
)
View Source 
var (
	DBusServerGetType func() O.Type
	DBusServerNewSync func(address string, flags DBusServerFlags, guid string, observer *DBusAuthObserver, cancellable *Cancellable, err **L.Error) *DBusServer

	DBusServerGetClientAddress func(d *DBusServer) string
	DBusServerGetFlags         func(d *DBusServer) DBusServerFlags
	DBusServerGetGuid          func(d *DBusServer) string
	DBusServerIsActive         func(d *DBusServer) bool
	DBusServerStart            func(d *DBusServer)
	DBusServerStop             func(d *DBusServer)
)
View Source 
var (
	DBusSignalInfoGetType func() O.Type

	DBusSignalInfoRef   func(d *DBusSignalInfo) *DBusSignalInfo
	DBusSignalInfoUnref func(d *DBusSignalInfo)
)
View Source 
var (
	DriveGetType func() O.Type

	DriveCanEject                 func(d *Drive) bool
	DriveCanPollForMedia          func(d *Drive) bool
	DriveCanStart                 func(d *Drive) bool
	DriveCanStartDegraded         func(d *Drive) bool
	DriveCanStop                  func(d *Drive) bool
	DriveEject                    func(d *Drive, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DriveEjectFinish              func(d *Drive, result *AsyncResult, err **L.Error) bool
	DriveEjectWithOperation       func(d *Drive, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DriveEjectWithOperationFinish func(d *Drive, result *AsyncResult, err **L.Error) bool
	DriveEnumerateIdentifiers     func(d *Drive) []string
	DriveGetIcon                  func(d *Drive) *Icon
	DriveGetIdentifier            func(d *Drive, kind string) string
	DriveGetName                  func(d *Drive) string
	DriveGetStartStopType         func(d *Drive) DriveStartStopType
	DriveGetVolumes               func(d *Drive) *L.List
	DriveHasMedia                 func(d *Drive) bool
	DriveHasVolumes               func(d *Drive) bool
	DriveIsMediaCheckAutomatic    func(d *Drive) bool
	DriveIsMediaRemovable         func(d *Drive) bool
	DrivePollForMedia             func(d *Drive, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DrivePollForMediaFinish       func(d *Drive, result *AsyncResult, err **L.Error) bool
	DriveStart                    func(d *Drive, flags DriveStartFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DriveStartFinish              func(d *Drive, result *AsyncResult, err **L.Error) bool
	DriveStop                     func(d *Drive, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	DriveStopFinish               func(d *Drive, result *AsyncResult, err **L.Error) bool
)
View Source 
var (
	EmblemGetType       func() O.Type
	EmblemNew           func(icon *Icon) *Emblem
	EmblemNewWithOrigin func(icon *Icon, origin EmblemOrigin) *Emblem

	EmblemGetIcon   func(e *Emblem) *Icon
	EmblemGetOrigin func(e *Emblem) EmblemOrigin
)
View Source 
var (
	EmblemedIconGetType func() O.Type
	EmblemedIconNew     func(icon *Icon, emblem *Emblem) *Icon

	EmblemedIconGetIcon      func(e *EmblemedIcon) *Icon
	EmblemedIconGetEmblems   func(e *EmblemedIcon) *L.List
	EmblemedIconAddEmblem    func(e *EmblemedIcon, emblem *Emblem)
	EmblemedIconClearEmblems func(e *EmblemedIcon)
)
View Source 
var (
	FileGetType              func() O.Type
	FileNewForPath           func(path string) *File
	FileNewForUri            func(uri string) *File
	FileNewForCommandlineArg func(arg string) *File

	FileParseName func(parseName string) *File
	FileHash      func(file T.Gconstpointer) uint

	FileAppendTo                            func(f *File, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream
	FileAppendToAsync                       func(f *File, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileAppendToFinish                      func(f *File, res *AsyncResult, err **L.Error) *FileOutputStream
	FileCopy                                func(f, destination *File, flags FileCopyFlags, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, err **L.Error) bool
	FileCopyAsync                           func(f, destination *File, flags FileCopyFlags, ioPriority int, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, callback AsyncReadyCallback, userData T.Gpointer)
	FileCopyAttributes                      func(f, destination *File, flags FileCopyFlags, cancellable *Cancellable, err **L.Error) bool
	FileCopyFinish                          func(f *File, res *AsyncResult, err **L.Error) bool
	FileCreate                              func(f *File, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream
	FileCreateAsync                         func(f *File, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileCreateFinish                        func(f *File, res *AsyncResult, err **L.Error) *FileOutputStream
	FileCreateReadwrite                     func(f *File, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileIOStream
	FileCreateReadwriteAsync                func(f *File, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileCreateReadwriteFinish               func(f *File, res *AsyncResult, err **L.Error) *FileIOStream
	FileDelete                              func(f *File, cancellable *Cancellable, err **L.Error) bool
	FileDup                                 func(f *File) *File
	FileEjectMountable                      func(f *File, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileEjectMountableFinish                func(f *File, result *AsyncResult, err **L.Error) bool
	FileEjectMountableWithOperation         func(f *File, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileEjectMountableWithOperationFinish   func(f *File, result *AsyncResult, err **L.Error) bool
	FileEnumerateChildren                   func(f *File, attributes string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) *FileEnumerator
	FileEnumerateChildrenAsync              func(f *File, attributes string, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileEnumerateChildrenFinish             func(f *File, res *AsyncResult, err **L.Error) *FileEnumerator
	FileEqual                               func(f, file2 *File) bool
	FileFindEnclosingMount                  func(f *File, cancellable *Cancellable, err **L.Error) *Mount
	FileFindEnclosingMountAsync             func(f *File, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileFindEnclosingMountFinish            func(f *File, res *AsyncResult, err **L.Error) *Mount
	FileGetBasename                         func(f *File) string
	FileGetChild                            func(f *File, name string) *File
	FileGetChildForDisplayName              func(f *File, displayName string, err **L.Error) *File
	FileGetParent                           func(f *File) *File
	FileGetParseName                        func(f *File) string
	FileGetPath                             func(f *File) string
	FileGetRelativePath                     func(f *File, descendant *File) string
	FileGetUri                              func(f *File) string
	FileGetUriScheme                        func(f *File) string
	FileHasParent                           func(f, parent *File) bool
	FileHasPrefix                           func(f, prefix *File) bool
	FileHasUriScheme                        func(f *File, uriScheme string) bool
	FileIsNative                            func(f *File) bool
	FileLoadContents                        func(f *File, cancellable *Cancellable, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool
	FileLoadContentsAsync                   func(f *File, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileLoadContentsFinish                  func(f *File, res *AsyncResult, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool
	FileLoadPartialContentsAsync            func(f *File, cancellable *Cancellable, readMoreCallback FileReadMoreCallback, callback AsyncReadyCallback, userData T.Gpointer)
	FileLoadPartialContentsFinish           func(f *File, res *AsyncResult, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool
	FileMakeDirectory                       func(f *File, cancellable *Cancellable, err **L.Error) bool
	FileMakeDirectoryWithParents            func(f *File, cancellable *Cancellable, err **L.Error) bool
	FileMakeSymbolicLink                    func(f *File, symlinkValue string, cancellable *Cancellable, err **L.Error) bool
	FileMonitor_                            func(f *File, flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor
	FileMonitorDirectory                    func(f *File, flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor
	FileMonitorFile                         func(f *File, flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor
	FileMountEnclosingVolume                func(f *File, flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileMountEnclosingVolumeFinish          func(f *File, result *AsyncResult, err **L.Error) bool
	FileMountMountable                      func(f *File, flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileMountMountableFinish                func(f *File, result *AsyncResult, err **L.Error) *File
	FileMove                                func(f *File, destination *File, flags FileCopyFlags, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, err **L.Error) bool
	FileOpenReadwrite                       func(f *File, cancellable *Cancellable, err **L.Error) *FileIOStream
	FileOpenReadwriteAsync                  func(f *File, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileOpenReadwriteFinish                 func(f *File, res *AsyncResult, err **L.Error) *FileIOStream
	FilePollMountable                       func(f *File, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FilePollMountableFinish                 func(f *File, result *AsyncResult, err **L.Error) bool
	FileQueryDefaultHandler                 func(f *File, cancellable *Cancellable, err **L.Error) *AppInfo
	FileQueryExists                         func(f *File, cancellable *Cancellable) bool
	FileQueryFilesystemInfo                 func(f *File, attributes string, cancellable *Cancellable, err **L.Error) *FileInfo
	FileQueryFilesystemInfoAsync            func(f *File, attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileQueryFilesystemInfoFinish           func(f *File, res *AsyncResult, err **L.Error) *FileInfo
	FileQueryFileType                       func(f *File, flags FileQueryInfoFlags, cancellable *Cancellable) FileType
	FileQueryInfo                           func(f *File, attributes string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) *FileInfo
	FileQueryInfoAsync                      func(f *File, attributes string, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileQueryInfoFinish                     func(f *File, res *AsyncResult, err **L.Error) *FileInfo
	FileQuerySettableAttributes             func(f *File, cancellable *Cancellable, err **L.Error) *FileAttributeInfoList
	FileQueryWritableNamespaces             func(f *File, cancellable *Cancellable, err **L.Error) *FileAttributeInfoList
	FileRead                                func(f *File, cancellable *Cancellable, err **L.Error) *FileInputStream
	FileReadAsync                           func(f *File, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileReadFinish                          func(f *File, res *AsyncResult, err **L.Error) *FileInputStream
	FileReplace                             func(f *File, etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream
	FileReplaceAsync                        func(f *File, etag string, makeBackup bool, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileReplaceContents                     func(f *File, contents string, length T.Gsize, etag string, makeBackup bool, flags FileCreateFlags, newEtag **T.Char, cancellable *Cancellable, err **L.Error) bool
	FileReplaceContentsAsync                func(f *File, contents string, length T.Gsize, etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileReplaceContentsFinish               func(f *File, res *AsyncResult, newEtag **T.Char, err **L.Error) bool
	FileReplaceFinish                       func(f *File, res *AsyncResult, err **L.Error) *FileOutputStream
	FileReplaceReadwrite                    func(f *File, etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileIOStream
	FileReplaceReadwriteAsync               func(f *File, etag string, makeBackup bool, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileReplaceReadwriteFinish              func(f *File, res *AsyncResult, err **L.Error) *FileIOStream
	FileResolveRelativePath                 func(f *File, relativePath string) *File
	FileSetAttribute                        func(f *File, attribute string, typ FileAttributeType, valueP T.Gpointer, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeByteString              func(f *File, attribute, value string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeInt32                   func(f *File, attribute string, value T.GInt32, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeInt64                   func(f *File, attribute string, value int64, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributesAsync                  func(f *File, info *FileInfo, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileSetAttributesFinish                 func(f *File, result *AsyncResult, info **FileInfo, err **L.Error) bool
	FileSetAttributesFromInfo               func(f *File, info *FileInfo, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeString                  func(f *File, attribute, value string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeUint32                  func(f *File, attribute string, value T.GUint32, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetAttributeUint64                  func(f *File, attribute string, value uint64, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool
	FileSetDisplayName                      func(f *File, displayName string, cancellable *Cancellable, err **L.Error) *File
	FileSetDisplayNameAsync                 func(f *File, displayName string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileSetDisplayNameFinish                func(f *File, res *AsyncResult, err **L.Error) *File
	FileStartMountable                      func(f *File, flags DriveStartFlags, startOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileStartMountableFinish                func(f *File, result *AsyncResult, err **L.Error) bool
	FileStopMountable                       func(f *File, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileStopMountableFinish                 func(f *File, result *AsyncResult, err **L.Error) bool
	FileSupportsThreadContexts              func(f *File) bool
	FileTrash                               func(f *File, cancellable *Cancellable, err **L.Error) bool
	FileUnmountMountable                    func(f *File, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileUnmountMountableFinish              func(f *File, result *AsyncResult, err **L.Error) bool
	FileUnmountMountableWithOperation       func(f *File, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileUnmountMountableWithOperationFinish func(f *File, result *AsyncResult, err **L.Error) bool
)
View Source 
var (
	FileAttributeInfoListGetType func() O.Type
	FileAttributeInfoListNew     func() *FileAttributeInfoList

	FileAttributeInfoListAdd    func(f *FileAttributeInfoList, name string, typ FileAttributeType, flags FileAttributeInfoFlags)
	FileAttributeInfoListDup    func(f *FileAttributeInfoList) *FileAttributeInfoList
	FileAttributeInfoListLookup func(f *FileAttributeInfoList, name string) *FileAttributeInfo
	FileAttributeInfoListRef    func(f *FileAttributeInfoList) *FileAttributeInfoList
	FileAttributeInfoListUnref  func(f *FileAttributeInfoList)
)
View Source 
var (
	FileAttributeMatcherGetType func() O.Type
	FileAttributeMatcherNew     func(attributes string) *FileAttributeMatcher

	FileAttributeMatcherEnumerateNamespace func(f *FileAttributeMatcher, ns string) bool
	FileAttributeMatcherEnumerateNext      func(f *FileAttributeMatcher) string
	FileAttributeMatcherMatches            func(f *FileAttributeMatcher, attribute string) bool
	FileAttributeMatcherMatchesOnly        func(f *FileAttributeMatcher, attribute string) bool
	FileAttributeMatcherRef                func(f *FileAttributeMatcher) *FileAttributeMatcher
	FileAttributeMatcherUnref              func(f *FileAttributeMatcher)
)
View Source 
var (
	FileEnumeratorGetType func() O.Type

	FileEnumeratorNextFile        func(f *FileEnumerator, cancellable *Cancellable, err **L.Error) *FileInfo
	FileEnumeratorClose           func(f *FileEnumerator, cancellable *Cancellable, err **L.Error) bool
	FileEnumeratorNextFilesAsync  func(f *FileEnumerator, numFiles, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileEnumeratorNextFilesFinish func(f *FileEnumerator, result *AsyncResult, err **L.Error) *L.List
	FileEnumeratorCloseAsync      func(f *FileEnumerator, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileEnumeratorCloseFinish     func(f *FileEnumerator, result *AsyncResult, err **L.Error) bool
	FileEnumeratorIsClosed        func(f *FileEnumerator) bool
	FileEnumeratorHasPending      func(f *FileEnumerator) bool
	FileEnumeratorSetPending      func(f *FileEnumerator, pending bool)
	FileEnumeratorGetContainer    func(f *FileEnumerator) *File
)
View Source 
var (
	FileIconGetType func() O.Type
	FileIconNew     func(file *File) *Icon

	FileIconGetFile func(f *FileIcon) *File
)
View Source 
var (
	FileInfoGetType func() O.Type
	FileInfoNew     func() *FileInfo

	FileInfoDup      func(other *FileInfo) *FileInfo
	FileInfoCopyInto func(srcInfo, destInfo *FileInfo)

	FileInfoClearStatus            func(f *FileInfo)
	FileInfoGetAttributeAsString   func(f *FileInfo, attribute string) string
	FileInfoGetAttributeBoolean    func(f *FileInfo, attribute string) bool
	FileInfoGetAttributeByteString func(f *FileInfo, attribute string) string
	FileInfoGetAttributeData       func(f *FileInfo, attribute string, typ *FileAttributeType, valuePp *T.Gpointer, status *FileAttributeStatus) bool
	FileInfoGetAttributeInt32      func(f *FileInfo, attribute string) T.GInt32
	FileInfoGetAttributeInt64      func(f *FileInfo, attribute string) int64
	FileInfoGetAttributeObject     func(f *FileInfo, attribute string) *O.Object
	FileInfoGetAttributeStatus     func(f *FileInfo, attribute string) FileAttributeStatus
	FileInfoGetAttributeString     func(f *FileInfo, attribute string) string
	FileInfoGetAttributeStringv    func(f *FileInfo, attribute string) []string
	FileInfoGetAttributeType       func(f *FileInfo, attribute string) FileAttributeType
	FileInfoGetAttributeUint32     func(f *FileInfo, attribute string) T.GUint32
	FileInfoGetAttributeUint64     func(f *FileInfo, attribute string) uint64
	FileInfoGetContentType         func(f *FileInfo) string
	FileInfoGetDisplayName         func(f *FileInfo) string
	FileInfoGetEditName            func(f *FileInfo) string
	FileInfoGetEtag                func(f *FileInfo) string
	FileInfoGetFileType            func(f *FileInfo) FileType
	FileInfoGetIcon                func(f *FileInfo) *Icon
	FileInfoGetIsBackup            func(f *FileInfo) bool
	FileInfoGetIsHidden            func(f *FileInfo) bool
	FileInfoGetIsSymlink           func(f *FileInfo) bool
	FileInfoGetModificationTime    func(f *FileInfo, result *L.TimeVal)
	FileInfoGetName                func(f *FileInfo) string
	FileInfoGetSize                func(f *FileInfo) T.Goffset
	FileInfoGetSortOrder           func(f *FileInfo) T.GInt32
	FileInfoGetSymlinkTarget       func(f *FileInfo) string
	FileInfoHasAttribute           func(f *FileInfo, attribute string) bool
	FileInfoHasNamespace           func(f *FileInfo, nameSpace string) bool
	FileInfoListAttributes         func(f *FileInfo, nameSpace string) []string
	FileInfoRemoveAttribute        func(f *FileInfo, attribute string)
	FileInfoSetAttribute           func(f *FileInfo, attribute string, typ FileAttributeType, valueP T.Gpointer)
	FileInfoSetAttributeBoolean    func(f *FileInfo, attribute string, attrValue bool)
	FileInfoSetAttributeByteString func(f *FileInfo, attribute, attrValue string)
	FileInfoSetAttributeInt32      func(f *FileInfo, attribute string, attrValue T.GInt32)
	FileInfoSetAttributeInt64      func(f *FileInfo, attribute string, attrValue int64)
	FileInfoSetAttributeMask       func(f *FileInfo, mask *FileAttributeMatcher)
	FileInfoSetAttributeObject     func(f *FileInfo, attribute string, attrValue *O.Object)
	FileInfoSetAttributeStatus     func(f *FileInfo, attribute string, status FileAttributeStatus) bool
	FileInfoSetAttributeString     func(f *FileInfo, attribute, attrValue string)
	FileInfoSetAttributeStringv    func(f *FileInfo, attribute string, attrValue **T.Char)
	FileInfoSetAttributeUint32     func(f *FileInfo, attribute string, attrValue T.GUint32)
	FileInfoSetAttributeUint64     func(f *FileInfo, attribute string, attrValue uint64)
	FileInfoSetContentType         func(f *FileInfo, contentType string)
	FileInfoSetDisplayName         func(f *FileInfo, displayName string)
	FileInfoSetEditName            func(f *FileInfo, editName string)
	FileInfoSetFileType            func(f *FileInfo, typ FileType)
	FileInfoSetIcon                func(f *FileInfo, icon *Icon)
	FileInfoSetIsHidden            func(f *FileInfo, isHidden bool)
	FileInfoSetIsSymlink           func(f *FileInfo, isSymlink bool)
	FileInfoSetModificationTime    func(f *FileInfo, mtime *L.TimeVal)
	FileInfoSetName                func(f *FileInfo, name string)
	FileInfoSetSize                func(f *FileInfo, size T.Goffset)
	FileInfoSetSortOrder           func(f *FileInfo, sortOrder T.GInt32)
	FileInfoSetSymlinkTarget       func(f *FileInfo, symlinkTarget string)
	FileInfoUnsetAttributeMask     func(f *FileInfo)
)
View Source 
var (
	FileInputStreamGetType func() O.Type

	FileInputStreamQueryInfo       func(f *FileInputStream, attributes string, cancellable *Cancellable, err **L.Error) *FileInfo
	FileInputStreamQueryInfoAsync  func(f *FileInputStream, attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileInputStreamQueryInfoFinish func(f *FileInputStream, result *AsyncResult, err **L.Error) *FileInfo
)
View Source 
var (
	FileIoStreamGetType func() O.Type

	FileIoStreamGetEtag         func(f *FileIOStream) string
	FileIoStreamQueryInfo       func(f *FileIOStream, attributes string, cancellable *Cancellable, err **L.Error) *FileInfo
	FileIoStreamQueryInfoAsync  func(f *FileIOStream, attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileIoStreamQueryInfoFinish func(f *FileIOStream, result *AsyncResult, err **L.Error) *FileInfo
)
View Source 
var (
	FileMonitorGetType func() O.Type

	FileMonitorCancel       func(f *FileMonitor) bool
	FileMonitorEmitEvent    func(f *FileMonitor, child, otherFile *File, eventType FileMonitorEvent)
	FileMonitorIsCancelled  func(f *FileMonitor) bool
	FileMonitorSetRateLimit func(f *FileMonitor, limitMsecs int)
)
View Source 
var (
	FilenameCompleterGetType func() O.Type
	FilenameCompleterNew     func() *FilenameCompleter

	FilenameCompleterGetCompletions      func(f *FilenameCompleter, initialText string) []string
	FilenameCompleterGetCompletionSuffix func(f *FilenameCompleter, initialText string) string
	FilenameCompleterSetDirsOnly         func(f *FilenameCompleter, dirsOnly bool)
)
View Source 
var (
	FileOutputStreamGetType func() O.Type

	FileOutputStreamGetEtag         func(f *FileOutputStream) string
	FileOutputStreamQueryInfo       func(f *FileOutputStream, attributes string, cancellable *Cancellable, err **L.Error) *FileInfo
	FileOutputStreamQueryInfoAsync  func(f *FileOutputStream, attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	FileOutputStreamQueryInfoFinish func(f *FileOutputStream, result *AsyncResult, err **L.Error) *FileInfo
)
View Source 
var (
	FilterInputStreamGetType func() O.Type

	FilterInputStreamGetBaseStream      func(f *FilterInputStream) *InputStream
	FilterInputStreamGetCloseBaseStream func(f *FilterInputStream) bool
	FilterInputStreamSetCloseBaseStream func(f *FilterInputStream, closeBase bool)
)
View Source 
var (
	FilterOutputStreamGetType func() O.Type

	FilterOutputStreamGetBaseStream      func(f *FilterOutputStream) *OutputStream
	FilterOutputStreamGetCloseBaseStream func(f *FilterOutputStream) bool
	FilterOutputStreamSetCloseBaseStream func(f *FilterOutputStream, closeBase bool)
)
View Source 
var (
	IconGetType      func() O.Type
	IconNewForString func(str string, err **L.Error) *Icon

	IconHash func(icon T.Gconstpointer) uint

	IconEqual    func(i *Icon, icon2 *Icon) bool
	IconToString func(i *Icon) string
)
View Source 
var (
	InetAddressGetType       func() O.Type
	InetAddressNewAny        func(family SocketFamily) *InetAddress
	InetAddressNewFromBytes  func(bytes *uint8, family SocketFamily) *InetAddress
	InetAddressNewFromString func(string string) *InetAddress
	InetAddressNewLoopback   func(family SocketFamily) *InetAddress

	InetAddressGetFamily        func(i *InetAddress) SocketFamily
	InetAddressGetIsAny         func(i *InetAddress) bool
	InetAddressGetIsLinkLocal   func(i *InetAddress) bool
	InetAddressGetIsLoopback    func(i *InetAddress) bool
	InetAddressGetIsMcGlobal    func(i *InetAddress) bool
	InetAddressGetIsMcLinkLocal func(i *InetAddress) bool
	InetAddressGetIsMcNodeLocal func(i *InetAddress) bool
	InetAddressGetIsMcOrgLocal  func(i *InetAddress) bool
	InetAddressGetIsMcSiteLocal func(i *InetAddress) bool
	InetAddressGetIsMulticast   func(i *InetAddress) bool
	InetAddressGetIsSiteLocal   func(i *InetAddress) bool
	InetAddressGetNativeSize    func(i *InetAddress) T.Gsize
	InetAddressToBytes          func(i *InetAddress) *uint8
	InetAddressToString         func(i *InetAddress) string
)
View Source 
var (
	InetSocketAddressGetType func() O.Type
	InetSocketAddressNew     func(address *InetAddress, port uint16) *SocketAddress

	InetSocketAddressGetAddress func(i *InetSocketAddress) *InetAddress
	InetSocketAddressGetPort    func(i *InetSocketAddress) uint16
)
View Source 
var (
	InitableGetType   func() O.Type
	InitableNew       func(objectType O.Type, cancellable *Cancellable, e **L.Error, firstPropertyName string, v ...VArg) T.Gpointer
	InitableNewv      func(objectType O.Type, nParameters uint, parameters *O.Parameter, cancellable *Cancellable, err **L.Error) T.Gpointer
	InitableNewValist func(objectType O.Type, firstPropertyName string, varArgs VAList, cancellable *Cancellable, err **L.Error) *O.Object

	InitableInit func(i *Initable, cancellable *Cancellable, err **L.Error) bool
)
View Source 
var (
	InputStreamGetType func() O.Type

	InputStreamClearPending func(i *InputStream)
	InputStreamClose        func(i *InputStream, cancellable *Cancellable, err **L.Error) bool
	InputStreamCloseAsync   func(i *InputStream, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	InputStreamCloseFinish  func(i *InputStream, result *AsyncResult, err **L.Error) bool
	InputStreamHasPending   func(i *InputStream) bool
	InputStreamIsClosed     func(i *InputStream) bool
	InputStreamRead         func(i *InputStream, buffer *T.Void, count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	InputStreamReadAll      func(i *InputStream, buffer *T.Void, count T.Gsize, bytesRead *T.Gsize, cancellable *Cancellable, err **L.Error) bool
	InputStreamReadAsync    func(i *InputStream, buffer *T.Void, count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	InputStreamReadFinish   func(i *InputStream, result *AsyncResult, err **L.Error) T.Gssize
	InputStreamSetPending   func(i *InputStream, err **L.Error) bool
	InputStreamSkip         func(i *InputStream, count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	InputStreamSkipAsync    func(i *InputStream, count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	InputStreamSkipFinish   func(i *InputStream, result *AsyncResult, err **L.Error) T.Gssize
)
View Source 
var (
	IoErrorQuark          func() L.Quark
	IoErrorFromErrno      func(errNo int) IOErrorEnum
	IoErrorFromWin32Error func(errorCode int) IOErrorEnum
)
View Source 
var (
	IoExtensionGetName     func(i *IOExtension) string
	IoExtensionGetPriority func(i *IOExtension) int
	IoExtensionGetType     func(i *IOExtension) O.Type
	IoExtensionRefClass    func(i *IOExtension) *O.TypeClass
)
View Source 
var (
	IoExtensionPointLookup   func(name string) *IOExtensionPoint
	IoExtensionPointRegister func(name string) *IOExtensionPoint

	IoExtensionPointImplement func(extensionPointName string, typ O.Type, extensionName string, priority int) *IOExtension

	IoExtensionPointGetExtensionByName func(i *IOExtensionPoint, name string) *IOExtension
	IoExtensionPointGetExtensions      func(i *IOExtensionPoint) *L.List
	IoExtensionPointGetRequiredType    func(i *IOExtensionPoint) O.Type
	IoExtensionPointSetRequiredType    func(i *IOExtensionPoint, typ O.Type)
)
View Source 
var (
	IoModuleGetType func() O.Type
	IoModuleNew     func(filename string) *IOModule

	IoModuleQuery               func() []string
	IoModulesLoadAllInDirectory func(dirname string) *L.List
	IoModulesScanAllInDirectory func(dirname string)

	IoModuleLoad   func(i *IOModule)
	IoModuleUnload func(i *IOModule)
)
View Source 
var (
	IoSchedulerCancelAllJobs func()

	IoSchedulerPushJob func(i IOSchedulerJobFunc, userData T.Gpointer, notify O.DestroyNotify, ioPriority int, cancellable *Cancellable)
)
View Source 
var (
	IoSchedulerJobSendToMainloop      func(i *IOSchedulerJob, f O.SourceFunc, userData T.Gpointer, notify O.DestroyNotify) bool
	IoSchedulerJobSendToMainloopAsync func(i *IOSchedulerJob, f O.SourceFunc, userData T.Gpointer, notify O.DestroyNotify)
)
View Source 
var (
	IoStreamGetType func() O.Type

	IoStreamSpliceFinish func(result *AsyncResult, err **L.Error) bool

	IoStreamClearPending    func(i *IOStream)
	IoStreamClose           func(i *IOStream, cancellable *Cancellable, err **L.Error) bool
	IoStreamCloseAsync      func(i *IOStream, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	IoStreamCloseFinish     func(i *IOStream, result *AsyncResult, err **L.Error) bool
	IoStreamGetInputStream  func(i *IOStream) *InputStream
	IoStreamGetOutputStream func(i *IOStream) *OutputStream
	IoStreamHasPending      func(i *IOStream) bool
	IoStreamIsClosed        func(i *IOStream) bool
	IoStreamSetPending      func(i *IOStream, err **L.Error) bool
	IoStreamSpliceAsync     func(i *IOStream, stream2 *IOStream, flags IOStreamSpliceFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
)
View Source 
var (
	LoadableIconGetType func() O.Type

	LoadableIconLoad       func(l *LoadableIcon, size int, t **T.Char, cancellable *Cancellable, err **L.Error) *InputStream
	LoadableIconLoadAsync  func(l *LoadableIcon, size int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	LoadableIconLoadFinish func(l *LoadableIcon, res *AsyncResult, typ **T.Char, err **L.Error) *InputStream
)
View Source 
var (
	MemoryInputStreamGetType     func() O.Type
	MemoryInputStreamNew         func() *InputStream
	MemoryInputStreamNewFromData func(data *T.Void, len T.Gssize, destroy O.DestroyNotify) *InputStream

	MemoryInputStreamAddData func(m *MemoryInputStream, data *T.Void, len T.Gssize, destroy O.DestroyNotify)
)
View Source 
var (
	MemoryOutputStreamGetType func() O.Type
	MemoryOutputStreamNew     func(data T.Gpointer, size T.Gsize, reallocFunction ReallocFunc, destroyFunction O.DestroyNotify) *OutputStream

	MemoryOutputStreamGetData     func(m *MemoryOutputStream) T.Gpointer
	MemoryOutputStreamGetDataSize func(m *MemoryOutputStream) T.Gsize
	MemoryOutputStreamGetSize     func(m *MemoryOutputStream) T.Gsize
	MemoryOutputStreamStealData   func(m *MemoryOutputStream) T.Gpointer
)
View Source 
var (
	MountGetType func() O.Type

	MountCanEject                   func(m *Mount) bool
	MountCanUnmount                 func(m *Mount) bool
	MountEject                      func(m *Mount, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountEjectFinish                func(m *Mount, result *AsyncResult, err **L.Error) bool
	MountEjectWithOperation         func(m *Mount, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountEjectWithOperationFinish   func(m *Mount, result *AsyncResult, err **L.Error) bool
	MountGetDefaultLocation         func(m *Mount) *File
	MountGetDrive                   func(m *Mount) *Drive
	MountGetIcon                    func(m *Mount) *Icon
	MountGetName                    func(m *Mount) string
	MountGetRoot                    func(m *Mount) *File
	MountGetUuid                    func(m *Mount) string
	MountGetVolume                  func(m *Mount) *Volume
	MountGuessContentType           func(m *Mount, forceRescan bool, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountGuessContentTypeFinish     func(m *Mount, result *AsyncResult, err **L.Error) []string
	MountGuessContentTypeSync       func(m *Mount, forceRescan bool, cancellable *Cancellable, err **L.Error) []string
	MountIsShadowed                 func(m *Mount) bool
	MountRemount                    func(m *Mount, flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountRemountFinish              func(m *Mount, result *AsyncResult, err **L.Error) bool
	MountShadow                     func(m *Mount)
	MountUnmount                    func(m *Mount, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountUnmountFinish              func(m *Mount, result *AsyncResult, err **L.Error) bool
	MountUnmountWithOperation       func(m *Mount, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	MountUnmountWithOperationFinish func(m *Mount, result *AsyncResult, err **L.Error) bool
	MountUnshadow                   func(m *Mount)
)
View Source 
var (
	MountOperationGetType func() O.Type
	MountOperationNew     func() *MountOperation

	MountOperationGetAnonymous    func(m *MountOperation) bool
	MountOperationGetChoice       func(m *MountOperation) int
	MountOperationGetDomain       func(m *MountOperation) string
	MountOperationGetPassword     func(m *MountOperation) string
	MountOperationGetPasswordSave func(m *MountOperation) T.GPasswordSave
	MountOperationGetUsername     func(m *MountOperation) string
	MountOperationReply           func(m *MountOperation, result MountOperationResult)
	MountOperationSetAnonymous    func(m *MountOperation, anonymous bool)
	MountOperationSetChoice       func(m *MountOperation, choice int)
	MountOperationSetDomain       func(m *MountOperation, domain string)
	MountOperationSetPassword     func(m *MountOperation, password string)
	MountOperationSetPasswordSave func(m *MountOperation, save T.GPasswordSave)
	MountOperationSetUsername     func(m *MountOperation, username string)
)
View Source 
var (
	NetworkAddressGetType func() O.Type
	NetworkAddressNew     func(hostname string, port uint16) *SocketConnectable

	NetworkAddressParse    func(hostAndPort string, defaultPort uint16, err **L.Error) *SocketConnectable
	NetworkAddressParseUri func(uri string, defaultPort uint16, err **L.Error) *SocketConnectable

	NetworkAddressGetHostname func(n *NetworkAddress) string
	NetworkAddressGetPort     func(n *NetworkAddress) uint16
	NetworkAddressGetScheme   func(n *NetworkAddress) string
)
View Source 
var (
	NetworkServiceGetType func() O.Type
	NetworkServiceNew     func(service string, protocol string, domain string) *SocketConnectable

	NetworkServiceGetService  func(n *NetworkService) string
	NetworkServiceGetProtocol func(n *NetworkService) string
	NetworkServiceGetDomain   func(n *NetworkService) string
	NetworkServiceGetScheme   func(n *NetworkService) string
	NetworkServiceSetScheme   func(n *NetworkService, scheme string)
)
View Source 
var (
	OutputStreamGetType func() O.Type

	OutputStreamClearPending func(o *OutputStream)
	OutputStreamClose        func(o *OutputStream, cancellable *Cancellable, err **L.Error) bool
	OutputStreamCloseAsync   func(o *OutputStream, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	OutputStreamCloseFinish  func(o *OutputStream, result *AsyncResult, err **L.Error) bool
	OutputStreamFlush        func(o *OutputStream, cancellable *Cancellable, err **L.Error) bool
	OutputStreamFlushAsync   func(o *OutputStream, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	OutputStreamFlushFinish  func(o *OutputStream, result *AsyncResult, err **L.Error) bool
	OutputStreamHasPending   func(o *OutputStream) bool
	OutputStreamIsClosed     func(o *OutputStream) bool
	OutputStreamIsClosing    func(o *OutputStream) bool
	OutputStreamSetPending   func(o *OutputStream, err **L.Error) bool
	OutputStreamSplice       func(o *OutputStream, source *InputStream, flags OutputStreamSpliceFlags, cancellable *Cancellable, err **L.Error) T.Gssize
	OutputStreamSpliceAsync  func(o *OutputStream, source *InputStream, flags OutputStreamSpliceFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	OutputStreamSpliceFinish func(o *OutputStream, result *AsyncResult, err **L.Error) T.Gssize
	OutputStreamWrite        func(o *OutputStream, buffer *T.Void, count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	OutputStreamWriteAll     func(o *OutputStream, buffer *T.Void, count T.Gsize, bytesWritten *T.Gsize, cancellable *Cancellable, err **L.Error) bool
	OutputStreamWriteAsync   func(o *OutputStream, buffer *T.Void, count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	OutputStreamWriteFinish  func(o *OutputStream, result *AsyncResult, err **L.Error) T.Gssize
)
View Source 
var (
	PermissionGetType func() O.Type

	PermissionAcquire       func(p *Permission, cancellable *Cancellable, err **L.Error) bool
	PermissionAcquireAsync  func(p *Permission, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	PermissionAcquireFinish func(p *Permission, result *AsyncResult, err **L.Error) bool
	PermissionGetAllowed    func(p *Permission) bool
	PermissionGetCanAcquire func(p *Permission) bool
	PermissionGetCanRelease func(p *Permission) bool
	PermissionImplUpdate    func(p *Permission, allowed bool, canAcquire bool, canRelease bool)
	PermissionRelease       func(p *Permission, cancellable *Cancellable, err **L.Error) bool
	PermissionReleaseAsync  func(p *Permission, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	PermissionReleaseFinish func(p *Permission, result *AsyncResult, err **L.Error) bool
)
View Source 
var (
	PollableInputStreamGetType func() O.Type

	PollableInputStreamCanPoll         func(p *PollableInputStream) bool
	PollableInputStreamIsReadable      func(p *PollableInputStream) bool
	PollableInputStreamCreateSource    func(p *PollableInputStream, cancellable *Cancellable) *L.Source
	PollableInputStreamReadNonblocking func(p *PollableInputStream, buffer *T.Void, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
)
View Source 
var (
	PollableOutputStreamGetType func() O.Type

	PollableOutputStreamCanPoll          func(p *PollableOutputStream) bool
	PollableOutputStreamIsWritable       func(p *PollableOutputStream) bool
	PollableOutputStreamCreateSource     func(p *PollableOutputStream, cancellable *Cancellable) *L.Source
	PollableOutputStreamWriteNonblocking func(p *PollableOutputStream, buffer *T.Void, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
)
View Source 
var (
	ProxyGetType func() O.Type

	ProxyGetDefaultForProtocol func(protocol string) *Proxy

	ProxyConnect          func(p *Proxy, connection *IOStream, proxyAddress *ProxyAddress, cancellable *Cancellable, err **L.Error) *IOStream
	ProxyConnectAsync     func(p *Proxy, connection *IOStream, proxyAddress *ProxyAddress, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	ProxyConnectFinish    func(p *Proxy, result *AsyncResult, err **L.Error) *IOStream
	ProxySupportsHostname func(p *Proxy) bool
)
View Source 
var (
	ProxyAddressGetType func() O.Type
	ProxyAddressNew     func(inetaddr *InetAddress, port uint16, protocol, destHostname string, destPort uint16, username, password string) *SocketAddress

	ProxyAddressGetProtocol            func(p *ProxyAddress) string
	ProxyAddressGetDestinationHostname func(p *ProxyAddress) string
	ProxyAddressGetDestinationPort     func(p *ProxyAddress) uint16
	ProxyAddressGetUsername            func(p *ProxyAddress) string
	ProxyAddressGetPassword            func(p *ProxyAddress) string
)
View Source 
var (
	ProxyResolverGetType func() O.Type

	ProxyResolverGetDefault func() *ProxyResolver

	ProxyResolverIsSupported  func(p *ProxyResolver) bool
	ProxyResolverLookup       func(p *ProxyResolver, uri string, cancellable *Cancellable, err **L.Error) []string
	ProxyResolverLookupAsync  func(p *ProxyResolver, uri string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	ProxyResolverLookupFinish func(p *ProxyResolver, result *AsyncResult, err **L.Error) []string
)
View Source 
var (
	ResolverGetType func() O.Type

	ResolverErrorGetType  func() O.Type
	ResolverErrorQuark    func() L.Quark
	ResolverFreeAddresses func(addresses *L.List)
	ResolverFreeTargets   func(targets *L.List)
	ResolverGetDefault    func() *Resolver

	ResolverLookupByAddress       func(r *Resolver, address *InetAddress, cancellable *Cancellable, err **L.Error) string
	ResolverLookupByAddressAsync  func(r *Resolver, address *InetAddress, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	ResolverLookupByAddressFinish func(r *Resolver, result *AsyncResult, err **L.Error) string
	ResolverLookupByName          func(r *Resolver, hostname string, cancellable *Cancellable, err **L.Error) *L.List
	ResolverLookupByNameAsync     func(r *Resolver, hostname string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	ResolverLookupByNameFinish    func(r *Resolver, result *AsyncResult, err **L.Error) *L.List
	ResolverLookupService         func(r *Resolver, service, protocol, domain string, cancellable *Cancellable, err **L.Error) *L.List
	ResolverLookupServiceAsync    func(r *Resolver, service, protocol, domain string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	ResolverLookupServiceFinish   func(r *Resolver, result *AsyncResult, err **L.Error) *L.List
	ResolverSetDefault            func(r *Resolver)
)
View Source 
var (
	SeekableGetType func() O.Type

	SeekableCanSeek     func(seekable *Seekable) bool
	SeekableCanTruncate func(seekable *Seekable) bool
	SeekableSeek        func(seekable *Seekable, offset T.Goffset, typ L.SeekType, cancellable *Cancellable, err **L.Error) bool
	SeekableTell        func(seekable *Seekable) T.Goffset
	SeekableTruncate    func(seekable *Seekable, offset T.Goffset, cancellable *Cancellable, err **L.Error) bool
)
View Source 
var (
	SettingsGetType func() O.Type

	SettingsListRelocatableSchemas func() []string
	SettingsListSchemas            func() []string
	SettingsNew                    func(schema string) *Settings
	SettingsNewWithBackend         func(schema string, backend *SettingsBackend) *Settings
	SettingsNewWithBackendAndPath  func(schema string, backend *SettingsBackend, path string) *Settings
	SettingsNewWithPath            func(schema string, path string) *Settings
	SettingsSync                   func()
	SettingsUnbind                 func(object T.Gpointer, property string)

	SettingsApply           func(s *Settings)
	SettingsBind            func(s *Settings, key string, object T.Gpointer, property string, flags SettingsBindFlags)
	SettingsBindWithMapping func(s *Settings, key string, object T.Gpointer, property string, flags SettingsBindFlags, getMapping SettingsBindGetMapping, setMapping SettingsBindSetMapping, userData T.Gpointer, destroy O.DestroyNotify)
	SettingsBindWritable    func(s *Settings, key string, object T.Gpointer, property string, inverted bool)
	SettingsDelay           func(s *Settings)
	SettingsGet             func(s *Settings, key, format string, v ...VArg)
	SettingsGetBoolean      func(s *Settings, key string) bool
	SettingsGetChild        func(s *Settings, name string) *Settings
	SettingsGetDouble       func(s *Settings, key string) float64
	SettingsGetEnum         func(s *Settings, key string) int
	SettingsGetFlags        func(s *Settings, key string) uint
	SettingsGetHasUnapplied func(s *Settings) bool
	SettingsGetInt          func(s *Settings, key string) int
	SettingsGetMapped       func(s *Settings, key string, mapping SettingsGetMapping, userData T.Gpointer) T.Gpointer
	SettingsGetRange        func(s *Settings, key string) *L.Variant
	SettingsGetString       func(s *Settings, key string) string
	SettingsGetStrv         func(s *Settings, key string) []string
	SettingsGetValue        func(s *Settings, key string) *L.Variant
	SettingsIsWritable      func(s *Settings, name string) bool
	SettingsListKeys        func(s *Settings) []string
	SettingsListChildren    func(s *Settings) []string
	SettingsRangeCheck      func(s *Settings, key string, value *L.Variant) bool
	SettingsReset           func(s *Settings, key string)
	SettingsRevert          func(s *Settings)
	SettingsSet             func(s *Settings, key, format string, v ...VArg) bool
	SettingsSetBoolean      func(s *Settings, key string, value bool) bool
	SettingsSetDouble       func(s *Settings, key string, value float64) bool
	SettingsSetEnum         func(s *Settings, key string, value int) bool
	SettingsSetFlags        func(s *Settings, key string, value uint) bool
	SettingsSetInt          func(s *Settings, key string, value int) bool
	SettingsSetString       func(s *Settings, key, value string) bool
	SettingsSetStrv         func(s *Settings, key string, value []string) bool
	SettingsSetValue        func(s *Settings, key string, value *L.Variant) bool
)
View Source 
var (
	SettingsBackendGetType func() O.Type

	SettingsBackendFlattenTree func(tree *L.Tree, path []string, keys ***T.Gchar, values ***L.Variant)
	SettingsBackendGetDefault  func() *SettingsBackend

	SettingsBackendKeysChanged         func(s *SettingsBackend, path string, items []string, originTag T.Gpointer)
	SettingsBackendChanged             func(s *SettingsBackend, key string, originTag T.Gpointer)
	SettingsBackendChangedTree         func(s *SettingsBackend, tree *L.Tree, originTag T.Gpointer)
	SettingsBackendPathChanged         func(s *SettingsBackend, path string, originTag T.Gpointer)
	SettingsBackendPathWritableChanged func(s *SettingsBackend, path string)
	SettingsBackendWritableChanged     func(s *SettingsBackend, key string)
)
View Source 
var (
	SimpleActionGetType     func() O.Type
	SimpleActionNew         func(name string, parameterType *L.VariantType) *SimpleAction
	SimpleActionNewStateful func(name string, parameterType *L.VariantType, state *L.Variant) *SimpleAction

	SimpleActionSetEnabled func(s *SimpleAction, enabled bool)
)
View Source 
var (
	SimpleActionGroupGetType func() O.Type
	SimpleActionGroupNew     func() *SimpleActionGroup

	SimpleActionGroupInsert func(s *SimpleActionGroup, action *Action)
	SimpleActionGroupLookup func(s *SimpleActionGroup, actionName string) *Action
	SimpleActionGroupRemove func(s *SimpleActionGroup, actionName string)
)
View Source 
var (
	SimpleAsyncReportErrorInIdle      func(object *O.Object, callback AsyncReadyCallback, userData T.Gpointer, domain L.Quark, code int, format string, v ...VArg)
	SimpleAsyncReportGerrorInIdle     func(object *O.Object, callback AsyncReadyCallback, userData T.Gpointer, err *L.Error)
	SimpleAsyncReportTakeGerrorInIdle func(object *O.Object, callback AsyncReadyCallback, userData T.Gpointer, err *L.Error)
)
View Source 
var (
	SimpleAsyncResultGetType      func() O.Type
	SimpleAsyncResultNew          func(sourceObject *O.Object, callback AsyncReadyCallback, userData T.Gpointer, sourceTag T.Gpointer) *SimpleAsyncResult
	SimpleAsyncResultNewError     func(sourceObject *O.Object, callback AsyncReadyCallback, userData T.Gpointer, domain L.Quark, code int, format string, v ...VArg) *SimpleAsyncResult
	SimpleAsyncResultNewFromError func(sourceObject *O.Object, callback AsyncReadyCallback, userData T.Gpointer, err *L.Error) *SimpleAsyncResult
	SimpleAsyncResultNewTakeError func(sourceObject *O.Object, callback AsyncReadyCallback, userData T.Gpointer, err *L.Error) *SimpleAsyncResult

	SimpleAsyncResultIsValid func(result *AsyncResult, source *O.Object, sourceTag T.Gpointer) bool

	SimpleAsyncResultComplete              func(s *SimpleAsyncResult)
	SimpleAsyncResultCompleteInIdle        func(s *SimpleAsyncResult)
	SimpleAsyncResultGetOpResGboolean      func(s *SimpleAsyncResult) bool
	SimpleAsyncResultGetOpResGpointer      func(s *SimpleAsyncResult) T.Gpointer
	SimpleAsyncResultGetOpResGssize        func(s *SimpleAsyncResult) T.Gssize
	SimpleAsyncResultGetSourceTag          func(s *SimpleAsyncResult) T.Gpointer
	SimpleAsyncResultPropagateError        func(s *SimpleAsyncResult, dest **L.Error) bool
	SimpleAsyncResultRunInThread           func(s *SimpleAsyncResult, f SimpleAsyncThreadFunc, ioPriority int, cancellable *Cancellable)
	SimpleAsyncResultSetError              func(s *SimpleAsyncResult, domain L.Quark, code int, format string, v ...VArg)
	SimpleAsyncResultSetErrorVa            func(s *SimpleAsyncResult, domain L.Quark, code int, format string, args VAList)
	SimpleAsyncResultSetFromError          func(s *SimpleAsyncResult, err *L.Error)
	SimpleAsyncResultSetHandleCancellation func(s *SimpleAsyncResult, handleCancellation bool)
	SimpleAsyncResultSetOpResGboolean      func(s *SimpleAsyncResult, opRes bool)
	SimpleAsyncResultSetOpResGpointer      func(s *SimpleAsyncResult, opRes T.Gpointer, destroyOpRes O.DestroyNotify)
	SimpleAsyncResultSetOpResGssize        func(s *SimpleAsyncResult, opRes T.Gssize)
	SimpleAsyncResultTakeError             func(s *SimpleAsyncResult, err *L.Error)
)
View Source 
var (
	SimplePermissionGetType func() O.Type
	SimplePermissionNew     func(allowed bool) *Permission
)
View Source 
var (
	SocketGetType   func() O.Type
	SocketNew       func(family SocketFamily, t SocketType, protocol SocketProtocol, err **L.Error) *Socket
	SocketNewFromFd func(fd int, err **L.Error) *Socket

	SocketGetFd               func(s *Socket) int
	SocketGetFamily           func(s *Socket) SocketFamily
	SocketGetSocketType       func(s *Socket) SocketType
	SocketGetProtocol         func(s *Socket) SocketProtocol
	SocketGetLocalAddress     func(s *Socket, err **L.Error) *SocketAddress
	SocketGetRemoteAddress    func(s *Socket, err **L.Error) *SocketAddress
	SocketSetBlocking         func(s *Socket, blocking bool)
	SocketGetBlocking         func(s *Socket) bool
	SocketSetKeepalive        func(s *Socket, keepalive bool)
	SocketGetKeepalive        func(s *Socket) bool
	SocketGetListenBacklog    func(s *Socket) int
	SocketSetListenBacklog    func(s *Socket, backlog int)
	SocketGetTimeout          func(s *Socket) uint
	SocketSetTimeout          func(s *Socket, timeout uint)
	SocketIsConnected         func(s *Socket) bool
	SocketBind                func(s *Socket, address *SocketAddress, allowReuse bool, err **L.Error) bool
	SocketConnect             func(s *Socket, address *SocketAddress, cancellable *Cancellable, err **L.Error) bool
	SocketCheckConnectResult  func(s *Socket, err **L.Error) bool
	SocketConditionCheck      func(s *Socket, condition L.IOCondition) L.IOCondition
	SocketConditionWait       func(s *Socket, condition L.IOCondition, cancellable *Cancellable, err **L.Error) bool
	SocketAccept              func(s *Socket, cancellable *Cancellable, err **L.Error) *Socket
	SocketListen              func(s *Socket, err **L.Error) bool
	SocketReceive             func(s *Socket, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketReceiveFrom         func(s *Socket, address **SocketAddress, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketSend                func(s *Socket, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketSendTo              func(s *Socket, address *SocketAddress, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketReceiveMessage      func(s *Socket, address **SocketAddress, vectors *InputVector, numVectors int, messages ***SocketControlMessage, numMessages *int, flags *int, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketSendMessage         func(s *Socket, address *SocketAddress, vectors *T.GOutputVector, numVectors int, messages **SocketControlMessage, numMessages int, flags int, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketClose               func(s *Socket, err **L.Error) bool
	SocketShutdown            func(s *Socket, shutdownRead bool, shutdownWrite bool, err **L.Error) bool
	SocketIsClosed            func(s *Socket) bool
	SocketCreateSource        func(s *Socket, condition L.IOCondition, cancellable *Cancellable) *O.Source
	SocketSpeaksIpv4          func(s *Socket) bool
	SocketGetCredentials      func(s *Socket, err **L.Error) *Credentials
	SocketReceiveWithBlocking func(s *Socket, buffer string, size T.Gsize, blocking bool, cancellable *Cancellable, err **L.Error) T.Gssize
	SocketSendWithBlocking    func(s *Socket, buffer string, size T.Gsize, blocking bool, cancellable *Cancellable, err **L.Error) T.Gssize
)
View Source 
var (
	SocketAddressGetType       func() O.Type
	SocketAddressNewFromNative func(native T.Gpointer, len T.Gsize) *SocketAddress

	SocketAddressGetFamily     func(s *SocketAddress) SocketFamily
	SocketAddressGetNativeSize func(s *SocketAddress) T.Gssize
	SocketAddressToNative      func(s *SocketAddress, dest T.Gpointer, destlen T.Gsize, err **L.Error) bool
)
View Source 
var (
	SocketAddressEnumeratorGetType func() O.Type

	SocketAddressEnumeratorNext       func(s *SocketAddressEnumerator, cancellable *Cancellable, err **L.Error) *SocketAddress
	SocketAddressEnumeratorNextAsync  func(s *SocketAddressEnumerator, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketAddressEnumeratorNextFinish func(s *SocketAddressEnumerator, result *AsyncResult, err **L.Error) *SocketAddress
)
View Source 
var (
	SocketClientGetType func() O.Type
	SocketClientNew     func() *SocketClient

	SocketClientAddApplicationProxy    func(s *SocketClient, protocol string)
	SocketClientConnect                func(s *SocketClient, connectable *SocketConnectable, cancellable *Cancellable, err **L.Error) *SocketConnection
	SocketClientConnectAsync           func(s *SocketClient, connectable *SocketConnectable, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketClientConnectFinish          func(s *SocketClient, result *AsyncResult, err **L.Error) *SocketConnection
	SocketClientConnectToHost          func(s *SocketClient, hostAndPort string, defaultPort uint16, cancellable *Cancellable, err **L.Error) *SocketConnection
	SocketClientConnectToHostAsync     func(s *SocketClient, hostAndPort string, defaultPort uint16, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketClientConnectToHostFinish    func(s *SocketClient, result *AsyncResult, err **L.Error) *SocketConnection
	SocketClientConnectToService       func(s *SocketClient, domain string, service string, cancellable *Cancellable, err **L.Error) *SocketConnection
	SocketClientConnectToServiceAsync  func(s *SocketClient, domain string, service string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketClientConnectToServiceFinish func(s *SocketClient, result *AsyncResult, err **L.Error) *SocketConnection
	SocketClientConnectToUri           func(s *SocketClient, uri string, defaultPort uint16, cancellable *Cancellable, err **L.Error) *SocketConnection
	SocketClientConnectToUriAsync      func(s *SocketClient, uri string, defaultPort uint16, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketClientConnectToUriFinish     func(s *SocketClient, result *AsyncResult, err **L.Error) *SocketConnection
	SocketClientGetEnableProxy         func(s *SocketClient) bool
	SocketClientGetFamily              func(s *SocketClient) SocketFamily
	SocketClientGetLocalAddress        func(s *SocketClient) *SocketAddress
	SocketClientGetProtocol            func(s *SocketClient) SocketProtocol
	SocketClientGetSocketType          func(s *SocketClient) SocketType
	SocketClientGetTimeout             func(s *SocketClient) uint
	SocketClientGetTls                 func(s *SocketClient) bool
	SocketClientGetTlsValidationFlags  func(s *SocketClient) TlsCertificateFlags
	SocketClientSetEnableProxy         func(s *SocketClient, enable bool)
	SocketClientSetFamily              func(s *SocketClient, family SocketFamily)
	SocketClientSetLocalAddress        func(s *SocketClient, address *SocketAddress)
	SocketClientSetProtocol            func(s *SocketClient, protocol SocketProtocol)
	SocketClientSetSocketType          func(s *SocketClient, t SocketType)
	SocketClientSetTimeout             func(s *SocketClient, timeout uint)
	SocketClientSetTls                 func(s *SocketClient, tls bool)
	SocketClientSetTlsValidationFlags  func(s *SocketClient, flags TlsCertificateFlags)
)
View Source 
var (
	SocketConnectableGetType func() O.Type

	SocketConnectableEnumerate      func(s *SocketConnectable) *SocketAddressEnumerator
	SocketConnectableProxyEnumerate func(s *SocketConnectable) *SocketAddressEnumerator
)
View Source 
var (
	SocketConnectionGetType func() O.Type

	SocketConnectionFactoryCreateConnection func(socket *Socket) *SocketConnection
	SocketConnectionFactoryLookupType       func(family SocketFamily, t SocketType, protocolId int) O.Type
	SocketConnectionFactoryRegisterType     func(GType O.Type, family SocketFamily, t SocketType, protocol int)

	SocketConnectionGetLocalAddress  func(s *SocketConnection, err **L.Error) *SocketAddress
	SocketConnectionGetRemoteAddress func(s *SocketConnection, err **L.Error) *SocketAddress
	SocketConnectionGetSocket        func(s *SocketConnection) *Socket
)
View Source 
var (
	SocketControlMessageGetType func() O.Type

	SocketControlMessageDeserialize func(level int, typ int, size T.Gsize, data T.Gpointer) *SocketControlMessage

	SocketControlMessageGetLevel   func(s *SocketControlMessage) int
	SocketControlMessageGetMsgType func(s *SocketControlMessage) int
	SocketControlMessageGetSize    func(s *SocketControlMessage) T.Gsize
	SocketControlMessageSerialize  func(s *SocketControlMessage, data T.Gpointer)
)
View Source 
var (
	SocketListenerGetType func() O.Type
	SocketListenerNew     func() *SocketListener

	SocketListenerAccept             func(s *SocketListener, sourceObject **O.Object, cancellable *Cancellable, err **L.Error) *SocketConnection
	SocketListenerAcceptAsync        func(s *SocketListener, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketListenerAcceptFinish       func(s *SocketListener, result *AsyncResult, sourceObject **O.Object, err **L.Error) *SocketConnection
	SocketListenerAcceptSocket       func(s *SocketListener, sourceObject **O.Object, cancellable *Cancellable, err **L.Error) *Socket
	SocketListenerAcceptSocketAsync  func(s *SocketListener, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	SocketListenerAcceptSocketFinish func(s *SocketListener, result *AsyncResult, sourceObject **O.Object, err **L.Error) *Socket
	SocketListenerAddAddress         func(s *SocketListener, address *SocketAddress, t SocketType, protocol SocketProtocol, sourceObject *O.Object, effectiveAddress **SocketAddress, err **L.Error) bool
	SocketListenerAddAnyInetPort     func(s *SocketListener, sourceObject *O.Object, err **L.Error) uint16
	SocketListenerAddInetPort        func(s *SocketListener, port uint16, sourceObject *O.Object, err **L.Error) bool
	SocketListenerAddSocket          func(s *SocketListener, socket *Socket, sourceObject *O.Object, err **L.Error) bool
	SocketListenerClose              func(s *SocketListener)
	SocketListenerSetBacklog         func(s *SocketListener, listenBacklog int)
)
View Source 
var (
	SocketServiceGetType func() O.Type
	SocketServiceNew     func() *SocketService

	SocketServiceIsActive func(s *SocketService) bool
	SocketServiceStart    func(s *SocketService)
	SocketServiceStop     func(s *SocketService)
)
View Source 
var (
	SrvTargetGetType func() O.Type
	SrvTargetNew     func(hostname string, port uint16, priority uint16, weight uint16) *SrvTarget

	SrvTargetListSort func(targets *L.List) *L.List

	SrvTargetCopy        func(s *SrvTarget) *SrvTarget
	SrvTargetFree        func(s *SrvTarget)
	SrvTargetGetHostname func(s *SrvTarget) string
	SrvTargetGetPort     func(s *SrvTarget) uint16
	SrvTargetGetPriority func(s *SrvTarget) uint16
	SrvTargetGetWeight   func(s *SrvTarget) uint16
)
View Source 
var (
	TlsErrorGetType func() O.Type

	TlsAuthenticationModeGetType func() O.Type
)
View Source 
var (
	TcpConnectionGetType func() O.Type

	TcpConnectionSetGracefulDisconnect func(t *TcpConnection, gracefulDisconnect bool)
	TcpConnectionGetGracefulDisconnect func(t *TcpConnection) bool
)
View Source 
var (
	TcpWrapperConnectionGetType func() O.Type
	TcpWrapperConnectionNew     func(baseIoStream *IOStream, socket *Socket) *SocketConnection

	TcpWrapperConnectionGetBaseIoStream func(t *TcpWrapperConnection) *IOStream
)
View Source 
var (
	ThemedIconGetType                 func() O.Type
	ThemedIconNew                     func(iconname string) *Icon
	ThemedIconNewWithDefaultFallbacks func(iconname string) *Icon
	ThemedIconNewFromNames            func(iconnames **T.Char, len int) *Icon

	ThemedIconAppendName  func(t *ThemedIcon, iconname string)
	ThemedIconGetNames    func(t *ThemedIcon) []string
	ThemedIconPrependName func(t *ThemedIcon, iconname string)
)
View Source 
var (
	ThreadedSocketServiceGetType func() O.Type
	ThreadedSocketServiceNew     func(maxThreads int) *SocketService
)
View Source 
var (
	TlsBackendGetType func() O.Type

	TlsBackendGetDefault func() *TlsBackend

	TlsBackendGetCertificateType      func(t *TlsBackend) O.Type
	TlsBackendGetClientConnectionType func(t *TlsBackend) O.Type
	TlsBackendGetServerConnectionType func(t *TlsBackend) O.Type
	TlsBackendSupportsTls             func(t *TlsBackend) bool
)
View Source 
var (
	TlsCertificateGetType func() O.Type

	TlsCertificateNewFromPem      func(data string, length T.Gssize, err **L.Error) *TlsCertificate
	TlsCertificateNewFromFile     func(file string, err **L.Error) *TlsCertificate
	TlsCertificateNewFromFiles    func(certFile string, keyFile string, err **L.Error) *TlsCertificate
	TlsCertificateListNewFromFile func(file string, err **L.Error) *L.List

	TlsCertificateGetIssuer func(t *TlsCertificate) *TlsCertificate
	TlsCertificateVerify    func(t *TlsCertificate, identity *SocketConnectable, trustedCa *TlsCertificate) TlsCertificateFlags
)
View Source 
var (
	TlsConnectionGetType func() O.Type

	TlsConnectionGetCertificate           func(t *TlsConnection) *TlsCertificate
	TlsConnectionGetPeerCertificate       func(t *TlsConnection) *TlsCertificate
	TlsConnectionGetPeerCertificateErrors func(t *TlsConnection) TlsCertificateFlags
	TlsConnectionGetRehandshakeMode       func(t *TlsConnection) TlsRehandshakeMode
	TlsConnectionGetRequireCloseNotify    func(t *TlsConnection) bool
	TlsConnectionGetUseSystemCertdb       func(t *TlsConnection) bool
	TlsConnectionHandshake                func(t *TlsConnection, cancellable *Cancellable, err **L.Error) bool
	TlsConnectionHandshakeAsync           func(t *TlsConnection, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	TlsConnectionHandshakeFinish          func(t *TlsConnection, result *AsyncResult, err **L.Error) bool
	TlsConnectionSetCertificate           func(t *TlsConnection, certificate *TlsCertificate)
	TlsConnectionSetRehandshakeMode       func(t *TlsConnection, mode TlsRehandshakeMode)
	TlsConnectionSetRequireCloseNotify    func(t *TlsConnection, requireCloseNotify bool)
	TlsConnectionSetUseSystemCertdb       func(t *TlsConnection, useSystemCertdb bool)
)
View Source 
var (
	TlsErrorQuark func() L.Quark

	TlsConnectionEmitAcceptCertificate func(t *TlsConnection, peerCert *TlsCertificate, errors TlsCertificateFlags) bool
)
View Source 
var (
	TlsClientConnectionGetType func() O.Type
	TlsClientConnectionNew     func(baseIoStream *IOStream, serverIdentity *SocketConnectable, err **L.Error) *IOStream

	TlsClientConnectionGetAcceptedCas     func(t *TlsClientConnection) *L.List
	TlsClientConnectionGetServerIdentity  func(t *TlsClientConnection) *SocketConnectable
	TlsClientConnectionGetUseSsl3         func(t *TlsClientConnection) bool
	TlsClientConnectionGetValidationFlags func(t *TlsClientConnection) TlsCertificateFlags
	TlsClientConnectionSetServerIdentity  func(t *TlsClientConnection, identity *SocketConnectable)
	TlsClientConnectionSetUseSsl3         func(t *TlsClientConnection, useSsl3 bool)
	TlsClientConnectionSetValidationFlags func(t *TlsClientConnection, flags TlsCertificateFlags)
)
View Source 
var (
	TlsServerConnectionGetType func() O.Type
	TlsServerConnectionNew     func(t *IOStream, certificate *TlsCertificate, err **L.Error) *IOStream
)
View Source 
var (
	VfsGetType func() O.Type

	VfsGetDefault func() *Vfs
	VfsGetLocal   func() *Vfs

	VfsGetFileForPath         func(v *Vfs, path string) *File
	VfsGetFileForUri          func(v *Vfs, uri string) *File
	VfsGetSupportedUriSchemes func(v *Vfs) []string
	VfsIsActive               func(v *Vfs) bool
	VfsParseName              func(v *Vfs, parseName string) *File
)
View Source 
var (
	VolumeGetType func() O.Type

	VolumeCanEject                 func(v *Volume) bool
	VolumeCanMount                 func(v *Volume) bool
	VolumeEject                    func(v *Volume, flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	VolumeEjectFinish              func(v *Volume, result *AsyncResult, err **L.Error) bool
	VolumeEjectWithOperation       func(v *Volume, flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	VolumeEjectWithOperationFinish func(v *Volume, result *AsyncResult, err **L.Error) bool
	VolumeEnumerateIdentifiers     func(v *Volume) []string
	VolumeGetActivationRoot        func(v *Volume) *File
	VolumeGetDrive                 func(v *Volume) *Drive
	VolumeGetIcon                  func(v *Volume) *Icon
	VolumeGetIdentifier            func(v *Volume, kind string) string
	VolumeGetMount                 func(v *Volume) *Mount
	VolumeGetName                  func(v *Volume) string
	VolumeGetUuid                  func(v *Volume) string
	VolumeMount                    func(v *Volume, flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)
	VolumeMountFinish              func(v *Volume, result *AsyncResult, err **L.Error) bool
	VolumeShouldAutomount          func(v *Volume) bool
)
View Source 
var (
	VolumeMonitorGetType func() O.Type

	VolumeMonitorAdoptOrphanMount func(mount *Mount) *Volume
	VolumeMonitorGet              func() *VolumeMonitor

	VolumeMonitorGetConnectedDrives func(v *VolumeMonitor) *L.List
	VolumeMonitorGetMountForUuid    func(v *VolumeMonitor, uuid string) *Mount
	VolumeMonitorGetMounts          func(v *VolumeMonitor) *L.List
	VolumeMonitorGetVolumeForUuid   func(v *VolumeMonitor, uuid string) *Volume
	VolumeMonitorGetVolumes         func(v *VolumeMonitor) *L.List
)
View Source 
var (
	Win32InputStreamGetType func() O.Type
	Win32InputStreamNew     func(handle *T.Void, closeHandle bool) *InputStream

	Win32InputStreamSetCloseHandle func(stream *Win32InputStream, closeHandle bool)
	Win32InputStreamGetCloseHandle func(stream *Win32InputStream) bool
	Win32InputStreamGetHandle      func(stream *Win32InputStream) *T.Void
)
View Source 
var (
	Win32OutputStreamGetType func() O.Type
	Win32OutputStreamNew     func(handle *T.Void, closeHandle bool) *OutputStream

	Win32OutputStreamSetCloseHandle func(stream *Win32OutputStream, closeHandle bool)
	Win32OutputStreamGetCloseHandle func(stream *Win32OutputStream) bool
	Win32OutputStreamGetHandle      func(stream *Win32OutputStream) *T.Void
)
View Source 
var (
	ZlibCompressorGetType func() O.Type
	ZlibCompressorNew     func(format ZlibCompressorFormat, level int) *ZlibCompressor

	ZlibCompressorGetFileInfo func(compressor *ZlibCompressor) *FileInfo
	ZlibCompressorSetFileInfo func(compressor *ZlibCompressor, fileInfo *FileInfo)
)
View Source 
var (
	ZlibDecompressorGetType func() O.Type
	ZlibDecompressorNew     func(format ZlibCompressorFormat) *ZlibDecompressor

	ZlibDecompressorGetFileInfo func(decompressor *ZlibDecompressor) *FileInfo
)
View Source 
var AppInfoCreateFlagsGetType func() O.Type
View Source 
var ApplicationFlagsGetType func() O.Type
View Source 
var AskPasswordFlagsGetType func() O.Type
View Source 
var BusNameOwnerFlagsGetType func() O.Type
View Source 
var BusNameWatcherFlagsGetType func() O.Type
View Source 
var ConverterFlagsGetType func() O.Type
View Source 
var ConverterResultGetType func() O.Type
View Source 
var CredentialsTypeGetType func() O.Type
View Source 
var DBusCallFlagsGetType func() O.Type
View Source 
var DBusCapabilityFlagsGetType func() O.Type
View Source 
var DBusConnectionFlagsGetType func() O.Type
View Source 
var DBusErrorGetType func() O.Type
View Source 
var DBusGenerateGuid func() string
View Source 
var DBusMessageByteOrderGetType func() O.Type
View Source 
var DBusMessageFlagsGetType func() O.Type
View Source 
var DBusMessageHeaderFieldGetType func() O.Type
View Source 
var DBusMessageTypeGetType func() O.Type
View Source 
var DBusPropertyInfoFlagsGetType func() O.Type
View Source 
var DBusProxyFlagsGetType func() O.Type
View Source 
var DBusSendMessageFlagsGetType func() O.Type
View Source 
var DBusServerFlagsGetType func() O.Type
View Source 
var DBusSignalFlagsGetType func() O.Type
View Source 
var DBusSubtreeFlagsGetType func() O.Type
View Source 
var DataStreamByteOrderGetType func() O.Type
View Source 
var DataStreamNewlineTypeGetType func() O.Type
View Source 
var DriveStartFlagsGetType func() O.Type
View Source 
var DriveStartStopTypeGetType func() O.Type
View Source 
var EmblemOriginGetType func() O.Type
View Source 
var FileAttributeInfoFlagsGetType func() O.Type
View Source 
var FileAttributeStatusGetType func() O.Type
View Source 
var FileAttributeTypeGetType func() O.Type
View Source 
var FileCopyFlagsGetType func() O.Type
View Source 
var FileCreateFlagsGetType func() O.Type
View Source 
var FileMonitorEventGetType func() O.Type
View Source 
var FileMonitorFlagsGetType func() O.Type
View Source 
var FileQueryInfoFlagsGetType func() O.Type
View Source 
var FileTypeGetType func() O.Type
View Source 
var FilesystemPreviewTypeGetType func() O.Type
View Source 
var IoErrorEnumGetType func() O.Type
View Source 
var IoStreamSpliceFlagsGetType func() O.Type
View Source 
var MemorySettingsBackendNew func() *SettingsBackend
View Source 
var MountMountFlagsGetType func() O.Type
View Source 
var MountOperationResultGetType func() O.Type
View Source 
var MountUnmountFlagsGetType func() O.Type
View Source 
var NativeVolumeMonitorGetType func() O.Type
View Source 
var NullSettingsBackendNew func() *SettingsBackend
View Source 
var OutputStreamSpliceFlagsGetType func() O.Type
View Source 
var PasswordSaveGetType func() O.Type
View Source 
var PollableSourceNew func(pollableStream *O.Object) *L.Source
View Source 
var ProxyAddressEnumeratorGetType func() O.Type
View Source 
var SettingsBindFlagsGetType func() O.Type
View Source 
var SocketFamilyGetType func() O.Type
View Source 
var SocketMsgFlagsGetType func() O.Type
View Source 
var SocketProtocolGetType func() O.Type
View Source 
var SocketTypeGetType func() O.Type
View Source 
var TlsCertificateFlagsGetType func() O.Type
View Source 
var TlsRehandshakeModeGetType func() O.Type
View Source 
var ZlibCompressorFormatGetType func() O.Type

Functions

This section is empty.

Types

type Action 

type Action struct{}

func (*Action) Activate 

func (a *Action) Activate(parameter *L.Variant)

func (*Action) GetEnabled 

func (a *Action) GetEnabled() bool

func (*Action) GetParameterType 

func (a *Action) GetParameterType() *L.VariantType

func (*Action) GetState 

func (a *Action) GetState() *L.Variant

func (*Action) GetStateHint 

func (a *Action) GetStateHint() *L.Variant

func (*Action) GetStateType 

func (a *Action) GetStateType() *L.VariantType

func (*Action) SetState 

func (a *Action) SetState(value *L.Variant)

type ActionGroup 

type ActionGroup struct{}

func (*ActionGroup) ActionAdded 

func (a *ActionGroup) ActionAdded(actionName string)

func (*ActionGroup) ActionEnabledChanged 

func (a *ActionGroup) ActionEnabledChanged(actionName string, enabled bool)

func (*ActionGroup) ActionRemoved 

func (a *ActionGroup) ActionRemoved(actionName string)

func (*ActionGroup) ActionStateChanged 

func (a *ActionGroup) ActionStateChanged(actionName string, state *L.Variant)

func (*ActionGroup) ActivateAction 

func (a *ActionGroup) ActivateAction(actionName string, parameter *L.Variant)

func (*ActionGroup) ChangeActionState 

func (a *ActionGroup) ChangeActionState(actionName string, value *L.Variant)

func (*ActionGroup) GetActionEnabled 

func (a *ActionGroup) GetActionEnabled(actionName string) bool

func (*ActionGroup) GetActionParameterType 

func (a *ActionGroup) GetActionParameterType(actionName string) *L.VariantType

func (*ActionGroup) GetActionState 

func (a *ActionGroup) GetActionState(actionName string) *L.Variant

func (*ActionGroup) GetActionStateHint 

func (a *ActionGroup) GetActionStateHint(actionName string) *L.Variant

func (*ActionGroup) GetActionStateType 

func (a *ActionGroup) GetActionStateType(actionName string) *L.VariantType

func (*ActionGroup) HasAction 

func (a *ActionGroup) HasAction(actionName string) bool

func (*ActionGroup) ListActions 

func (a *ActionGroup) ListActions() []string

type AppInfo 

type AppInfo struct{}

func (*AppInfo) AddSupportsType 

func (a *AppInfo) AddSupportsType(contentType string, err **L.Error) bool

func (*AppInfo) CanDelete 

func (a *AppInfo) CanDelete() bool

func (*AppInfo) CanRemoveSupportsType 

func (a *AppInfo) CanRemoveSupportsType() bool

func (*AppInfo) Delete 

func (a *AppInfo) Delete() bool

func (*AppInfo) Dup 

func (a *AppInfo) Dup() *AppInfo

func (*AppInfo) Equal 

func (a *AppInfo) Equal(appinfo2 *AppInfo) bool

func (*AppInfo) GetCommandline 

func (a *AppInfo) GetCommandline() string

func (*AppInfo) GetDescription 

func (a *AppInfo) GetDescription() string

func (*AppInfo) GetDisplayName 

func (a *AppInfo) GetDisplayName() string

func (*AppInfo) GetExecutable 

func (a *AppInfo) GetExecutable() string

func (*AppInfo) GetIcon 

func (a *AppInfo) GetIcon() *Icon

func (*AppInfo) GetId 

func (a *AppInfo) GetId() string

func (*AppInfo) GetName 

func (a *AppInfo) GetName() string

func (*AppInfo) Launch 

func (a *AppInfo) Launch(files *L.List, launchContext *AppLaunchContext, err **L.Error) bool

func (*AppInfo) LaunchUris 

func (a *AppInfo) LaunchUris(uris *L.List, launchContext *AppLaunchContext, err **L.Error) bool

func (*AppInfo) RemoveSupportsType 

func (a *AppInfo) RemoveSupportsType(contentType string, err **L.Error) bool

func (*AppInfo) SetAsDefaultForExtension 

func (a *AppInfo) SetAsDefaultForExtension(extension string, err **L.Error) bool

func (*AppInfo) SetAsDefaultForType 

func (a *AppInfo) SetAsDefaultForType(contentType string, err **L.Error) bool

func (*AppInfo) SetAsLastUsedForType 

func (a *AppInfo) SetAsLastUsedForType(contentType string, err **L.Error) bool

func (*AppInfo) ShouldShow 

func (a *AppInfo) ShouldShow() bool

func (*AppInfo) SupportsFiles 

func (a *AppInfo) SupportsFiles() bool

func (*AppInfo) SupportsUris 

func (a *AppInfo) SupportsUris() bool

type AppInfoCreateFlags 

type AppInfoCreateFlags Enum
const (
	APP_INFO_CREATE_NEEDS_TERMINAL AppInfoCreateFlags = 1 << iota
	APP_INFO_CREATE_SUPPORTS_URIS
	APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION
	APP_INFO_CREATE_NONE AppInfoCreateFlags = 0
)

type AppLaunchContext 

type AppLaunchContext struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*AppLaunchContext) GetDisplay 

func (a *AppLaunchContext) GetDisplay(info *AppInfo, files *L.List) string

func (*AppLaunchContext) GetStartupNotifyId 

func (a *AppLaunchContext) GetStartupNotifyId(info *AppInfo, files *L.List) string

func (*AppLaunchContext) LaunchFailed 

func (a *AppLaunchContext) LaunchFailed(startupNotifyId string)

type Application 

type Application struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Application) Activate 

func (a *Application) Activate()

func (*Application) GetApplicationId 

func (a *Application) GetApplicationId() string

func (*Application) GetFlags 

func (a *Application) GetFlags() ApplicationFlags

func (*Application) GetInactivityTimeout 

func (a *Application) GetInactivityTimeout() uint

func (*Application) GetIsRegistered 

func (a *Application) GetIsRegistered() bool

func (*Application) GetIsRemote 

func (a *Application) GetIsRemote() bool

func (*Application) Hold 

func (a *Application) Hold()

func (*Application) Open 

func (a *Application) Open(files **File, nFiles int, hint string)

func (*Application) Register 

func (a *Application) Register(cancellable *Cancellable, err **L.Error) bool

func (*Application) Release 

func (a *Application) Release()

func (*Application) Run 

func (a *Application) Run(argc int, argv **T.Char) int

func (*Application) SetActionGroup 

func (a *Application) SetActionGroup(ag *ActionGroup)

func (*Application) SetApplicationId 

func (a *Application) SetApplicationId(applicationId string)

func (*Application) SetFlags 

func (a *Application) SetFlags(flags ApplicationFlags)

func (*Application) SetInactivityTimeout 

func (a *Application) SetInactivityTimeout(inactivityTimeout uint)

type ApplicationCommandLine 

type ApplicationCommandLine struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*ApplicationCommandLine) GetArguments 

func (a *ApplicationCommandLine) GetArguments(argc *int) []string

func (*ApplicationCommandLine) GetCwd 

func (a *ApplicationCommandLine) GetCwd() string

func (*ApplicationCommandLine) GetEnviron 

func (a *ApplicationCommandLine) GetEnviron() []string

func (*ApplicationCommandLine) GetExitStatus 

func (a *ApplicationCommandLine) GetExitStatus() int

func (*ApplicationCommandLine) GetIsRemote 

func (a *ApplicationCommandLine) GetIsRemote() bool

func (*ApplicationCommandLine) GetPlatformData 

func (a *ApplicationCommandLine) GetPlatformData() *L.Variant

func (*ApplicationCommandLine) Getenv 

func (a *ApplicationCommandLine) Getenv(name string) string

func (*ApplicationCommandLine) Print 

func (a *ApplicationCommandLine) Print(format string, v ...VArg)

func (*ApplicationCommandLine) Printerr 

func (a *ApplicationCommandLine) Printerr(format string, v ...VArg)

func (*ApplicationCommandLine) SetExitStatus 

func (a *ApplicationCommandLine) SetExitStatus(exitStatus int)

type ApplicationFlags 

type ApplicationFlags Enum
const (
	APPLICATION_IS_SERVICE ApplicationFlags = 1 << iota
	APPLICATION_IS_LAUNCHER
	APPLICATION_HANDLES_OPEN
	APPLICATION_HANDLES_COMMAND_LINE
	APPLICATION_SEND_ENVIRONMENT
	APPLICATION_FLAGS_NONE ApplicationFlags = 0
)

type AsyncInitable 

type AsyncInitable struct{}

func (*AsyncInitable) InitAsync 

func (a *AsyncInitable) InitAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*AsyncInitable) InitFinish 

func (a *AsyncInitable) InitFinish(res *AsyncResult, err **L.Error) bool

func (*AsyncInitable) NewFinish 

func (a *AsyncInitable) NewFinish(res *AsyncResult, err **L.Error) *O.Object

type AsyncReadyCallback 

type AsyncReadyCallback func(
	sourceObject *O.Object,
	res *AsyncResult,
	userData T.Gpointer)

type AsyncResult 

type AsyncResult struct{}

func (*AsyncResult) GetSourceObject 

func (a *AsyncResult) GetSourceObject() *O.Object

func (*AsyncResult) GetUserData 

func (a *AsyncResult) GetUserData() T.Gpointer

type BufferedInputStream 

type BufferedInputStream struct {
	Parent FilterInputStream
	// contains filtered or unexported fields
}

func (*BufferedInputStream) Fill 

func (b *BufferedInputStream) Fill(count T.Gssize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*BufferedInputStream) FillAsync 

func (b *BufferedInputStream) FillAsync(count T.Gssize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*BufferedInputStream) FillFinish 

func (b *BufferedInputStream) FillFinish(result *AsyncResult, err **L.Error) T.Gssize

func (*BufferedInputStream) GetAvailable 

func (b *BufferedInputStream) GetAvailable() T.Gsize

func (*BufferedInputStream) GetBufferSize 

func (b *BufferedInputStream) GetBufferSize() T.Gsize

func (*BufferedInputStream) Peek 

func (b *BufferedInputStream) Peek(buffer *T.Void, offset, count T.Gsize) T.Gsize

func (*BufferedInputStream) PeekBuffer 

func (b *BufferedInputStream) PeekBuffer(count *T.Gsize) *T.Void

func (*BufferedInputStream) ReadByte 

func (b *BufferedInputStream) ReadByte(cancellable *Cancellable, err **L.Error) int

func (*BufferedInputStream) SetBufferSize 

func (b *BufferedInputStream) SetBufferSize(size T.Gsize)

type BufferedOutputStream 

type BufferedOutputStream struct {
	Parent FilterOutputStream
	// contains filtered or unexported fields
}

func (*BufferedOutputStream) GetAutoGrow 

func (b *BufferedOutputStream) GetAutoGrow() bool

func (*BufferedOutputStream) GetBufferSize 

func (b *BufferedOutputStream) GetBufferSize() T.Gsize

func (*BufferedOutputStream) SetAutoGrow 

func (b *BufferedOutputStream) SetAutoGrow(autoGrow bool)

func (*BufferedOutputStream) SetBufferSize 

func (b *BufferedOutputStream) SetBufferSize(size T.Gsize)

type BusAcquiredCallback 

type BusAcquiredCallback func(
	connection *DBusConnection,
	name string,
	userData T.Gpointer)

type BusNameAcquiredCallback 

type BusNameAcquiredCallback func(
	connection *DBusConnection,
	name string,
	userData T.Gpointer)

type BusNameAppearedCallback 

type BusNameAppearedCallback func(
	connection *DBusConnection,
	name string,
	nameOwner string,
	userData T.Gpointer)

type BusNameLostCallback 

type BusNameLostCallback func(
	connection *DBusConnection,
	name string,
	userData T.Gpointer)

type BusNameOwnerFlags 

type BusNameOwnerFlags Enum
const (
	BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT BusNameOwnerFlags = 1 << iota
	BUS_NAME_OWNER_FLAGS_REPLACE
	BUS_NAME_OWNER_FLAGS_NONE BusNameOwnerFlags = 0
)

type BusNameVanishedCallback 

type BusNameVanishedCallback func(
	connection *DBusConnection,
	name string,
	userData T.Gpointer)

type BusNameWatcherFlags 

type BusNameWatcherFlags Enum
const (
	BUS_NAME_WATCHER_FLAGS_AUTO_START BusNameWatcherFlags = 1 << iota
	BUS_NAME_WATCHER_FLAGS_NONE       BusNameWatcherFlags = 0
)

type BusType 

type BusType Enum
const (
	BUS_TYPE_STARTER BusType = iota - 1
	BUS_TYPE_NONE
	BUS_TYPE_SYSTEM
	BUS_TYPE_SESSION
)

func (BusType) Get 

func (b BusType) Get(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (BusType) GetSync 

func (b BusType) GetSync(cancellable *Cancellable, err **L.Error) *DBusConnection

func (BusType) OwnName 

func (b BusType) OwnName(name string, flags BusNameOwnerFlags, busAcquiredHandler BusAcquiredCallback, nameAcquiredHandler BusNameAcquiredCallback, nameLostHandler BusNameLostCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint

func (BusType) OwnNameWithClosures 

func (b BusType) OwnNameWithClosures(name string, flags BusNameOwnerFlags, busAcquiredClosure, nameAcquiredClosure, nameLostClosure *O.Closure) uint

func (BusType) WatchName 

func (b BusType) WatchName(name string, flags BusNameWatcherFlags, nameAppearedHandler BusNameAppearedCallback, nameVanishedHandler BusNameVanishedCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint

func (BusType) WatchNameWithClosures 

func (b BusType) WatchNameWithClosures(name string, flags BusNameWatcherFlags, nameAppearedClosure, nameVanishedClosure *O.Closure) uint

type Cancellable 

type Cancellable struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Cancellable) Cancel 

func (c *Cancellable) Cancel()

func (*Cancellable) Connect 

func (c *Cancellable) Connect(callback O.Callback, data T.Gpointer, dataDestroyFunc O.DestroyNotify) T.Gulong

func (*Cancellable) Disconnect 

func (c *Cancellable) Disconnect(handlerId T.Gulong)

func (*Cancellable) GetFd 

func (c *Cancellable) GetFd() int

func (*Cancellable) IsCancelled 

func (c *Cancellable) IsCancelled() bool

func (*Cancellable) MakePollfd 

func (c *Cancellable) MakePollfd(pollfd *T.GPollFD) bool

func (*Cancellable) PopCurrent 

func (c *Cancellable) PopCurrent()

func (*Cancellable) PushCurrent 

func (c *Cancellable) PushCurrent()

func (*Cancellable) ReleaseFd 

func (c *Cancellable) ReleaseFd()

func (*Cancellable) Reset 

func (c *Cancellable) Reset()

func (*Cancellable) SetErrorIfCancelled 

func (c *Cancellable) SetErrorIfCancelled(err **L.Error) bool

func (*Cancellable) SourceNew 

func (c *Cancellable) SourceNew() *O.Source

type CharsetConverter 

type CharsetConverter struct{}

func (*CharsetConverter) GetNumFallbacks 

func (c *CharsetConverter) GetNumFallbacks() uint

func (*CharsetConverter) GetUseFallback 

func (c *CharsetConverter) GetUseFallback() bool

func (*CharsetConverter) SetUseFallback 

func (c *CharsetConverter) SetUseFallback(useFallback bool)

type Converter 

type Converter struct{}

func (*Converter) Convert 

func (c *Converter) Convert(inbuf *T.Void, inbufSize T.Gsize, outbuf *T.Void, outbufSize T.Gsize, flags ConverterFlags, bytesRead, bytesWritten *T.Gsize, err **L.Error) ConverterResult

func (*Converter) Reset 

func (c *Converter) Reset()

type ConverterFlags 

type ConverterFlags Enum
const (
	CONVERTER_INPUT_AT_END ConverterFlags = 1 << iota
	CONVERTER_FLUSH
	CONVERTER_NO_FLAGS ConverterFlags = 0
)

type ConverterInputStream 

type ConverterInputStream struct {
	Parent FilterInputStream
	// contains filtered or unexported fields
}

func (*ConverterInputStream) GetConverter 

func (c *ConverterInputStream) GetConverter() *Converter

type ConverterOutputStream 

type ConverterOutputStream struct {
	Parent FilterOutputStream
	// contains filtered or unexported fields
}

func (*ConverterOutputStream) GetConverter 

func (c *ConverterOutputStream) GetConverter() *Converter

type ConverterResult 

type ConverterResult Enum
const (
	CONVERTER_ERROR ConverterResult = iota
	CONVERTER_CONVERTED
	CONVERTER_FINISHED
	CONVERTER_FLUSHED
)

type Credentials 

type Credentials struct{}

func (*Credentials) GetNative 

func (c *Credentials) GetNative(nativeType CredentialsType) T.Gpointer

func (*Credentials) IsSameUser 

func (c *Credentials) IsSameUser(otherCredentials *Credentials, err **L.Error) bool

func (*Credentials) SetNative 

func (c *Credentials) SetNative(nativeType CredentialsType, native T.Gpointer)

func (*Credentials) ToString 

func (c *Credentials) ToString() string

type CredentialsType 

type CredentialsType Enum
const (
	CREDENTIALS_TYPE_INVALID CredentialsType = iota
	CREDENTIALS_TYPE_LINUX_UCRED
	CREDENTIALS_TYPE_FREEBSD_CMSGCRED
)

type DBusAnnotationInfo 

type DBusAnnotationInfo struct {
	RefCount    int
	Key         *T.Gchar
	Value       *T.Gchar
	Annotations **DBusAnnotationInfo
}

func (*DBusAnnotationInfo) Ref 

func (d *DBusAnnotationInfo) Ref() *DBusAnnotationInfo

func (*DBusAnnotationInfo) Unref 

func (d *DBusAnnotationInfo) Unref()

type DBusArgInfo 

type DBusArgInfo struct {
	RefCount    int
	Name        *T.Gchar
	Signature   *T.Gchar
	Annotations **DBusAnnotationInfo
}

func (*DBusArgInfo) Ref 

func (d *DBusArgInfo) Ref() *DBusArgInfo

func (*DBusArgInfo) Unref 

func (d *DBusArgInfo) Unref()

type DBusAuthObserver 

type DBusAuthObserver struct{}

func (*DBusAuthObserver) AuthorizeAuthenticatedPeer 

func (d *DBusAuthObserver) AuthorizeAuthenticatedPeer(stream *IOStream, credentials *Credentials) bool

type DBusCallFlags 

type DBusCallFlags Enum
const (
	DBUS_CALL_FLAGS_NO_AUTO_START DBusCallFlags = 1 << iota
	DBUS_CALL_FLAGS_NONE          DBusCallFlags = 0
)

type DBusCapabilityFlags 

type DBusCapabilityFlags Enum
const (
	DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING DBusCapabilityFlags = 1 << iota
	DBUS_CAPABILITY_FLAGS_NONE            DBusCapabilityFlags = 0
)

type DBusConnection 

type DBusConnection struct{}

func (*DBusConnection) AddFilter 

func (d *DBusConnection) AddFilter(filterFunction DBusMessageFilterFunction, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint

func (*DBusConnection) Call 

func (d *DBusConnection) Call(busName, objectPath, interfaceName, methodName string, parameters *L.Variant, replyType *L.VariantType, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DBusConnection) CallFinish 

func (d *DBusConnection) CallFinish(res *AsyncResult, err **L.Error) *L.Variant

func (*DBusConnection) CallSync 

func (d *DBusConnection) CallSync(busName, objectPath, interfaceName, methodName string, parameters *L.Variant, replyType *L.VariantType, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, err **L.Error) *L.Variant

func (*DBusConnection) Close 

func (d *DBusConnection) Close(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DBusConnection) CloseFinish 

func (d *DBusConnection) CloseFinish(res *AsyncResult, err **L.Error) bool

func (*DBusConnection) CloseSync 

func (d *DBusConnection) CloseSync(cancellable *Cancellable, err **L.Error) bool

func (*DBusConnection) EmitSignal 

func (d *DBusConnection) EmitSignal(destinationBusName, objectPath, interfaceName string, signalName string, parameters *L.Variant, err **L.Error) bool

func (*DBusConnection) Flush 

func (d *DBusConnection) Flush(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DBusConnection) FlushFinish 

func (d *DBusConnection) FlushFinish(res *AsyncResult, err **L.Error) bool

func (*DBusConnection) FlushSync 

func (d *DBusConnection) FlushSync(cancellable *Cancellable, err **L.Error) bool

func (*DBusConnection) GetCapabilities 

func (d *DBusConnection) GetCapabilities() DBusCapabilityFlags

func (*DBusConnection) GetExitOnClose 

func (d *DBusConnection) GetExitOnClose() bool

func (*DBusConnection) GetGuid 

func (d *DBusConnection) GetGuid() string

func (*DBusConnection) GetPeerCredentials 

func (d *DBusConnection) GetPeerCredentials() *Credentials

func (*DBusConnection) GetStream 

func (d *DBusConnection) GetStream() *IOStream

func (*DBusConnection) GetUniqueName 

func (d *DBusConnection) GetUniqueName() string

func (*DBusConnection) IsClosed 

func (d *DBusConnection) IsClosed() bool

func (*DBusConnection) RegisterObject 

func (d *DBusConnection) RegisterObject(objectPath string, interfaceInfo *DBusInterfaceInfo, vtable *DBusInterfaceVTable, userData T.Gpointer, userDataFreeFunc O.DestroyNotify, err **L.Error) uint

func (*DBusConnection) RegisterSubtree 

func (d *DBusConnection) RegisterSubtree(objectPath string, vtable *DBusSubtreeVTable, flags DBusSubtreeFlags, userData T.Gpointer, userDataFreeFunc O.DestroyNotify, err **L.Error) uint

func (*DBusConnection) RemoveFilter 

func (d *DBusConnection) RemoveFilter(filterId uint)

func (*DBusConnection) SendMessage 

func (d *DBusConnection) SendMessage(message *DBusMessage, flags DBusSendMessageFlags, outSerial *T.GUint32, err **L.Error) bool

func (*DBusConnection) SendMessageWithReply 

func (d *DBusConnection) SendMessageWithReply(message *DBusMessage, flags DBusSendMessageFlags, timeoutMsec int, outSerial *T.GUint32, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DBusConnection) SendMessageWithReplyFinish 

func (d *DBusConnection) SendMessageWithReplyFinish(res *AsyncResult, err **L.Error) *DBusMessage

func (*DBusConnection) SendMessageWithReplySync 

func (d *DBusConnection) SendMessageWithReplySync(message *DBusMessage, flags DBusSendMessageFlags, timeoutMsec int, outSerial *T.GUint32, cancellable *Cancellable, err **L.Error) *DBusMessage

func (*DBusConnection) SetExitOnClose 

func (d *DBusConnection) SetExitOnClose(exitOnClose bool)

func (*DBusConnection) SignalSubscribe 

func (d *DBusConnection) SignalSubscribe(sender, interfaceName, member, objectPath, arg0 string, flags DBusSignalFlags, callback DBusSignalCallback, userData T.Gpointer, userDataFreeFunc O.DestroyNotify) uint

func (*DBusConnection) SignalUnsubscribe 

func (d *DBusConnection) SignalUnsubscribe(subscriptionId uint)

func (*DBusConnection) StartMessageProcessing 

func (d *DBusConnection) StartMessageProcessing()

func (*DBusConnection) UnregisterObject 

func (d *DBusConnection) UnregisterObject(registrationId uint) bool

func (*DBusConnection) UnregisterSubtree 

func (d *DBusConnection) UnregisterSubtree(registrationId uint) bool

type DBusConnectionFlags 

type DBusConnectionFlags Enum
const (
	DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT DBusConnectionFlags = 1 << iota
	DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER
	DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS
	DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION
	DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING
	DBUS_CONNECTION_FLAGS_NONE DBusConnectionFlags = 0
)

type DBusErrorEntry 

type DBusErrorEntry struct {
	ErrorCode     int
	DbusErrorName *T.Gchar
}

type DBusInterfaceGetPropertyFunc 

type DBusInterfaceGetPropertyFunc func(connection *DBusConnection,
	sender, objectPath, interfaceName, propertyName string,
	err **L.Error, userData T.Gpointer)

type DBusInterfaceInfo 

type DBusInterfaceInfo struct {
	RefCount    int
	Name        *T.Gchar
	Methods     **DBusMethodInfo
	Signals     **DBusSignalInfo
	Properties  **DBusPropertyInfo
	Annotations **DBusAnnotationInfo
}

func (*DBusInterfaceInfo) GenerateXml 

func (d *DBusInterfaceInfo) GenerateXml(indent uint, stringBuilder *L.String)

func (*DBusInterfaceInfo) LookupMethod 

func (d *DBusInterfaceInfo) LookupMethod(name string) *DBusMethodInfo

func (*DBusInterfaceInfo) LookupProperty 

func (d *DBusInterfaceInfo) LookupProperty(name string) *DBusPropertyInfo

func (*DBusInterfaceInfo) LookupSignal 

func (d *DBusInterfaceInfo) LookupSignal(name string) *DBusSignalInfo

func (*DBusInterfaceInfo) Ref 

func (d *DBusInterfaceInfo) Ref() *DBusInterfaceInfo

func (*DBusInterfaceInfo) Unref 

func (d *DBusInterfaceInfo) Unref()

type DBusInterfaceMethodCallFunc 

type DBusInterfaceMethodCallFunc func(connection *DBusConnection,
	sender, objectPath, interfaceName, methodName string,
	parameters *L.Variant, invocation *DBusMethodInvocation,
	userData T.Gpointer)

type DBusInterfaceSetPropertyFunc 

type DBusInterfaceSetPropertyFunc func(connection *DBusConnection,
	sender, objectPath, interfaceName, propertyName string,
	value *L.Variant, err **L.Error, userData T.Gpointer)

type DBusInterfaceVTable 

type DBusInterfaceVTable struct {
	MethodCall  DBusInterfaceMethodCallFunc
	GetProperty DBusInterfaceGetPropertyFunc
	SetProperty DBusInterfaceSetPropertyFunc
	Padding     [8]T.Gpointer
}

type DBusMessage 

type DBusMessage struct{}

func (*DBusMessage) Copy 

func (d *DBusMessage) Copy(err **L.Error) *DBusMessage

func (*DBusMessage) GetArg0 

func (d *DBusMessage) GetArg0() string

func (*DBusMessage) GetBody 

func (d *DBusMessage) GetBody() *L.Variant

func (*DBusMessage) GetByteOrder 

func (d *DBusMessage) GetByteOrder() DBusMessageByteOrder

func (*DBusMessage) GetDestination 

func (d *DBusMessage) GetDestination() string

func (*DBusMessage) GetErrorName 

func (d *DBusMessage) GetErrorName() string

func (*DBusMessage) GetFlags 

func (d *DBusMessage) GetFlags() DBusMessageFlags

func (*DBusMessage) GetHeader 

func (d *DBusMessage) GetHeader(headerField DBusMessageHeaderField) *L.Variant

func (*DBusMessage) GetHeaderFields 

func (d *DBusMessage) GetHeaderFields() *T.Guchar

func (*DBusMessage) GetInterface 

func (d *DBusMessage) GetInterface() string

func (*DBusMessage) GetLocked 

func (d *DBusMessage) GetLocked() bool

func (*DBusMessage) GetMember 

func (d *DBusMessage) GetMember() string

func (*DBusMessage) GetMessageType 

func (d *DBusMessage) GetMessageType() DBusMessageType

func (*DBusMessage) GetNumUnixFds 

func (d *DBusMessage) GetNumUnixFds() T.GUint32

func (*DBusMessage) GetPath 

func (d *DBusMessage) GetPath() string

func (*DBusMessage) GetReplySerial 

func (d *DBusMessage) GetReplySerial() T.GUint32

func (*DBusMessage) GetSender 

func (d *DBusMessage) GetSender() string

func (*DBusMessage) GetSerial 

func (d *DBusMessage) GetSerial() T.GUint32

func (*DBusMessage) GetSignature 

func (d *DBusMessage) GetSignature() string

func (*DBusMessage) GetUnixFdList 

func (d *DBusMessage) GetUnixFdList() *T.GUnixFDList

func (*DBusMessage) Lock 

func (d *DBusMessage) Lock()

func (*DBusMessage) NewMethodError 

func (d *DBusMessage) NewMethodError(errorName, errorMessageFormat string, v ...VArg) *DBusMessage

func (*DBusMessage) NewMethodErrorLiteral 

func (d *DBusMessage) NewMethodErrorLiteral(errorName, errorMessage string) *DBusMessage

func (*DBusMessage) NewMethodErrorValist 

func (d *DBusMessage) NewMethodErrorValist(errorName, errorMessageFormat string, varArgs VAList) *DBusMessage

func (*DBusMessage) NewMethodReply 

func (d *DBusMessage) NewMethodReply() *DBusMessage

func (*DBusMessage) Print 

func (d *DBusMessage) Print(indent uint) string

func (*DBusMessage) SetBody 

func (d *DBusMessage) SetBody(body *L.Variant)

func (*DBusMessage) SetByteOrder 

func (d *DBusMessage) SetByteOrder(byteOrder DBusMessageByteOrder)

func (*DBusMessage) SetDestination 

func (d *DBusMessage) SetDestination(value string)

func (*DBusMessage) SetErrorName 

func (d *DBusMessage) SetErrorName(value string)

func (*DBusMessage) SetFlags 

func (d *DBusMessage) SetFlags(flags DBusMessageFlags)

func (*DBusMessage) SetHeader 

func (d *DBusMessage) SetHeader(headerField DBusMessageHeaderField, value *L.Variant)

func (*DBusMessage) SetInterface 

func (d *DBusMessage) SetInterface(value string)

func (*DBusMessage) SetMember 

func (d *DBusMessage) SetMember(value string)

func (*DBusMessage) SetMessageType 

func (d *DBusMessage) SetMessageType(typ DBusMessageType)

func (*DBusMessage) SetNumUnixFds 

func (d *DBusMessage) SetNumUnixFds(value T.GUint32)

func (*DBusMessage) SetPath 

func (d *DBusMessage) SetPath(value string)

func (*DBusMessage) SetReplySerial 

func (d *DBusMessage) SetReplySerial(value T.GUint32)

func (*DBusMessage) SetSender 

func (d *DBusMessage) SetSender(value string)

func (*DBusMessage) SetSerial 

func (d *DBusMessage) SetSerial(serial T.GUint32)

func (*DBusMessage) SetSignature 

func (d *DBusMessage) SetSignature(value string)

func (*DBusMessage) SetUnixFdList 

func (d *DBusMessage) SetUnixFdList(fdList *T.GUnixFDList)

func (*DBusMessage) ToBlob 

func (d *DBusMessage) ToBlob(outSize *T.Gsize, capabilities DBusCapabilityFlags, err **L.Error) *T.Guchar

func (*DBusMessage) ToGerror 

func (d *DBusMessage) ToGerror(err **L.Error) bool

type DBusMessageByteOrder 

type DBusMessageByteOrder Enum
const (
	DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN    DBusMessageByteOrder = 'B'
	DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN DBusMessageByteOrder = 'l'
)

type DBusMessageFilterFunction 

type DBusMessageFilterFunction func(
	connection *DBusConnection,
	message *DBusMessage,
	incoming bool,
	userData T.Gpointer) *DBusMessage

type DBusMessageFlags 

type DBusMessageFlags Enum
const (
	DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED DBusMessageFlags = 1 << iota
	DBUS_MESSAGE_FLAGS_NO_AUTO_START
	DBUS_MESSAGE_FLAGS_NONE DBusMessageFlags = 0
)

type DBusMessageHeaderField 

type DBusMessageHeaderField Enum
const (
	DBUS_MESSAGE_HEADER_FIELD_INVALID DBusMessageHeaderField = iota
	DBUS_MESSAGE_HEADER_FIELD_PATH
	DBUS_MESSAGE_HEADER_FIELD_INTERFACE
	DBUS_MESSAGE_HEADER_FIELD_MEMBER
	DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME
	DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL
	DBUS_MESSAGE_HEADER_FIELD_DESTINATION
	DBUS_MESSAGE_HEADER_FIELD_SENDER
	DBUS_MESSAGE_HEADER_FIELD_SIGNATURE
	DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS
)

type DBusMessageType 

type DBusMessageType Enum
const (
	DBUS_MESSAGE_TYPE_INVALID DBusMessageType = iota
	DBUS_MESSAGE_TYPE_METHOD_CALL
	DBUS_MESSAGE_TYPE_METHOD_RETURN
	DBUS_MESSAGE_TYPE_ERROR
	DBUS_MESSAGE_TYPE_SIGNAL
)

type DBusMethodInfo 

type DBusMethodInfo struct {
	RefCount    int
	Name        *T.Gchar
	InArgs      **DBusArgInfo
	OutArgs     **DBusArgInfo
	Annotations **DBusAnnotationInfo
}

func (*DBusMethodInfo) Ref 

func (d *DBusMethodInfo) Ref() *DBusMethodInfo

func (*DBusMethodInfo) Unref 

func (d *DBusMethodInfo) Unref()

type DBusMethodInvocation 

type DBusMethodInvocation struct{}

func (*DBusMethodInvocation) GetConnection 

func (d *DBusMethodInvocation) GetConnection() *DBusConnection

func (*DBusMethodInvocation) GetInterfaceName 

func (d *DBusMethodInvocation) GetInterfaceName() string

func (*DBusMethodInvocation) GetMessage 

func (d *DBusMethodInvocation) GetMessage() *DBusMessage

func (*DBusMethodInvocation) GetMethodInfo 

func (d *DBusMethodInvocation) GetMethodInfo() *DBusMethodInfo

func (*DBusMethodInvocation) GetMethodName 

func (d *DBusMethodInvocation) GetMethodName() string

func (*DBusMethodInvocation) GetObjectPath 

func (d *DBusMethodInvocation) GetObjectPath() string

func (*DBusMethodInvocation) GetParameters 

func (d *DBusMethodInvocation) GetParameters() *L.Variant

func (*DBusMethodInvocation) GetSender 

func (d *DBusMethodInvocation) GetSender() string

func (*DBusMethodInvocation) GetUserData 

func (d *DBusMethodInvocation) GetUserData() T.Gpointer

func (*DBusMethodInvocation) ReturnDBusError 

func (d *DBusMethodInvocation) ReturnDBusError(errorName, errorMessage string)

func (*DBusMethodInvocation) ReturnError 

func (d *DBusMethodInvocation) ReturnError(domain L.Quark, code int, format string, v ...VArg)

func (*DBusMethodInvocation) ReturnErrorLiteral 

func (d *DBusMethodInvocation) ReturnErrorLiteral(domain L.Quark, code int, message string)

func (*DBusMethodInvocation) ReturnErrorValist 

func (d *DBusMethodInvocation) ReturnErrorValist(domain L.Quark, code int, format string, varArgs VAList)

func (*DBusMethodInvocation) ReturnGerror 

func (d *DBusMethodInvocation) ReturnGerror(err *L.Error)

func (*DBusMethodInvocation) ReturnValue 

func (d *DBusMethodInvocation) ReturnValue(parameters *L.Variant)

type DBusNodeInfo 

type DBusNodeInfo struct {
	Ref_count   int
	Path        *T.Gchar
	Interfaces  **DBusInterfaceInfo
	Nodes       **DBusNodeInfo
	Annotations **DBusAnnotationInfo
}

func (*DBusNodeInfo) GenerateXml 

func (d *DBusNodeInfo) GenerateXml(indent uint, stringBuilder *L.String)

func (*DBusNodeInfo) LookupInterface 

func (d *DBusNodeInfo) LookupInterface(name string) *DBusInterfaceInfo

func (*DBusNodeInfo) Ref 

func (d *DBusNodeInfo) Ref() *DBusNodeInfo

func (*DBusNodeInfo) Unref 

func (d *DBusNodeInfo) Unref()

type DBusPropertyInfo 

type DBusPropertyInfo struct {
	RefCount    int
	Name        *T.Gchar
	Signature   *T.Gchar
	Flags       DBusPropertyInfoFlags
	Annotations **DBusAnnotationInfo
}

func (*DBusPropertyInfo) Ref 

func (d *DBusPropertyInfo) Ref() *DBusPropertyInfo

func (*DBusPropertyInfo) Unref 

func (d *DBusPropertyInfo) Unref()

type DBusPropertyInfoFlags 

type DBusPropertyInfoFlags Enum
const (
	DBUS_PROPERTY_INFO_FLAGS_READABLE DBusPropertyInfoFlags = 1 << iota
	DBUS_PROPERTY_INFO_FLAGS_WRITABLE
	DBUS_PROPERTY_INFO_FLAGS_NONE DBusPropertyInfoFlags = 0
)

type DBusProxy 

type DBusProxy struct {
	Parent O.Object
	Priv   *struct{}
}

func (*DBusProxy) Call 

func (d *DBusProxy) Call(methodName string, parameters *L.Variant, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DBusProxy) CallFinish 

func (d *DBusProxy) CallFinish(res *AsyncResult, err **L.Error) *L.Variant

func (*DBusProxy) CallSync 

func (d *DBusProxy) CallSync(methodName string, parameters *L.Variant, flags DBusCallFlags, timeoutMsec int, cancellable *Cancellable, err **L.Error) *L.Variant

func (*DBusProxy) GetCachedProperty 

func (d *DBusProxy) GetCachedProperty(propertyName string) *L.Variant

func (*DBusProxy) GetCachedPropertyNames 

func (d *DBusProxy) GetCachedPropertyNames() []string

func (*DBusProxy) GetConnection 

func (d *DBusProxy) GetConnection() *DBusConnection

func (*DBusProxy) GetDefaultTimeout 

func (d *DBusProxy) GetDefaultTimeout() int

func (*DBusProxy) GetFlags 

func (d *DBusProxy) GetFlags() DBusProxyFlags

func (*DBusProxy) GetInterfaceInfo 

func (d *DBusProxy) GetInterfaceInfo() *DBusInterfaceInfo

func (*DBusProxy) GetInterfaceName 

func (d *DBusProxy) GetInterfaceName() string

func (*DBusProxy) GetName 

func (d *DBusProxy) GetName() string

func (*DBusProxy) GetNameOwner 

func (d *DBusProxy) GetNameOwner() string

func (*DBusProxy) GetObjectPath 

func (d *DBusProxy) GetObjectPath() string

func (*DBusProxy) SetCachedProperty 

func (d *DBusProxy) SetCachedProperty(propertyName string, value *L.Variant)

func (*DBusProxy) SetDefaultTimeout 

func (d *DBusProxy) SetDefaultTimeout(timeoutMsec int)

func (*DBusProxy) SetInterfaceInfo 

func (d *DBusProxy) SetInterfaceInfo(info *DBusInterfaceInfo)

type DBusProxyFlags 

type DBusProxyFlags Enum
const (
	DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES DBusProxyFlags = 1 << iota
	DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS
	DBUS_PROXY_FLAGS_DO_NOT_AUTO_START
	DBUS_PROXY_FLAGS_NONE DBusProxyFlags = 0
)

type DBusSendMessageFlags 

type DBusSendMessageFlags Enum
const (
	DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL DBusSendMessageFlags = 1 << iota
	DBUS_SEND_MESSAGE_FLAGS_NONE            DBusSendMessageFlags = 0
)

type DBusServer 

type DBusServer struct{}

func (*DBusServer) GetClientAddress 

func (d *DBusServer) GetClientAddress() string

func (*DBusServer) GetFlags 

func (d *DBusServer) GetFlags() DBusServerFlags

func (*DBusServer) GetGuid 

func (d *DBusServer) GetGuid() string

func (*DBusServer) IsActive 

func (d *DBusServer) IsActive() bool

func (*DBusServer) Start 

func (d *DBusServer) Start()

func (*DBusServer) Stop 

func (d *DBusServer) Stop()

type DBusServerFlags 

type DBusServerFlags Enum
const (
	DBUS_SERVER_FLAGS_RUN_IN_THREAD DBusServerFlags = 1 << iota
	DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS
	DBUS_SERVER_FLAGS_NONE DBusServerFlags = 0
)

type DBusSignalCallback 

type DBusSignalCallback func(connection *DBusConnection,
	senderName, objectPath, interfaceName, signalName string,
	parameters *L.Variant, userData T.Gpointer)

type DBusSignalFlags 

type DBusSignalFlags Enum
const (
	DBUS_SIGNAL_FLAGS_NO_MATCH_RULE DBusSignalFlags = 1 << iota
	DBUS_SIGNAL_FLAGS_NONE          DBusSignalFlags = 0
)

type DBusSignalInfo 

type DBusSignalInfo struct {
	RefCount    int
	Name        *T.Gchar
	Args        **DBusArgInfo
	Annotations **DBusAnnotationInfo
}

func (*DBusSignalInfo) Ref 

func (d *DBusSignalInfo) Ref() *DBusSignalInfo

func (*DBusSignalInfo) Unref 

func (d *DBusSignalInfo) Unref()

type DBusSubtreeDispatchFunc 

type DBusSubtreeDispatchFunc func(connection *DBusConnection,
	sender, objectPath, interfaceName, node string,
	outUserData *T.Gpointer,
	userData T.Gpointer) *DBusInterfaceVTable

type DBusSubtreeEnumerateFunc 

type DBusSubtreeEnumerateFunc func(connection *DBusConnection,
	sender, objectPath string, userData T.Gpointer) []string

type DBusSubtreeFlags 

type DBusSubtreeFlags Enum
const (
	DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES DBusSubtreeFlags = 1 << iota
	DBUS_SUBTREE_FLAGS_NONE                           DBusSubtreeFlags = 0
)

type DBusSubtreeIntrospectFunc 

type DBusSubtreeIntrospectFunc func(connection *DBusConnection,
	sender, objectPath, node string,
	userData T.Gpointer) **DBusInterfaceInfo

type DBusSubtreeVTable 

type DBusSubtreeVTable struct {
	Enumerate  DBusSubtreeEnumerateFunc
	Introspect DBusSubtreeIntrospectFunc
	Dispatch   DBusSubtreeDispatchFunc
	Padding    [8]T.Gpointer
}

type DataInputStream 

type DataInputStream struct {
	Parent BufferedInputStream
	// contains filtered or unexported fields
}

func (*DataInputStream) GetByteOrder 

func (d *DataInputStream) GetByteOrder() DataStreamByteOrder

func (*DataInputStream) GetNewlineType 

func (d *DataInputStream) GetNewlineType() DataStreamNewlineType

func (*DataInputStream) ReadByte 

func (d *DataInputStream) ReadByte(cancellable *Cancellable, err **L.Error) T.Guchar

func (*DataInputStream) ReadInt16 

func (d *DataInputStream) ReadInt16(cancellable *Cancellable, err **L.Error) int16

func (*DataInputStream) ReadInt32 

func (d *DataInputStream) ReadInt32(cancellable *Cancellable, err **L.Error) T.GInt32

func (*DataInputStream) ReadInt64 

func (d *DataInputStream) ReadInt64(cancellable *Cancellable, err **L.Error) int64

func (*DataInputStream) ReadLine 

func (d *DataInputStream) ReadLine(length *T.Gsize, cancellable *Cancellable, err **L.Error) string

func (*DataInputStream) ReadLineAsync 

func (d *DataInputStream) ReadLineAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DataInputStream) ReadLineFinish 

func (d *DataInputStream) ReadLineFinish(result *AsyncResult, length *T.Gsize, err **L.Error) string

func (*DataInputStream) ReadUint16 

func (d *DataInputStream) ReadUint16(cancellable *Cancellable, err **L.Error) uint16

func (*DataInputStream) ReadUint32 

func (d *DataInputStream) ReadUint32(cancellable *Cancellable, err **L.Error) T.GUint32

func (*DataInputStream) ReadUint64 

func (d *DataInputStream) ReadUint64(cancellable *Cancellable, err **L.Error) uint64

func (*DataInputStream) ReadUntil 

func (d *DataInputStream) ReadUntil(stopChars string, length *T.Gsize, cancellable *Cancellable, err **L.Error) string

func (*DataInputStream) ReadUntilAsync 

func (d *DataInputStream) ReadUntilAsync(stopChars string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DataInputStream) ReadUntilFinish 

func (d *DataInputStream) ReadUntilFinish(result *AsyncResult, length *T.Gsize, err **L.Error) string

func (*DataInputStream) ReadUpto 

func (d *DataInputStream) ReadUpto(stopChars string, stopCharsLen T.Gssize, length *T.Gsize, cancellable *Cancellable, err **L.Error) string

func (*DataInputStream) ReadUptoAsync 

func (d *DataInputStream) ReadUptoAsync(stopChars string, stopCharsLen T.Gssize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*DataInputStream) ReadUptoFinish 

func (d *DataInputStream) ReadUptoFinish(result *AsyncResult, length *T.Gsize, err **L.Error) string

func (*DataInputStream) SetByteOrder 

func (d *DataInputStream) SetByteOrder(order DataStreamByteOrder)

func (*DataInputStream) SetNewlineType 

func (d *DataInputStream) SetNewlineType(typ DataStreamNewlineType)

type DataOutputStream 

type DataOutputStream struct {
	Parent FilterOutputStream
	// contains filtered or unexported fields
}

func (*DataOutputStream) GetByteOrder 

func (d *DataOutputStream) GetByteOrder() DataStreamByteOrder

func (*DataOutputStream) PutByte 

func (d *DataOutputStream) PutByte(data T.Guchar, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutInt16 

func (d *DataOutputStream) PutInt16(data int16, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutInt32 

func (d *DataOutputStream) PutInt32(data T.GInt32, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutInt64 

func (d *DataOutputStream) PutInt64(data int64, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutString 

func (d *DataOutputStream) PutString(str string, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutUint16 

func (d *DataOutputStream) PutUint16(data uint16, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutUint32 

func (d *DataOutputStream) PutUint32(data T.GUint32, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) PutUint64 

func (d *DataOutputStream) PutUint64(data uint64, cancellable *Cancellable, err **L.Error) bool

func (*DataOutputStream) SetByteOrder 

func (d *DataOutputStream) SetByteOrder(order DataStreamByteOrder)

type DataStreamByteOrder 

type DataStreamByteOrder Enum
const (
	DATA_STREAM_BYTE_ORDER_BIG_ENDIAN DataStreamByteOrder = iota
	DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
	DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
)

type DataStreamNewlineType 

type DataStreamNewlineType Enum
const (
	DATA_STREAM_NEWLINE_TYPE_LF DataStreamNewlineType = iota
	DATA_STREAM_NEWLINE_TYPE_CR
	DATA_STREAM_NEWLINE_TYPE_CR_LF
	DATA_STREAM_NEWLINE_TYPE_ANY
)

type Drive 

type Drive struct{}

func (*Drive) CanEject 

func (d *Drive) CanEject() bool

func (*Drive) CanPollForMedia 

func (d *Drive) CanPollForMedia() bool

func (*Drive) CanStart 

func (d *Drive) CanStart() bool

func (*Drive) CanStartDegraded 

func (d *Drive) CanStartDegraded() bool

func (*Drive) CanStop 

func (d *Drive) CanStop() bool

func (*Drive) Eject 

func (d *Drive) Eject(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Drive) EjectFinish 

func (d *Drive) EjectFinish(result *AsyncResult, err **L.Error) bool

func (*Drive) EjectWithOperation 

func (d *Drive) EjectWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Drive) EjectWithOperationFinish 

func (d *Drive) EjectWithOperationFinish(result *AsyncResult, err **L.Error) bool

func (*Drive) EnumerateIdentifiers 

func (d *Drive) EnumerateIdentifiers() []string

func (*Drive) GetIcon 

func (d *Drive) GetIcon() *Icon

func (*Drive) GetIdentifier 

func (d *Drive) GetIdentifier(kind string) string

func (*Drive) GetName 

func (d *Drive) GetName() string

func (*Drive) GetStartStopType 

func (d *Drive) GetStartStopType() DriveStartStopType

func (*Drive) GetVolumes 

func (d *Drive) GetVolumes() *L.List

func (*Drive) HasMedia 

func (d *Drive) HasMedia() bool

func (*Drive) HasVolumes 

func (d *Drive) HasVolumes() bool

func (*Drive) IsMediaCheckAutomatic 

func (d *Drive) IsMediaCheckAutomatic() bool

func (*Drive) IsMediaRemovable 

func (d *Drive) IsMediaRemovable() bool

func (*Drive) PollForMedia 

func (d *Drive) PollForMedia(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Drive) PollForMediaFinish 

func (d *Drive) PollForMediaFinish(result *AsyncResult, err **L.Error) bool

func (*Drive) Start 

func (d *Drive) Start(flags DriveStartFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Drive) StartFinish 

func (d *Drive) StartFinish(result *AsyncResult, err **L.Error) bool

func (*Drive) Stop 

func (d *Drive) Stop(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Drive) StopFinish 

func (d *Drive) StopFinish(result *AsyncResult, err **L.Error) bool

type DriveStartFlags 

type DriveStartFlags Enum
const DRIVE_START_NONE DriveStartFlags = 0

type DriveStartStopType 

type DriveStartStopType Enum
const (
	DRIVE_START_STOP_TYPE_UNKNOWN DriveStartStopType = iota
	DRIVE_START_STOP_TYPE_SHUTDOWN
	DRIVE_START_STOP_TYPE_NETWORK
	DRIVE_START_STOP_TYPE_MULTIDISK
	DRIVE_START_STOP_TYPE_PASSWORD
)

type Emblem 

type Emblem struct{}

func (*Emblem) GetIcon 

func (e *Emblem) GetIcon() *Icon

func (*Emblem) GetOrigin 

func (e *Emblem) GetOrigin() EmblemOrigin

type EmblemOrigin 

type EmblemOrigin Enum
const (
	EMBLEM_ORIGIN_UNKNOWN EmblemOrigin = iota
	EMBLEM_ORIGIN_DEVICE
	EMBLEM_ORIGIN_LIVEMETADATA
	EMBLEM_ORIGIN_TAG
)

type EmblemedIcon 

type EmblemedIcon struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*EmblemedIcon) AddEmblem 

func (e *EmblemedIcon) AddEmblem(emblem *Emblem)

func (*EmblemedIcon) ClearEmblems 

func (e *EmblemedIcon) ClearEmblems()

func (*EmblemedIcon) GetEmblems 

func (e *EmblemedIcon) GetEmblems() *L.List

func (*EmblemedIcon) GetIcon 

func (e *EmblemedIcon) GetIcon() *Icon

type Enum 

type Enum int

type File 

type File struct{}

func (*File) AppendTo 

func (f *File) AppendTo(flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream

func (*File) AppendToAsync 

func (f *File) AppendToAsync(flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) AppendToFinish 

func (f *File) AppendToFinish(res *AsyncResult, err **L.Error) *FileOutputStream

func (*File) Copy 

func (f *File) Copy(destination *File, flags FileCopyFlags, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, err **L.Error) bool

func (*File) CopyAsync 

func (f *File) CopyAsync(destination *File, flags FileCopyFlags, ioPriority int, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) CopyAttributes 

func (f *File) CopyAttributes(destination *File, flags FileCopyFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) CopyFinish 

func (f *File) CopyFinish(res *AsyncResult, err **L.Error) bool

func (*File) Create 

func (f *File) Create(flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream

func (*File) CreateAsync 

func (f *File) CreateAsync(flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) CreateFinish 

func (f *File) CreateFinish(res *AsyncResult, err **L.Error) *FileOutputStream

func (*File) CreateReadwrite 

func (f *File) CreateReadwrite(flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileIOStream

func (*File) CreateReadwriteAsync 

func (f *File) CreateReadwriteAsync(flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) CreateReadwriteFinish 

func (f *File) CreateReadwriteFinish(res *AsyncResult, err **L.Error) *FileIOStream

func (*File) Delete 

func (f *File) Delete(cancellable *Cancellable, err **L.Error) bool

func (*File) Dup 

func (f *File) Dup() *File

func (*File) EjectMountable 

func (f *File) EjectMountable(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) EjectMountableFinish 

func (f *File) EjectMountableFinish(result *AsyncResult, err **L.Error) bool

func (*File) EjectMountableWithOperation 

func (f *File) EjectMountableWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) EjectMountableWithOperationFinish 

func (f *File) EjectMountableWithOperationFinish(result *AsyncResult, err **L.Error) bool

func (*File) EnumerateChildren 

func (f *File) EnumerateChildren(attributes string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) *FileEnumerator

func (*File) EnumerateChildrenAsync 

func (f *File) EnumerateChildrenAsync(attributes string, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) EnumerateChildrenFinish 

func (f *File) EnumerateChildrenFinish(res *AsyncResult, err **L.Error) *FileEnumerator

func (*File) Equal 

func (f *File) Equal(file2 *File) bool

func (*File) FindEnclosingMount 

func (f *File) FindEnclosingMount(cancellable *Cancellable, err **L.Error) *Mount

func (*File) FindEnclosingMountAsync 

func (f *File) FindEnclosingMountAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) FindEnclosingMountFinish 

func (f *File) FindEnclosingMountFinish(res *AsyncResult, err **L.Error) *Mount

func (*File) GetBasename 

func (f *File) GetBasename() string

func (*File) GetChild 

func (f *File) GetChild(name string) *File

func (*File) GetChildForDisplayName 

func (f *File) GetChildForDisplayName(displayName string, err **L.Error) *File

func (*File) GetParent 

func (f *File) GetParent() *File

func (*File) GetParseName 

func (f *File) GetParseName() string

func (*File) GetPath 

func (f *File) GetPath() string

func (*File) GetRelativePath 

func (f *File) GetRelativePath(descendant *File) string

func (*File) GetUri 

func (f *File) GetUri() string

func (*File) GetUriScheme 

func (f *File) GetUriScheme() string

func (*File) HasParent 

func (f *File) HasParent(parent *File) bool

func (*File) HasPrefix 

func (f *File) HasPrefix(prefix *File) bool

func (*File) HasUriScheme 

func (f *File) HasUriScheme(uriScheme string) bool

func (*File) IsNative 

func (f *File) IsNative() bool

func (*File) LoadContents 

func (f *File) LoadContents(cancellable *Cancellable, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool

func (*File) LoadContentsAsync 

func (f *File) LoadContentsAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) LoadContentsFinish 

func (f *File) LoadContentsFinish(res *AsyncResult, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool

func (*File) LoadPartialContentsAsync 

func (f *File) LoadPartialContentsAsync(cancellable *Cancellable, readMoreCallback FileReadMoreCallback, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) LoadPartialContentsFinish 

func (f *File) LoadPartialContentsFinish(res *AsyncResult, contents **T.Char, length *T.Gsize, etagOut **T.Char, err **L.Error) bool

func (*File) MakeDirectory 

func (f *File) MakeDirectory(cancellable *Cancellable, err **L.Error) bool

func (*File) MakeDirectoryWithParents 

func (f *File) MakeDirectoryWithParents(cancellable *Cancellable, err **L.Error) bool
func (f *File) MakeSymbolicLink(symlinkValue string, cancellable *Cancellable, err **L.Error) bool

func (*File) Monitor 

func (f *File) Monitor(flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor

func (*File) MonitorDirectory 

func (f *File) MonitorDirectory(flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor

func (*File) MonitorFile 

func (f *File) MonitorFile(flags FileMonitorFlags, cancellable *Cancellable, err **L.Error) *FileMonitor

func (*File) MountEnclosingVolume 

func (f *File) MountEnclosingVolume(flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) MountEnclosingVolumeFinish 

func (f *File) MountEnclosingVolumeFinish(result *AsyncResult, err **L.Error) bool

func (*File) MountMountable 

func (f *File) MountMountable(flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) MountMountableFinish 

func (f *File) MountMountableFinish(result *AsyncResult, err **L.Error) *File

func (*File) Move 

func (f *File) Move(destination *File, flags FileCopyFlags, cancellable *Cancellable, progressCallback FileProgressCallback, progressCallbackData T.Gpointer, err **L.Error) bool

func (*File) OpenReadwrite 

func (f *File) OpenReadwrite(cancellable *Cancellable, err **L.Error) *FileIOStream

func (*File) OpenReadwriteAsync 

func (f *File) OpenReadwriteAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) OpenReadwriteFinish 

func (f *File) OpenReadwriteFinish(res *AsyncResult, err **L.Error) *FileIOStream

func (*File) PollMountable 

func (f *File) PollMountable(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) PollMountableFinish 

func (f *File) PollMountableFinish(result *AsyncResult, err **L.Error) bool

func (*File) QueryDefaultHandler 

func (f *File) QueryDefaultHandler(cancellable *Cancellable, err **L.Error) *AppInfo

func (*File) QueryExists 

func (f *File) QueryExists(cancellable *Cancellable) bool

func (*File) QueryFileType 

func (f *File) QueryFileType(flags FileQueryInfoFlags, cancellable *Cancellable) FileType

func (*File) QueryFilesystemInfo 

func (f *File) QueryFilesystemInfo(attributes string, cancellable *Cancellable, err **L.Error) *FileInfo

func (*File) QueryFilesystemInfoAsync 

func (f *File) QueryFilesystemInfoAsync(attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) QueryFilesystemInfoFinish 

func (f *File) QueryFilesystemInfoFinish(res *AsyncResult, err **L.Error) *FileInfo

func (*File) QueryInfo 

func (f *File) QueryInfo(attributes string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) *FileInfo

func (*File) QueryInfoAsync 

func (f *File) QueryInfoAsync(attributes string, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) QueryInfoFinish 

func (f *File) QueryInfoFinish(res *AsyncResult, err **L.Error) *FileInfo

func (*File) QuerySettableAttributes 

func (f *File) QuerySettableAttributes(cancellable *Cancellable, err **L.Error) *FileAttributeInfoList

func (*File) QueryWritableNamespaces 

func (f *File) QueryWritableNamespaces(cancellable *Cancellable, err **L.Error) *FileAttributeInfoList

func (*File) Read 

func (f *File) Read(cancellable *Cancellable, err **L.Error) *FileInputStream

func (*File) ReadAsync 

func (f *File) ReadAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) ReadFinish 

func (f *File) ReadFinish(res *AsyncResult, err **L.Error) *FileInputStream

func (*File) Replace 

func (f *File) Replace(etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileOutputStream

func (*File) ReplaceAsync 

func (f *File) ReplaceAsync(etag string, makeBackup bool, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) ReplaceContents 

func (f *File) ReplaceContents(contents string, length T.Gsize, etag string, makeBackup bool, flags FileCreateFlags, newEtag **T.Char, cancellable *Cancellable, err **L.Error) bool

func (*File) ReplaceContentsAsync 

func (f *File) ReplaceContentsAsync(contents string, length T.Gsize, etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) ReplaceContentsFinish 

func (f *File) ReplaceContentsFinish(res *AsyncResult, newEtag **T.Char, err **L.Error) bool

func (*File) ReplaceFinish 

func (f *File) ReplaceFinish(res *AsyncResult, err **L.Error) *FileOutputStream

func (*File) ReplaceReadwrite 

func (f *File) ReplaceReadwrite(etag string, makeBackup bool, flags FileCreateFlags, cancellable *Cancellable, err **L.Error) *FileIOStream

func (*File) ReplaceReadwriteAsync 

func (f *File) ReplaceReadwriteAsync(etag string, makeBackup bool, flags FileCreateFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) ReplaceReadwriteFinish 

func (f *File) ReplaceReadwriteFinish(res *AsyncResult, err **L.Error) *FileIOStream

func (*File) ResolveRelativePath 

func (f *File) ResolveRelativePath(relativePath string) *File

func (*File) SetAttribute 

func (f *File) SetAttribute(attribute string, typ FileAttributeType, valueP T.Gpointer, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeByteString 

func (f *File) SetAttributeByteString(attribute, value string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeInt32 

func (f *File) SetAttributeInt32(attribute string, value T.GInt32, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeInt64 

func (f *File) SetAttributeInt64(attribute string, value int64, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeString 

func (f *File) SetAttributeString(attribute, value string, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeUint32 

func (f *File) SetAttributeUint32(attribute string, value T.GUint32, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributeUint64 

func (f *File) SetAttributeUint64(attribute string, value uint64, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetAttributesAsync 

func (f *File) SetAttributesAsync(info *FileInfo, flags FileQueryInfoFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) SetAttributesFinish 

func (f *File) SetAttributesFinish(result *AsyncResult, info **FileInfo, err **L.Error) bool

func (*File) SetAttributesFromInfo 

func (f *File) SetAttributesFromInfo(info *FileInfo, flags FileQueryInfoFlags, cancellable *Cancellable, err **L.Error) bool

func (*File) SetDisplayName 

func (f *File) SetDisplayName(displayName string, cancellable *Cancellable, err **L.Error) *File

func (*File) SetDisplayNameAsync 

func (f *File) SetDisplayNameAsync(displayName string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) SetDisplayNameFinish 

func (f *File) SetDisplayNameFinish(res *AsyncResult, err **L.Error) *File

func (*File) StartMountable 

func (f *File) StartMountable(flags DriveStartFlags, startOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) StartMountableFinish 

func (f *File) StartMountableFinish(result *AsyncResult, err **L.Error) bool

func (*File) StopMountable 

func (f *File) StopMountable(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) StopMountableFinish 

func (f *File) StopMountableFinish(result *AsyncResult, err **L.Error) bool

func (*File) SupportsThreadContexts 

func (f *File) SupportsThreadContexts() bool

func (*File) Trash 

func (f *File) Trash(cancellable *Cancellable, err **L.Error) bool

func (*File) UnmountMountable 

func (f *File) UnmountMountable(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) UnmountMountableFinish 

func (f *File) UnmountMountableFinish(result *AsyncResult, err **L.Error) bool

func (*File) UnmountMountableWithOperation 

func (f *File) UnmountMountableWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*File) UnmountMountableWithOperationFinish 

func (f *File) UnmountMountableWithOperationFinish(result *AsyncResult, err **L.Error) bool

type FileAttributeInfo 

type FileAttributeInfo struct {
	Name  *T.Char
	Type  FileAttributeType
	Flags FileAttributeInfoFlags
}

type FileAttributeInfoFlags 

type FileAttributeInfoFlags Enum
const (
	FILE_ATTRIBUTE_INFO_COPY_WITH_FILE FileAttributeInfoFlags = 1 << iota
	FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED
	FILE_ATTRIBUTE_INFO_NONE FileAttributeInfoFlags = 0
)

type FileAttributeInfoList 

type FileAttributeInfoList struct {
	Infos  *FileAttributeInfo
	NInfos int
}

func (*FileAttributeInfoList) Add 

func (f *FileAttributeInfoList) Add(name string, typ FileAttributeType, flags FileAttributeInfoFlags)

func (*FileAttributeInfoList) Dup 

func (f *FileAttributeInfoList) Dup() *FileAttributeInfoList

func (*FileAttributeInfoList) Lookup 

func (f *FileAttributeInfoList) Lookup(name string) *FileAttributeInfo

func (*FileAttributeInfoList) Ref 

func (f *FileAttributeInfoList) Ref() *FileAttributeInfoList

func (*FileAttributeInfoList) Unref 

func (f *FileAttributeInfoList) Unref()

type FileAttributeMatcher 

type FileAttributeMatcher struct{}

func (*FileAttributeMatcher) EnumerateNamespace 

func (f *FileAttributeMatcher) EnumerateNamespace(ns string) bool

func (*FileAttributeMatcher) EnumerateNext 

func (f *FileAttributeMatcher) EnumerateNext() string

func (*FileAttributeMatcher) Matches 

func (f *FileAttributeMatcher) Matches(attribute string) bool

func (*FileAttributeMatcher) MatchesOnly 

func (f *FileAttributeMatcher) MatchesOnly(attribute string) bool

func (*FileAttributeMatcher) Ref 

func (f *FileAttributeMatcher) Ref() *FileAttributeMatcher

func (*FileAttributeMatcher) Unref 

func (f *FileAttributeMatcher) Unref()

type FileAttributeStatus 

type FileAttributeStatus Enum
const (
	FILE_ATTRIBUTE_STATUS_UNSET FileAttributeStatus = iota
	FILE_ATTRIBUTE_STATUS_SET
	FILE_ATTRIBUTE_STATUS_ERROR_SETTING
)

type FileAttributeType 

type FileAttributeType Enum
const (
	FILE_ATTRIBUTE_TYPE_INVALID FileAttributeType = iota
	FILE_ATTRIBUTE_TYPE_STRING
	FILE_ATTRIBUTE_TYPE_BYTE_STRING
	FILE_ATTRIBUTE_TYPE_BOOLEAN
	FILE_ATTRIBUTE_TYPE_UINT32
	FILE_ATTRIBUTE_TYPE_INT32
	FILE_ATTRIBUTE_TYPE_UINT64
	FILE_ATTRIBUTE_TYPE_INT64
	FILE_ATTRIBUTE_TYPE_OBJECT
	FILE_ATTRIBUTE_TYPE_STRINGV
)

type FileCopyFlags 

type FileCopyFlags Enum
const (
	FILE_COPY_OVERWRITE FileCopyFlags = 1 << iota
	FILE_COPY_BACKUP
	FILE_COPY_NOFOLLOW_SYMLINKS
	FILE_COPY_ALL_METADATA
	FILE_COPY_NO_FALLBACK_FOR_MOVE
	FILE_COPY_TARGET_DEFAULT_PERMS
	FILE_COPY_NONE FileCopyFlags = 0
)

type FileCreateFlags 

type FileCreateFlags Enum
const (
	FILE_CREATE_PRIVATE FileCreateFlags = 1 << iota
	FILE_CREATE_REPLACE_DESTINATION
	FILE_CREATE_NONE FileCreateFlags = 0
)

type FileEnumerator 

type FileEnumerator struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*FileEnumerator) Close 

func (f *FileEnumerator) Close(cancellable *Cancellable, err **L.Error) bool

func (*FileEnumerator) CloseAsync 

func (f *FileEnumerator) CloseAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*FileEnumerator) CloseFinish 

func (f *FileEnumerator) CloseFinish(result *AsyncResult, err **L.Error) bool

func (*FileEnumerator) GetContainer 

func (f *FileEnumerator) GetContainer() *File

func (*FileEnumerator) HasPending 

func (f *FileEnumerator) HasPending() bool

func (*FileEnumerator) IsClosed 

func (f *FileEnumerator) IsClosed() bool

func (*FileEnumerator) NextFile 

func (f *FileEnumerator) NextFile(cancellable *Cancellable, err **L.Error) *FileInfo

func (*FileEnumerator) NextFilesAsync 

func (f *FileEnumerator) NextFilesAsync(numFiles, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*FileEnumerator) NextFilesFinish 

func (f *FileEnumerator) NextFilesFinish(result *AsyncResult, err **L.Error) *L.List

func (*FileEnumerator) SetPending 

func (f *FileEnumerator) SetPending(pending bool)

type FileIOStream 

type FileIOStream struct {
	Parent IOStream
	// contains filtered or unexported fields
}

func (*FileIOStream) GetEtag 

func (f *FileIOStream) GetEtag() string

func (*FileIOStream) QueryInfo 

func (f *FileIOStream) QueryInfo(attributes string, cancellable *Cancellable, err **L.Error) *FileInfo

func (*FileIOStream) QueryInfoAsync 

func (f *FileIOStream) QueryInfoAsync(attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*FileIOStream) QueryInfoFinish 

func (f *FileIOStream) QueryInfoFinish(result *AsyncResult, err **L.Error) *FileInfo

type FileIcon 

type FileIcon struct{}

func (*FileIcon) GetFile 

func (f *FileIcon) GetFile() *File

type FileInfo 

type FileInfo struct{}

func (*FileInfo) ClearStatus 

func (f *FileInfo) ClearStatus()

func (*FileInfo) GetAttributeAsString 

func (f *FileInfo) GetAttributeAsString(attribute string) string

func (*FileInfo) GetAttributeBoolean 

func (f *FileInfo) GetAttributeBoolean(attribute string) bool

func (*FileInfo) GetAttributeByteString 

func (f *FileInfo) GetAttributeByteString(attribute string) string

func (*FileInfo) GetAttributeData 

func (f *FileInfo) GetAttributeData(attribute string, typ *FileAttributeType, valuePp *T.Gpointer, status *FileAttributeStatus) bool

func (*FileInfo) GetAttributeInt32 

func (f *FileInfo) GetAttributeInt32(attribute string) T.GInt32

func (*FileInfo) GetAttributeInt64 

func (f *FileInfo) GetAttributeInt64(attribute string) int64

func (*FileInfo) GetAttributeObject 

func (f *FileInfo) GetAttributeObject(attribute string) *O.Object

func (*FileInfo) GetAttributeStatus 

func (f *FileInfo) GetAttributeStatus(attribute string) FileAttributeStatus

func (*FileInfo) GetAttributeString 

func (f *FileInfo) GetAttributeString(attribute string) string

func (*FileInfo) GetAttributeStringv 

func (f *FileInfo) GetAttributeStringv(attribute string) []string

func (*FileInfo) GetAttributeType 

func (f *FileInfo) GetAttributeType(attribute string) FileAttributeType

func (*FileInfo) GetAttributeUint32 

func (f *FileInfo) GetAttributeUint32(attribute string) T.GUint32

func (*FileInfo) GetAttributeUint64 

func (f *FileInfo) GetAttributeUint64(attribute string) uint64

func (*FileInfo) GetContentType 

func (f *FileInfo) GetContentType() string

func (*FileInfo) GetDisplayName 

func (f *FileInfo) GetDisplayName() string

func (*FileInfo) GetEditName 

func (f *FileInfo) GetEditName() string

func (*FileInfo) GetEtag 

func (f *FileInfo) GetEtag() string

func (*FileInfo) GetFileType 

func (f *FileInfo) GetFileType() FileType

func (*FileInfo) GetIcon 

func (f *FileInfo) GetIcon() *Icon

func (*FileInfo) GetIsBackup 

func (f *FileInfo) GetIsBackup() bool

func (*FileInfo) GetIsHidden 

func (f *FileInfo) GetIsHidden() bool
func (f *FileInfo) GetIsSymlink() bool

func (*FileInfo) GetModificationTime 

func (f *FileInfo) GetModificationTime(result *L.TimeVal)

func (*FileInfo) GetName 

func (f *FileInfo) GetName() string

func (*FileInfo) GetSize 

func (f *FileInfo) GetSize() T.Goffset

func (*FileInfo) GetSortOrder 

func (f *FileInfo) GetSortOrder() T.GInt32

func (*FileInfo) GetSymlinkTarget 

func (f *FileInfo) GetSymlinkTarget() string

func (*FileInfo) HasAttribute 

func (f *FileInfo) HasAttribute(attribute string) bool

func (*FileInfo) HasNamespace 

func (f *FileInfo) HasNamespace(nameSpace string) bool

func (*FileInfo) ListAttributes 

func (f *FileInfo) ListAttributes(nameSpace string) []string

func (*FileInfo) RemoveAttribute 

func (f *FileInfo) RemoveAttribute(attribute string)

func (*FileInfo) SetAttribute 

func (f *FileInfo) SetAttribute(attribute string, typ FileAttributeType, valueP T.Gpointer)

func (*FileInfo) SetAttributeBoolean 

func (f *FileInfo) SetAttributeBoolean(attribute string, attrValue bool)

func (*FileInfo) SetAttributeByteString 

func (f *FileInfo) SetAttributeByteString(attribute, attrValue string)

func (*FileInfo) SetAttributeInt32 

func (f *FileInfo) SetAttributeInt32(attribute string, attrValue T.GInt32)

func (*FileInfo) SetAttributeInt64 

func (f *FileInfo) SetAttributeInt64(attribute string, attrValue int64)

func (*FileInfo) SetAttributeMask 

func (f *FileInfo) SetAttributeMask(mask *FileAttributeMatcher)

func (*FileInfo) SetAttributeObject 

func (f *FileInfo) SetAttributeObject(attribute string, attrValue *O.Object)

func (*FileInfo) SetAttributeStatus 

func (f *FileInfo) SetAttributeStatus(attribute string, status FileAttributeStatus) bool

func (*FileInfo) SetAttributeString 

func (f *FileInfo) SetAttributeString(attribute, attrValue string)

func (*FileInfo) SetAttributeStringv 

func (f *FileInfo) SetAttributeStringv(attribute string, attrValue **T.Char)

func (*FileInfo) SetAttributeUint32 

func (f *FileInfo) SetAttributeUint32(attribute string, attrValue T.GUint32)

func (*FileInfo) SetAttributeUint64 

func (f *FileInfo) SetAttributeUint64(attribute string, attrValue uint64)

func (*FileInfo) SetContentType 

func (f *FileInfo) SetContentType(contentType string)

func (*FileInfo) SetDisplayName 

func (f *FileInfo) SetDisplayName(displayName string)

func (*FileInfo) SetEditName 

func (f *FileInfo) SetEditName(editName string)

func (*FileInfo) SetFileType 

func (f *FileInfo) SetFileType(typ FileType)

func (*FileInfo) SetIcon 

func (f *FileInfo) SetIcon(icon *Icon)

func (*FileInfo) SetIsHidden 

func (f *FileInfo) SetIsHidden(isHidden bool)
func (f *FileInfo) SetIsSymlink(isSymlink bool)

func (*FileInfo) SetModificationTime 

func (f *FileInfo) SetModificationTime(mtime *L.TimeVal)

func (*FileInfo) SetName 

func (f *FileInfo) SetName(name string)

func (*FileInfo) SetSize 

func (f *FileInfo) SetSize(size T.Goffset)

func (*FileInfo) SetSortOrder 

func (f *FileInfo) SetSortOrder(sortOrder T.GInt32)

func (*FileInfo) SetSymlinkTarget 

func (f *FileInfo) SetSymlinkTarget(symlinkTarget string)

func (*FileInfo) UnsetAttributeMask 

func (f *FileInfo) UnsetAttributeMask()

type FileInputStream 

type FileInputStream struct {
	Parent InputStream
	// contains filtered or unexported fields
}

func (*FileInputStream) QueryInfo 

func (f *FileInputStream) QueryInfo(attributes string, cancellable *Cancellable, err **L.Error) *FileInfo

func (*FileInputStream) QueryInfoAsync 

func (f *FileInputStream) QueryInfoAsync(attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*FileInputStream) QueryInfoFinish 

func (f *FileInputStream) QueryInfoFinish(result *AsyncResult, err **L.Error) *FileInfo

type FileMonitor 

type FileMonitor struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*FileMonitor) Cancel 

func (f *FileMonitor) Cancel() bool

func (*FileMonitor) EmitEvent 

func (f *FileMonitor) EmitEvent(child, otherFile *File, eventType FileMonitorEvent)

func (*FileMonitor) IsCancelled 

func (f *FileMonitor) IsCancelled() bool

func (*FileMonitor) SetRateLimit 

func (f *FileMonitor) SetRateLimit(limitMsecs int)

type FileMonitorEvent 

type FileMonitorEvent Enum
const (
	FILE_MONITOR_EVENT_CHANGED FileMonitorEvent = iota
	FILE_MONITOR_EVENT_CHANGES_DONE_HINT
	FILE_MONITOR_EVENT_DELETED
	FILE_MONITOR_EVENT_CREATED
	FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED
	FILE_MONITOR_EVENT_PRE_UNMOUNT
	FILE_MONITOR_EVENT_UNMOUNTED
	FILE_MONITOR_EVENT_MOVED
)

type FileMonitorFlags 

type FileMonitorFlags Enum
const (
	FILE_MONITOR_WATCH_MOUNTS FileMonitorFlags = 1 << iota
	FILE_MONITOR_SEND_MOVED
	FILE_MONITOR_NONE FileMonitorFlags = 0
)

type FileOutputStream 

type FileOutputStream struct {
	Parent OutputStream
	// contains filtered or unexported fields
}

func (*FileOutputStream) GetEtag 

func (f *FileOutputStream) GetEtag() string

func (*FileOutputStream) QueryInfo 

func (f *FileOutputStream) QueryInfo(attributes string, cancellable *Cancellable, err **L.Error) *FileInfo

func (*FileOutputStream) QueryInfoAsync 

func (f *FileOutputStream) QueryInfoAsync(attributes string, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*FileOutputStream) QueryInfoFinish 

func (f *FileOutputStream) QueryInfoFinish(result *AsyncResult, err **L.Error) *FileInfo

type FileProgressCallback 

type FileProgressCallback func(
	currentNumBytes, totalNumBytes T.Goffset, userData T.Gpointer)

type FileQueryInfoFlags 

type FileQueryInfoFlags Enum
const (
	FILE_QUERY_INFO_NOFOLLOW_SYMLINKS FileQueryInfoFlags = 1 << iota
	FILE_QUERY_INFO_NONE              FileQueryInfoFlags = 0
)

type FileReadMoreCallback 

type FileReadMoreCallback func(fileContents string,
	FileSize T.Goffset, callbackData T.Gpointer) bool

type FileType 

type FileType Enum
const (
	FILE_TYPE_UNKNOWN FileType = iota
	FILE_TYPE_REGULAR
	FILE_TYPE_DIRECTORY
	FILE_TYPE_SYMBOLIC_LINK
	FILE_TYPE_SPECIAL
	FILE_TYPE_SHORTCUT
	FILE_TYPE_MOUNTABLE
)

type FilenameCompleter 

type FilenameCompleter struct{}

func (*FilenameCompleter) GetCompletionSuffix 

func (f *FilenameCompleter) GetCompletionSuffix(initialText string) string

func (*FilenameCompleter) GetCompletions 

func (f *FilenameCompleter) GetCompletions(initialText string) []string

func (*FilenameCompleter) SetDirsOnly 

func (f *FilenameCompleter) SetDirsOnly(dirsOnly bool)

type FilterInputStream 

type FilterInputStream struct {
	Parent     InputStream
	BaseStream *InputStream
}

func (*FilterInputStream) GetBaseStream 

func (f *FilterInputStream) GetBaseStream() *InputStream

func (*FilterInputStream) GetCloseBaseStream 

func (f *FilterInputStream) GetCloseBaseStream() bool

func (*FilterInputStream) SetCloseBaseStream 

func (f *FilterInputStream) SetCloseBaseStream(closeBase bool)

type FilterOutputStream 

type FilterOutputStream struct {
	Parent     OutputStream
	BaseStream *OutputStream
}

func (*FilterOutputStream) GetBaseStream 

func (f *FilterOutputStream) GetBaseStream() *OutputStream

func (*FilterOutputStream) GetCloseBaseStream 

func (f *FilterOutputStream) GetCloseBaseStream() bool

func (*FilterOutputStream) SetCloseBaseStream 

func (f *FilterOutputStream) SetCloseBaseStream(closeBase bool)

type IOErrorEnum 

type IOErrorEnum Enum
const (
	IO_ERROR_FAILED IOErrorEnum = iota
	IO_ERROR_NOT_FOUND
	IO_ERROR_EXISTS
	IO_ERROR_IS_DIRECTORY
	IO_ERROR_NOT_DIRECTORY
	IO_ERROR_NOT_EMPTY
	IO_ERROR_NOT_REGULAR_FILE
	IO_ERROR_NOT_SYMBOLIC_LINK
	IO_ERROR_NOT_MOUNTABLE_FILE
	IO_ERROR_FILENAME_TOO_LONG
	IO_ERROR_INVALID_FILENAME
	IO_ERROR_TOO_MANY_LINKS
	IO_ERROR_NO_SPACE
	IO_ERROR_INVALID_ARGUMENT
	IO_ERROR_PERMISSION_DENIED
	IO_ERROR_NOT_SUPPORTED
	IO_ERROR_NOT_MOUNTED
	IO_ERROR_ALREADY_MOUNTED
	IO_ERROR_CLOSED
	IO_ERROR_CANCELLED
	IO_ERROR_PENDING
	IO_ERROR_READ_ONLY
	IO_ERROR_CANT_CREATE_BACKUP
	IO_ERROR_WRONG_ETAG
	IO_ERROR_TIMED_OUT
	IO_ERROR_WOULD_RECURSE
	IO_ERROR_BUSY
	IO_ERROR_WOULD_BLOCK
	IO_ERROR_HOST_NOT_FOUND
	IO_ERROR_WOULD_MERGE
	IO_ERROR_FAILED_HANDLED
	IO_ERROR_TOO_MANY_OPEN_FILES
	IO_ERROR_NOT_INITIALIZED
	IO_ERROR_ADDRESS_IN_USE
	IO_ERROR_PARTIAL_INPUT
	IO_ERROR_INVALID_DATA
	IO_ERROR_DBUS_ERROR
	IO_ERROR_HOST_UNREACHABLE
	IO_ERROR_NETWORK_UNREACHABLE
	IO_ERROR_CONNECTION_REFUSED
	IO_ERROR_PROXY_FAILED
	IO_ERROR_PROXY_AUTH_FAILED
	IO_ERROR_PROXY_NEED_AUTH
	IO_ERROR_PROXY_NOT_ALLOWED
)

type IOExtension 

type IOExtension struct{}

func (*IOExtension) GetName 

func (i *IOExtension) GetName() string

func (*IOExtension) GetPriority 

func (i *IOExtension) GetPriority() int

func (*IOExtension) GetType 

func (i *IOExtension) GetType() O.Type

func (*IOExtension) RefClass 

func (i *IOExtension) RefClass() *O.TypeClass

type IOExtensionPoint 

type IOExtensionPoint struct{}

func (*IOExtensionPoint) GetExtensionByName 

func (i *IOExtensionPoint) GetExtensionByName(name string) *IOExtension

func (*IOExtensionPoint) GetExtensions 

func (i *IOExtensionPoint) GetExtensions() *L.List

func (*IOExtensionPoint) GetRequiredType 

func (i *IOExtensionPoint) GetRequiredType() O.Type

func (*IOExtensionPoint) SetRequiredType 

func (i *IOExtensionPoint) SetRequiredType(typ O.Type)

type IOModule 

type IOModule struct{}

func (*IOModule) Load 

func (i *IOModule) Load()

func (*IOModule) Unload 

func (i *IOModule) Unload()

type IOSchedulerJob 

type IOSchedulerJob struct{}

func (*IOSchedulerJob) SendToMainloop 

func (i *IOSchedulerJob) SendToMainloop(f O.SourceFunc, userData T.Gpointer, notify O.DestroyNotify) bool

func (*IOSchedulerJob) SendToMainloopAsync 

func (i *IOSchedulerJob) SendToMainloopAsync(f O.SourceFunc, userData T.Gpointer, notify O.DestroyNotify)

type IOSchedulerJobFunc 

type IOSchedulerJobFunc func(
	job *IOSchedulerJob,
	cancellable *Cancellable,
	userData T.Gpointer) bool

type IOStream 

type IOStream struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*IOStream) ClearPending 

func (i *IOStream) ClearPending()

func (*IOStream) Close 

func (i *IOStream) Close(cancellable *Cancellable, err **L.Error) bool

func (*IOStream) CloseAsync 

func (i *IOStream) CloseAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*IOStream) CloseFinish 

func (i *IOStream) CloseFinish(result *AsyncResult, err **L.Error) bool

func (*IOStream) GetInputStream 

func (i *IOStream) GetInputStream() *InputStream

func (*IOStream) GetOutputStream 

func (i *IOStream) GetOutputStream() *OutputStream

func (*IOStream) HasPending 

func (i *IOStream) HasPending() bool

func (*IOStream) IsClosed 

func (i *IOStream) IsClosed() bool

func (*IOStream) SetPending 

func (i *IOStream) SetPending(err **L.Error) bool

func (*IOStream) SpliceAsync 

func (i *IOStream) SpliceAsync(stream2 *IOStream, flags IOStreamSpliceFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

type IOStreamSpliceFlags 

type IOStreamSpliceFlags Enum
const (
	IO_STREAM_SPLICE_CLOSE_STREAM1 IOStreamSpliceFlags = 1 << iota
	IO_STREAM_SPLICE_CLOSE_STREAM2
	IO_STREAM_SPLICE_WAIT_FOR_BOTH
	IO_STREAM_SPLICE_NONE IOStreamSpliceFlags = 0
)

type Icon 

type Icon struct{}

type InetAddress 

type InetAddress struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*InetAddress) GetFamily 

func (i *InetAddress) GetFamily() SocketFamily

func (*InetAddress) GetIsAny 

func (i *InetAddress) GetIsAny() bool

func (*InetAddress) GetIsLinkLocal 

func (i *InetAddress) GetIsLinkLocal() bool

func (*InetAddress) GetIsLoopback 

func (i *InetAddress) GetIsLoopback() bool

func (*InetAddress) GetIsMcGlobal 

func (i *InetAddress) GetIsMcGlobal() bool

func (*InetAddress) GetIsMcLinkLocal 

func (i *InetAddress) GetIsMcLinkLocal() bool

func (*InetAddress) GetIsMcNodeLocal 

func (i *InetAddress) GetIsMcNodeLocal() bool

func (*InetAddress) GetIsMcOrgLocal 

func (i *InetAddress) GetIsMcOrgLocal() bool

func (*InetAddress) GetIsMcSiteLocal 

func (i *InetAddress) GetIsMcSiteLocal() bool

func (*InetAddress) GetIsMulticast 

func (i *InetAddress) GetIsMulticast() bool

func (*InetAddress) GetIsSiteLocal 

func (i *InetAddress) GetIsSiteLocal() bool

func (*InetAddress) GetNativeSize 

func (i *InetAddress) GetNativeSize() T.Gsize

func (*InetAddress) ToBytes 

func (i *InetAddress) ToBytes() *uint8

func (*InetAddress) ToString 

func (i *InetAddress) ToString() string

type InetSocketAddress 

type InetSocketAddress struct {
	Parent SocketAddress
	// contains filtered or unexported fields
}

func (*InetSocketAddress) GetAddress 

func (i *InetSocketAddress) GetAddress() *InetAddress

func (*InetSocketAddress) GetPort 

func (i *InetSocketAddress) GetPort() uint16

type Initable 

type Initable struct{}

func (*Initable) Init 

func (i *Initable) Init(cancellable *Cancellable, err **L.Error) bool

type InputStream 

type InputStream struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*InputStream) ClearPending 

func (i *InputStream) ClearPending()

func (*InputStream) Close 

func (i *InputStream) Close(cancellable *Cancellable, err **L.Error) bool

func (*InputStream) CloseAsync 

func (i *InputStream) CloseAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*InputStream) CloseFinish 

func (i *InputStream) CloseFinish(result *AsyncResult, err **L.Error) bool

func (*InputStream) HasPending 

func (i *InputStream) HasPending() bool

func (*InputStream) IsClosed 

func (i *InputStream) IsClosed() bool

func (*InputStream) Read 

func (i *InputStream) Read(buffer *T.Void, count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*InputStream) ReadAll 

func (i *InputStream) ReadAll(buffer *T.Void, count T.Gsize, bytesRead *T.Gsize, cancellable *Cancellable, err **L.Error) bool

func (*InputStream) ReadAsync 

func (i *InputStream) ReadAsync(buffer *T.Void, count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*InputStream) ReadFinish 

func (i *InputStream) ReadFinish(result *AsyncResult, err **L.Error) T.Gssize

func (*InputStream) SetPending 

func (i *InputStream) SetPending(err **L.Error) bool

func (*InputStream) Skip 

func (i *InputStream) Skip(count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*InputStream) SkipAsync 

func (i *InputStream) SkipAsync(count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*InputStream) SkipFinish 

func (i *InputStream) SkipFinish(result *AsyncResult, err **L.Error) T.Gssize

type InputVector 

type InputVector struct {
	Buffer T.Gpointer
	Size   T.Gsize
}

type LoadableIcon 

type LoadableIcon struct{}

func (*LoadableIcon) Load 

func (l *LoadableIcon) Load(size int, t **T.Char, cancellable *Cancellable, err **L.Error) *InputStream

func (*LoadableIcon) LoadAsync 

func (l *LoadableIcon) LoadAsync(size int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*LoadableIcon) LoadFinish 

func (l *LoadableIcon) LoadFinish(res *AsyncResult, typ **T.Char, err **L.Error) *InputStream

type MemoryInputStream 

type MemoryInputStream struct {
	Parent InputStream
	// contains filtered or unexported fields
}

func (*MemoryInputStream) AddData 

func (m *MemoryInputStream) AddData(data *T.Void, len T.Gssize, destroy O.DestroyNotify)

type MemoryOutputStream 

type MemoryOutputStream struct {
	Parent OutputStream
	Priv   *struct{}
}

func (*MemoryOutputStream) GetData 

func (m *MemoryOutputStream) GetData() T.Gpointer

func (*MemoryOutputStream) GetDataSize 

func (m *MemoryOutputStream) GetDataSize() T.Gsize

func (*MemoryOutputStream) GetSize 

func (m *MemoryOutputStream) GetSize() T.Gsize

func (*MemoryOutputStream) StealData 

func (m *MemoryOutputStream) StealData() T.Gpointer

type Mount 

type Mount struct{}

func (*Mount) CanEject 

func (m *Mount) CanEject() bool

func (*Mount) CanUnmount 

func (m *Mount) CanUnmount() bool

func (*Mount) Eject 

func (m *Mount) Eject(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) EjectFinish 

func (m *Mount) EjectFinish(result *AsyncResult, err **L.Error) bool

func (*Mount) EjectWithOperation 

func (m *Mount) EjectWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) EjectWithOperationFinish 

func (m *Mount) EjectWithOperationFinish(result *AsyncResult, err **L.Error) bool

func (*Mount) GetDefaultLocation 

func (m *Mount) GetDefaultLocation() *File

func (*Mount) GetDrive 

func (m *Mount) GetDrive() *Drive

func (*Mount) GetIcon 

func (m *Mount) GetIcon() *Icon

func (*Mount) GetName 

func (m *Mount) GetName() string

func (*Mount) GetRoot 

func (m *Mount) GetRoot() *File

func (*Mount) GetUuid 

func (m *Mount) GetUuid() string

func (*Mount) GetVolume 

func (m *Mount) GetVolume() *Volume

func (*Mount) GuessContentType 

func (m *Mount) GuessContentType(forceRescan bool, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) GuessContentTypeFinish 

func (m *Mount) GuessContentTypeFinish(result *AsyncResult, err **L.Error) []string

func (*Mount) GuessContentTypeSync 

func (m *Mount) GuessContentTypeSync(forceRescan bool, cancellable *Cancellable, err **L.Error) []string

func (*Mount) IsShadowed 

func (m *Mount) IsShadowed() bool

func (*Mount) Remount 

func (m *Mount) Remount(flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) RemountFinish 

func (m *Mount) RemountFinish(result *AsyncResult, err **L.Error) bool

func (*Mount) Shadow 

func (m *Mount) Shadow()

func (*Mount) Unmount 

func (m *Mount) Unmount(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) UnmountFinish 

func (m *Mount) UnmountFinish(result *AsyncResult, err **L.Error) bool

func (*Mount) UnmountWithOperation 

func (m *Mount) UnmountWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Mount) UnmountWithOperationFinish 

func (m *Mount) UnmountWithOperationFinish(result *AsyncResult, err **L.Error) bool

func (*Mount) Unshadow 

func (m *Mount) Unshadow()

type MountMountFlags 

type MountMountFlags Enum
const MOUNT_MOUNT_NONE MountMountFlags = 0

type MountOperation 

type MountOperation struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*MountOperation) GetAnonymous 

func (m *MountOperation) GetAnonymous() bool

func (*MountOperation) GetChoice 

func (m *MountOperation) GetChoice() int

func (*MountOperation) GetDomain 

func (m *MountOperation) GetDomain() string

func (*MountOperation) GetPassword 

func (m *MountOperation) GetPassword() string

func (*MountOperation) GetPasswordSave 

func (m *MountOperation) GetPasswordSave() T.GPasswordSave

func (*MountOperation) GetUsername 

func (m *MountOperation) GetUsername() string

func (*MountOperation) Reply 

func (m *MountOperation) Reply(result MountOperationResult)

func (*MountOperation) SetAnonymous 

func (m *MountOperation) SetAnonymous(anonymous bool)

func (*MountOperation) SetChoice 

func (m *MountOperation) SetChoice(choice int)

func (*MountOperation) SetDomain 

func (m *MountOperation) SetDomain(domain string)

func (*MountOperation) SetPassword 

func (m *MountOperation) SetPassword(password string)

func (*MountOperation) SetPasswordSave 

func (m *MountOperation) SetPasswordSave(save T.GPasswordSave)

func (*MountOperation) SetUsername 

func (m *MountOperation) SetUsername(username string)

type MountOperationResult 

type MountOperationResult Enum
const (
	MOUNT_OPERATION_HANDLED MountOperationResult = iota
	MOUNT_OPERATION_ABORTED
	MOUNT_OPERATION_UNHANDLED
)

type MountUnmountFlags 

type MountUnmountFlags Enum
const (
	MOUNT_UNMOUNT_FORCE MountUnmountFlags = 1 << iota
	MOUNT_UNMOUNT_NONE  MountUnmountFlags = 0
)

type NetworkAddress 

type NetworkAddress struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*NetworkAddress) GetHostname 

func (n *NetworkAddress) GetHostname() string

func (*NetworkAddress) GetPort 

func (n *NetworkAddress) GetPort() uint16

func (*NetworkAddress) GetScheme 

func (n *NetworkAddress) GetScheme() string

type NetworkService 

type NetworkService struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*NetworkService) GetDomain 

func (n *NetworkService) GetDomain() string

func (*NetworkService) GetProtocol 

func (n *NetworkService) GetProtocol() string

func (*NetworkService) GetScheme 

func (n *NetworkService) GetScheme() string

func (*NetworkService) GetService 

func (n *NetworkService) GetService() string

func (*NetworkService) SetScheme 

func (n *NetworkService) SetScheme(scheme string)

type OutputStream 

type OutputStream struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*OutputStream) ClearPending 

func (o *OutputStream) ClearPending()

func (*OutputStream) Close 

func (o *OutputStream) Close(cancellable *Cancellable, err **L.Error) bool

func (*OutputStream) CloseAsync 

func (o *OutputStream) CloseAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*OutputStream) CloseFinish 

func (o *OutputStream) CloseFinish(result *AsyncResult, err **L.Error) bool

func (*OutputStream) Flush 

func (o *OutputStream) Flush(cancellable *Cancellable, err **L.Error) bool

func (*OutputStream) FlushAsync 

func (o *OutputStream) FlushAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*OutputStream) FlushFinish 

func (o *OutputStream) FlushFinish(result *AsyncResult, err **L.Error) bool

func (*OutputStream) HasPending 

func (o *OutputStream) HasPending() bool

func (*OutputStream) IsClosed 

func (o *OutputStream) IsClosed() bool

func (*OutputStream) IsClosing 

func (o *OutputStream) IsClosing() bool

func (*OutputStream) SetPending 

func (o *OutputStream) SetPending(err **L.Error) bool

func (*OutputStream) Splice 

func (o *OutputStream) Splice(source *InputStream, flags OutputStreamSpliceFlags, cancellable *Cancellable, err **L.Error) T.Gssize

func (*OutputStream) SpliceAsync 

func (o *OutputStream) SpliceAsync(source *InputStream, flags OutputStreamSpliceFlags, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*OutputStream) SpliceFinish 

func (o *OutputStream) SpliceFinish(result *AsyncResult, err **L.Error) T.Gssize

func (*OutputStream) Write 

func (o *OutputStream) Write(buffer *T.Void, count T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*OutputStream) WriteAll 

func (o *OutputStream) WriteAll(buffer *T.Void, count T.Gsize, bytesWritten *T.Gsize, cancellable *Cancellable, err **L.Error) bool

func (*OutputStream) WriteAsync 

func (o *OutputStream) WriteAsync(buffer *T.Void, count T.Gsize, ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*OutputStream) WriteFinish 

func (o *OutputStream) WriteFinish(result *AsyncResult, err **L.Error) T.Gssize

type OutputStreamSpliceFlags 

type OutputStreamSpliceFlags Enum
const (
	OUTPUT_STREAM_SPLICE_CLOSE_SOURCE OutputStreamSpliceFlags = 1 << iota
	OUTPUT_STREAM_SPLICE_CLOSE_TARGET
	OUTPUT_STREAM_SPLICE_NONE OutputStreamSpliceFlags = 0
)

type Permission 

type Permission struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Permission) Acquire 

func (p *Permission) Acquire(cancellable *Cancellable, err **L.Error) bool

func (*Permission) AcquireAsync 

func (p *Permission) AcquireAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Permission) AcquireFinish 

func (p *Permission) AcquireFinish(result *AsyncResult, err **L.Error) bool

func (*Permission) GetAllowed 

func (p *Permission) GetAllowed() bool

func (*Permission) GetCanAcquire 

func (p *Permission) GetCanAcquire() bool

func (*Permission) GetCanRelease 

func (p *Permission) GetCanRelease() bool

func (*Permission) ImplUpdate 

func (p *Permission) ImplUpdate(allowed bool, canAcquire bool, canRelease bool)

func (*Permission) Release 

func (p *Permission) Release(cancellable *Cancellable, err **L.Error) bool

func (*Permission) ReleaseAsync 

func (p *Permission) ReleaseAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Permission) ReleaseFinish 

func (p *Permission) ReleaseFinish(result *AsyncResult, err **L.Error) bool

type PollableInputStream 

type PollableInputStream struct{}

func (*PollableInputStream) CanPoll 

func (p *PollableInputStream) CanPoll() bool

func (*PollableInputStream) CreateSource 

func (p *PollableInputStream) CreateSource(cancellable *Cancellable) *L.Source

func (*PollableInputStream) IsReadable 

func (p *PollableInputStream) IsReadable() bool

func (*PollableInputStream) ReadNonblocking 

func (p *PollableInputStream) ReadNonblocking(buffer *T.Void, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

type PollableOutputStream 

type PollableOutputStream struct{}

func (*PollableOutputStream) CanPoll 

func (p *PollableOutputStream) CanPoll() bool

func (*PollableOutputStream) CreateSource 

func (p *PollableOutputStream) CreateSource(cancellable *Cancellable) *L.Source

func (*PollableOutputStream) IsWritable 

func (p *PollableOutputStream) IsWritable() bool

func (*PollableOutputStream) WriteNonblocking 

func (p *PollableOutputStream) WriteNonblocking(buffer *T.Void, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

type Proxy 

type Proxy struct{}

func (*Proxy) Connect 

func (p *Proxy) Connect(connection *IOStream, proxyAddress *ProxyAddress, cancellable *Cancellable, err **L.Error) *IOStream

func (*Proxy) ConnectAsync 

func (p *Proxy) ConnectAsync(connection *IOStream, proxyAddress *ProxyAddress, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Proxy) ConnectFinish 

func (p *Proxy) ConnectFinish(result *AsyncResult, err **L.Error) *IOStream

func (*Proxy) SupportsHostname 

func (p *Proxy) SupportsHostname() bool

type ProxyAddress 

type ProxyAddress struct {
	Parent InetSocketAddress
	// contains filtered or unexported fields
}

func (*ProxyAddress) GetDestinationHostname 

func (p *ProxyAddress) GetDestinationHostname() string

func (*ProxyAddress) GetDestinationPort 

func (p *ProxyAddress) GetDestinationPort() uint16

func (*ProxyAddress) GetPassword 

func (p *ProxyAddress) GetPassword() string

func (*ProxyAddress) GetProtocol 

func (p *ProxyAddress) GetProtocol() string

func (*ProxyAddress) GetUsername 

func (p *ProxyAddress) GetUsername() string

type ProxyResolver 

type ProxyResolver struct{}

func (*ProxyResolver) IsSupported 

func (p *ProxyResolver) IsSupported() bool

func (*ProxyResolver) Lookup 

func (p *ProxyResolver) Lookup(uri string, cancellable *Cancellable, err **L.Error) []string

func (*ProxyResolver) LookupAsync 

func (p *ProxyResolver) LookupAsync(uri string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*ProxyResolver) LookupFinish 

func (p *ProxyResolver) LookupFinish(result *AsyncResult, err **L.Error) []string

type ReallocFunc 

type ReallocFunc func(data T.Gpointer, size T.Gsize) T.Gpointer

type Resolver 

type Resolver struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Resolver) LookupByAddress 

func (r *Resolver) LookupByAddress(address *InetAddress, cancellable *Cancellable, err **L.Error) string

func (*Resolver) LookupByAddressAsync 

func (r *Resolver) LookupByAddressAsync(address *InetAddress, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Resolver) LookupByAddressFinish 

func (r *Resolver) LookupByAddressFinish(result *AsyncResult, err **L.Error) string

func (*Resolver) LookupByName 

func (r *Resolver) LookupByName(hostname string, cancellable *Cancellable, err **L.Error) *L.List

func (*Resolver) LookupByNameAsync 

func (r *Resolver) LookupByNameAsync(hostname string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Resolver) LookupByNameFinish 

func (r *Resolver) LookupByNameFinish(result *AsyncResult, err **L.Error) *L.List

func (*Resolver) LookupService 

func (r *Resolver) LookupService(service, protocol, domain string, cancellable *Cancellable, err **L.Error) *L.List

func (*Resolver) LookupServiceAsync 

func (r *Resolver) LookupServiceAsync(service, protocol, domain string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Resolver) LookupServiceFinish 

func (r *Resolver) LookupServiceFinish(result *AsyncResult, err **L.Error) *L.List

func (*Resolver) SetDefault 

func (r *Resolver) SetDefault()

type Seekable 

type Seekable struct{}

func (*Seekable) CanSeek 

func (s *Seekable) CanSeek() bool

func (*Seekable) CanTruncate 

func (s *Seekable) CanTruncate() bool

func (*Seekable) Seek 

func (s *Seekable) Seek(offset T.Goffset, typ L.SeekType, cancellable *Cancellable, err **L.Error) bool

func (*Seekable) Tell 

func (s *Seekable) Tell() T.Goffset

func (*Seekable) Truncate 

func (s *Seekable) Truncate(offset T.Goffset, cancellable *Cancellable, err **L.Error) bool

type Settings 

type Settings struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Settings) Apply 

func (s *Settings) Apply()

func (*Settings) Bind 

func (s *Settings) Bind(key string, object T.Gpointer, property string, flags SettingsBindFlags)

func (*Settings) BindWithMapping 

func (s *Settings) BindWithMapping(key string, object T.Gpointer, property string, flags SettingsBindFlags, getMapping SettingsBindGetMapping, setMapping SettingsBindSetMapping, userData T.Gpointer, destroy O.DestroyNotify)

func (*Settings) BindWritable 

func (s *Settings) BindWritable(key string, object T.Gpointer, property string, inverted bool)

func (*Settings) Delay 

func (s *Settings) Delay()

func (*Settings) Get 

func (s *Settings) Get(key, format string, v ...VArg)

func (*Settings) GetBoolean 

func (s *Settings) GetBoolean(key string) bool

func (*Settings) GetChild 

func (s *Settings) GetChild(name string) *Settings

func (*Settings) GetDouble 

func (s *Settings) GetDouble(key string) float64

func (*Settings) GetEnum 

func (s *Settings) GetEnum(key string) int

func (*Settings) GetFlags 

func (s *Settings) GetFlags(key string) uint

func (*Settings) GetHasUnapplied 

func (s *Settings) GetHasUnapplied() bool

func (*Settings) GetInt 

func (s *Settings) GetInt(key string) int

func (*Settings) GetMapped 

func (s *Settings) GetMapped(key string, mapping SettingsGetMapping, userData T.Gpointer) T.Gpointer

func (*Settings) GetRange 

func (s *Settings) GetRange(key string) *L.Variant

func (*Settings) GetString 

func (s *Settings) GetString(key string) string

func (*Settings) GetStrv 

func (s *Settings) GetStrv(key string) []string

func (*Settings) GetValue 

func (s *Settings) GetValue(key string) *L.Variant

func (*Settings) IsWritable 

func (s *Settings) IsWritable(name string) bool

func (*Settings) ListChildren 

func (s *Settings) ListChildren() []string

func (*Settings) ListKeys 

func (s *Settings) ListKeys() []string

func (*Settings) RangeCheck 

func (s *Settings) RangeCheck(key string, value *L.Variant) bool

func (*Settings) Reset 

func (s *Settings) Reset(key string)

func (*Settings) Revert 

func (s *Settings) Revert()

func (*Settings) Set 

func (s *Settings) Set(key, format string, v ...VArg) bool

func (*Settings) SetBoolean 

func (s *Settings) SetBoolean(key string, value bool) bool

func (*Settings) SetDouble 

func (s *Settings) SetDouble(key string, value float64) bool

func (*Settings) SetEnum 

func (s *Settings) SetEnum(key string, value int) bool

func (*Settings) SetFlags 

func (s *Settings) SetFlags(key string, value uint) bool

func (*Settings) SetInt 

func (s *Settings) SetInt(key string, value int) bool

func (*Settings) SetString 

func (s *Settings) SetString(key, value string) bool

func (*Settings) SetStrv 

func (s *Settings) SetStrv(key string, value []string) bool

func (*Settings) SetValue 

func (s *Settings) SetValue(key string, value *L.Variant) bool

type SettingsBackend 

type SettingsBackend struct{}

func (*SettingsBackend) Changed 

func (s *SettingsBackend) Changed(key string, originTag T.Gpointer)

func (*SettingsBackend) ChangedTree 

func (s *SettingsBackend) ChangedTree(tree *L.Tree, originTag T.Gpointer)

func (*SettingsBackend) KeysChanged 

func (s *SettingsBackend) KeysChanged(path string, items []string, originTag T.Gpointer)

func (*SettingsBackend) PathChanged 

func (s *SettingsBackend) PathChanged(path string, originTag T.Gpointer)

func (*SettingsBackend) PathWritableChanged 

func (s *SettingsBackend) PathWritableChanged(path string)

func (*SettingsBackend) WritableChanged 

func (s *SettingsBackend) WritableChanged(key string)

type SettingsBindFlags 

type SettingsBindFlags Enum
const (
	SETTINGS_BIND_GET SettingsBindFlags = 1 << iota
	SETTINGS_BIND_SET
	SETTINGS_BIND_NO_SENSITIVITY
	SETTINGS_BIND_GET_NO_CHANGES
	SETTINGS_BIND_INVERT_BOOLEAN
	SETTINGS_BIND_DEFAULT SettingsBindFlags = 0
)

type SettingsBindGetMapping 

type SettingsBindGetMapping func(
	value *O.Value,
	variant *L.Variant,
	userData T.Gpointer) bool

type SettingsBindSetMapping 

type SettingsBindSetMapping func(
	value *O.Value,
	expectedType *L.VariantType,
	userData T.Gpointer) *L.Variant

type SettingsGetMapping 

type SettingsGetMapping func(
	value *L.Variant,
	result *T.Gpointer,
	userData T.Gpointer) bool

type SimpleAction 

type SimpleAction struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*SimpleAction) SetEnabled 

func (s *SimpleAction) SetEnabled(enabled bool)

type SimpleActionGroup 

type SimpleActionGroup struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*SimpleActionGroup) Insert 

func (s *SimpleActionGroup) Insert(action *Action)

func (*SimpleActionGroup) Lookup 

func (s *SimpleActionGroup) Lookup(actionName string) *Action

func (*SimpleActionGroup) Remove 

func (s *SimpleActionGroup) Remove(actionName string)

type SimpleAsyncResult 

type SimpleAsyncResult struct{}

func (*SimpleAsyncResult) Complete 

func (s *SimpleAsyncResult) Complete()

func (*SimpleAsyncResult) CompleteInIdle 

func (s *SimpleAsyncResult) CompleteInIdle()

func (*SimpleAsyncResult) GetOpResGboolean 

func (s *SimpleAsyncResult) GetOpResGboolean() bool

func (*SimpleAsyncResult) GetOpResGpointer 

func (s *SimpleAsyncResult) GetOpResGpointer() T.Gpointer

func (*SimpleAsyncResult) GetOpResGssize 

func (s *SimpleAsyncResult) GetOpResGssize() T.Gssize

func (*SimpleAsyncResult) GetSourceTag 

func (s *SimpleAsyncResult) GetSourceTag() T.Gpointer

func (*SimpleAsyncResult) PropagateError 

func (s *SimpleAsyncResult) PropagateError(dest **L.Error) bool

func (*SimpleAsyncResult) RunInThread 

func (s *SimpleAsyncResult) RunInThread(f SimpleAsyncThreadFunc, ioPriority int, cancellable *Cancellable)

func (*SimpleAsyncResult) SetError 

func (s *SimpleAsyncResult) SetError(domain L.Quark, code int, format string, v ...VArg)

func (*SimpleAsyncResult) SetErrorVa 

func (s *SimpleAsyncResult) SetErrorVa(domain L.Quark, code int, format string, args VAList)

func (*SimpleAsyncResult) SetFromError 

func (s *SimpleAsyncResult) SetFromError(err *L.Error)

func (*SimpleAsyncResult) SetHandleCancellation 

func (s *SimpleAsyncResult) SetHandleCancellation(handleCancellation bool)

func (*SimpleAsyncResult) SetOpResGboolean 

func (s *SimpleAsyncResult) SetOpResGboolean(opRes bool)

func (*SimpleAsyncResult) SetOpResGpointer 

func (s *SimpleAsyncResult) SetOpResGpointer(opRes T.Gpointer, destroyOpRes O.DestroyNotify)

func (*SimpleAsyncResult) SetOpResGssize 

func (s *SimpleAsyncResult) SetOpResGssize(opRes T.Gssize)

func (*SimpleAsyncResult) TakeError 

func (s *SimpleAsyncResult) TakeError(err *L.Error)

type SimpleAsyncThreadFunc 

type SimpleAsyncThreadFunc func(
	res *SimpleAsyncResult,
	object *O.Object,
	cancellable *Cancellable)

type Socket 

type Socket struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*Socket) Accept 

func (s *Socket) Accept(cancellable *Cancellable, err **L.Error) *Socket

func (*Socket) Bind 

func (s *Socket) Bind(address *SocketAddress, allowReuse bool, err **L.Error) bool

func (*Socket) CheckConnectResult 

func (s *Socket) CheckConnectResult(err **L.Error) bool

func (*Socket) Close 

func (s *Socket) Close(err **L.Error) bool

func (*Socket) ConditionCheck 

func (s *Socket) ConditionCheck(condition L.IOCondition) L.IOCondition

func (*Socket) ConditionWait 

func (s *Socket) ConditionWait(condition L.IOCondition, cancellable *Cancellable, err **L.Error) bool

func (*Socket) Connect 

func (s *Socket) Connect(address *SocketAddress, cancellable *Cancellable, err **L.Error) bool

func (*Socket) CreateSource 

func (s *Socket) CreateSource(condition L.IOCondition, cancellable *Cancellable) *O.Source

func (*Socket) GetBlocking 

func (s *Socket) GetBlocking() bool

func (*Socket) GetCredentials 

func (s *Socket) GetCredentials(err **L.Error) *Credentials

func (*Socket) GetFamily 

func (s *Socket) GetFamily() SocketFamily

func (*Socket) GetFd 

func (s *Socket) GetFd() int

func (*Socket) GetKeepalive 

func (s *Socket) GetKeepalive() bool

func (*Socket) GetListenBacklog 

func (s *Socket) GetListenBacklog() int

func (*Socket) GetLocalAddress 

func (s *Socket) GetLocalAddress(err **L.Error) *SocketAddress

func (*Socket) GetProtocol 

func (s *Socket) GetProtocol() SocketProtocol

func (*Socket) GetRemoteAddress 

func (s *Socket) GetRemoteAddress(err **L.Error) *SocketAddress

func (*Socket) GetSocketType 

func (s *Socket) GetSocketType() SocketType

func (*Socket) GetTimeout 

func (s *Socket) GetTimeout() uint

func (*Socket) IsClosed 

func (s *Socket) IsClosed() bool

func (*Socket) IsConnected 

func (s *Socket) IsConnected() bool

func (*Socket) Listen 

func (s *Socket) Listen(err **L.Error) bool

func (*Socket) Receive 

func (s *Socket) Receive(buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) ReceiveFrom 

func (s *Socket) ReceiveFrom(address **SocketAddress, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) ReceiveMessage 

func (s *Socket) ReceiveMessage(address **SocketAddress, vectors *InputVector, numVectors int, messages ***SocketControlMessage, numMessages, flags *int, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) ReceiveWithBlocking 

func (s *Socket) ReceiveWithBlocking(buffer string, size T.Gsize, blocking bool, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) Send 

func (s *Socket) Send(buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) SendMessage 

func (s *Socket) SendMessage(address *SocketAddress, vectors *T.GOutputVector, numVectors int, messages **SocketControlMessage, numMessages, flags int, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) SendTo 

func (s *Socket) SendTo(address *SocketAddress, buffer string, size T.Gsize, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) SendWithBlocking 

func (s *Socket) SendWithBlocking(buffer string, size T.Gsize, blocking bool, cancellable *Cancellable, err **L.Error) T.Gssize

func (*Socket) SetBlocking 

func (s *Socket) SetBlocking(blocking bool)

func (*Socket) SetKeepalive 

func (s *Socket) SetKeepalive(keepalive bool)

func (*Socket) SetListenBacklog 

func (s *Socket) SetListenBacklog(backlog int)

func (*Socket) SetTimeout 

func (s *Socket) SetTimeout(timeout uint)

func (*Socket) Shutdown 

func (s *Socket) Shutdown(shutdownRead, shutdownWrite bool, err **L.Error) bool

func (*Socket) SpeaksIpv4 

func (s *Socket) SpeaksIpv4() bool

type SocketAddress 

type SocketAddress struct {
	Parent O.Object
}

func (*SocketAddress) GetFamily 

func (s *SocketAddress) GetFamily() SocketFamily

func (*SocketAddress) GetNativeSize 

func (s *SocketAddress) GetNativeSize() T.Gssize

func (*SocketAddress) ToNative 

func (s *SocketAddress) ToNative(dest T.Gpointer, destlen T.Gsize, err **L.Error) bool

type SocketAddressEnumerator 

type SocketAddressEnumerator struct {
	Parent O.Object
}

func (*SocketAddressEnumerator) Next 

func (s *SocketAddressEnumerator) Next(cancellable *Cancellable, err **L.Error) *SocketAddress

func (*SocketAddressEnumerator) NextAsync 

func (s *SocketAddressEnumerator) NextAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketAddressEnumerator) NextFinish 

func (s *SocketAddressEnumerator) NextFinish(result *AsyncResult, err **L.Error) *SocketAddress

type SocketClient 

type SocketClient struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*SocketClient) AddApplicationProxy 

func (s *SocketClient) AddApplicationProxy(protocol string)

func (*SocketClient) Connect 

func (s *SocketClient) Connect(connectable *SocketConnectable, cancellable *Cancellable, err **L.Error) *SocketConnection

func (*SocketClient) ConnectAsync 

func (s *SocketClient) ConnectAsync(connectable *SocketConnectable, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketClient) ConnectFinish 

func (s *SocketClient) ConnectFinish(result *AsyncResult, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToHost 

func (s *SocketClient) ConnectToHost(hostAndPort string, defaultPort uint16, cancellable *Cancellable, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToHostAsync 

func (s *SocketClient) ConnectToHostAsync(hostAndPort string, defaultPort uint16, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketClient) ConnectToHostFinish 

func (s *SocketClient) ConnectToHostFinish(result *AsyncResult, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToService 

func (s *SocketClient) ConnectToService(domain, service string, cancellable *Cancellable, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToServiceAsync 

func (s *SocketClient) ConnectToServiceAsync(domain, service string, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketClient) ConnectToServiceFinish 

func (s *SocketClient) ConnectToServiceFinish(result *AsyncResult, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToUri 

func (s *SocketClient) ConnectToUri(uri string, defaultPort uint16, cancellable *Cancellable, err **L.Error) *SocketConnection

func (*SocketClient) ConnectToUriAsync 

func (s *SocketClient) ConnectToUriAsync(uri string, defaultPort uint16, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketClient) ConnectToUriFinish 

func (s *SocketClient) ConnectToUriFinish(result *AsyncResult, err **L.Error) *SocketConnection

func (*SocketClient) GetEnableProxy 

func (s *SocketClient) GetEnableProxy() bool

func (*SocketClient) GetFamily 

func (s *SocketClient) GetFamily() SocketFamily

func (*SocketClient) GetLocalAddress 

func (s *SocketClient) GetLocalAddress() *SocketAddress

func (*SocketClient) GetProtocol 

func (s *SocketClient) GetProtocol() SocketProtocol

func (*SocketClient) GetSocketType 

func (s *SocketClient) GetSocketType() SocketType

func (*SocketClient) GetTimeout 

func (s *SocketClient) GetTimeout() uint

func (*SocketClient) GetTls 

func (s *SocketClient) GetTls() bool

func (*SocketClient) GetTlsValidationFlags 

func (s *SocketClient) GetTlsValidationFlags() TlsCertificateFlags

func (*SocketClient) SetEnableProxy 

func (s *SocketClient) SetEnableProxy(enable bool)

func (*SocketClient) SetFamily 

func (s *SocketClient) SetFamily(family SocketFamily)

func (*SocketClient) SetLocalAddress 

func (s *SocketClient) SetLocalAddress(address *SocketAddress)

func (*SocketClient) SetProtocol 

func (s *SocketClient) SetProtocol(protocol SocketProtocol)

func (*SocketClient) SetSocketType 

func (s *SocketClient) SetSocketType(t SocketType)

func (*SocketClient) SetTimeout 

func (s *SocketClient) SetTimeout(timeout uint)

func (*SocketClient) SetTls 

func (s *SocketClient) SetTls(tls bool)

func (*SocketClient) SetTlsValidationFlags 

func (s *SocketClient) SetTlsValidationFlags(flags TlsCertificateFlags)

type SocketConnectable 

type SocketConnectable struct{}

func (*SocketConnectable) Enumerate 

func (s *SocketConnectable) Enumerate() *SocketAddressEnumerator

func (*SocketConnectable) ProxyEnumerate 

func (s *SocketConnectable) ProxyEnumerate() *SocketAddressEnumerator

type SocketConnection 

type SocketConnection struct {
	Parent IOStream
	// contains filtered or unexported fields
}

func (*SocketConnection) GetLocalAddress 

func (s *SocketConnection) GetLocalAddress(err **L.Error) *SocketAddress

func (*SocketConnection) GetRemoteAddress 

func (s *SocketConnection) GetRemoteAddress(err **L.Error) *SocketAddress

func (*SocketConnection) GetSocket 

func (s *SocketConnection) GetSocket() *Socket

type SocketControlMessage 

type SocketControlMessage struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*SocketControlMessage) GetLevel 

func (s *SocketControlMessage) GetLevel() int

func (*SocketControlMessage) GetMsgType 

func (s *SocketControlMessage) GetMsgType() int

func (*SocketControlMessage) GetSize 

func (s *SocketControlMessage) GetSize() T.Gsize

func (*SocketControlMessage) Serialize 

func (s *SocketControlMessage) Serialize(data T.Gpointer)

type SocketFamily 

type SocketFamily Enum
const (
	SOCKET_FAMILY_INVALID SocketFamily = iota
	SOCKET_FAMILY_UNIX
	SOCKET_FAMILY_IPV4
	SOCKET_FAMILY_IPV6 SocketFamily = 23
)

type SocketListener 

type SocketListener struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*SocketListener) Accept 

func (s *SocketListener) Accept(sourceObject **O.Object, cancellable *Cancellable, err **L.Error) *SocketConnection

func (*SocketListener) AcceptAsync 

func (s *SocketListener) AcceptAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketListener) AcceptFinish 

func (s *SocketListener) AcceptFinish(result *AsyncResult, sourceObject **O.Object, err **L.Error) *SocketConnection

func (*SocketListener) AcceptSocket 

func (s *SocketListener) AcceptSocket(sourceObject **O.Object, cancellable *Cancellable, err **L.Error) *Socket

func (*SocketListener) AcceptSocketAsync 

func (s *SocketListener) AcceptSocketAsync(cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*SocketListener) AcceptSocketFinish 

func (s *SocketListener) AcceptSocketFinish(result *AsyncResult, sourceObject **O.Object, err **L.Error) *Socket

func (*SocketListener) AddAddress 

func (s *SocketListener) AddAddress(address *SocketAddress, t SocketType, protocol SocketProtocol, sourceObject *O.Object, effectiveAddress **SocketAddress, err **L.Error) bool

func (*SocketListener) AddAnyInetPort 

func (s *SocketListener) AddAnyInetPort(sourceObject *O.Object, err **L.Error) uint16

func (*SocketListener) AddInetPort 

func (s *SocketListener) AddInetPort(port uint16, sourceObject *O.Object, err **L.Error) bool

func (*SocketListener) AddSocket 

func (s *SocketListener) AddSocket(socket *Socket, sourceObject *O.Object, err **L.Error) bool

func (*SocketListener) Close 

func (s *SocketListener) Close()

func (*SocketListener) SetBacklog 

func (s *SocketListener) SetBacklog(listenBacklog int)

type SocketProtocol 

type SocketProtocol Enum
const (
	SOCKET_PROTOCOL_UNKNOWN SocketProtocol = -1
	SOCKET_PROTOCOL_DEFAULT SocketProtocol = 0
	SOCKET_PROTOCOL_TCP     SocketProtocol = 6
	SOCKET_PROTOCOL_UDP     SocketProtocol = 17
	SOCKET_PROTOCOL_SCTP    SocketProtocol = 132
)

type SocketService 

type SocketService struct {
	Parent SocketListener
	// contains filtered or unexported fields
}

func (*SocketService) IsActive 

func (s *SocketService) IsActive() bool

func (*SocketService) Start 

func (s *SocketService) Start()

func (*SocketService) Stop 

func (s *SocketService) Stop()

type SocketType 

type SocketType Enum
const (
	SOCKET_TYPE_INVALID SocketType = iota
	SOCKET_TYPE_STREAM
	SOCKET_TYPE_DATAGRAM
	SOCKET_TYPE_SEQPACKET
)

type SrvTarget 

type SrvTarget struct{}

func (*SrvTarget) Copy 

func (s *SrvTarget) Copy() *SrvTarget

func (*SrvTarget) Free 

func (s *SrvTarget) Free()

func (*SrvTarget) GetHostname 

func (s *SrvTarget) GetHostname() string

func (*SrvTarget) GetPort 

func (s *SrvTarget) GetPort() uint16

func (*SrvTarget) GetPriority 

func (s *SrvTarget) GetPriority() uint16

func (*SrvTarget) GetWeight 

func (s *SrvTarget) GetWeight() uint16

type TcpConnection 

type TcpConnection struct {
	Parent SocketConnection
	// contains filtered or unexported fields
}

func (*TcpConnection) GetGracefulDisconnect 

func (t *TcpConnection) GetGracefulDisconnect() bool

func (*TcpConnection) SetGracefulDisconnect 

func (t *TcpConnection) SetGracefulDisconnect(gracefulDisconnect bool)

type TcpWrapperConnection 

type TcpWrapperConnection struct {
	Parent TcpConnection
	// contains filtered or unexported fields
}

func (*TcpWrapperConnection) GetBaseIoStream 

func (t *TcpWrapperConnection) GetBaseIoStream() *IOStream

type ThemedIcon 

type ThemedIcon struct{}

func (*ThemedIcon) AppendName 

func (t *ThemedIcon) AppendName(iconname string)

func (*ThemedIcon) GetNames 

func (t *ThemedIcon) GetNames() []string

func (*ThemedIcon) PrependName 

func (t *ThemedIcon) PrependName(iconname string)

type TlsBackend 

type TlsBackend struct{}

func (*TlsBackend) GetCertificateType 

func (t *TlsBackend) GetCertificateType() O.Type

func (*TlsBackend) GetClientConnectionType 

func (t *TlsBackend) GetClientConnectionType() O.Type

func (*TlsBackend) GetServerConnectionType 

func (t *TlsBackend) GetServerConnectionType() O.Type

func (*TlsBackend) SupportsTls 

func (t *TlsBackend) SupportsTls() bool

type TlsCertificate 

type TlsCertificate struct {
	Parent O.Object
	// contains filtered or unexported fields
}

func (*TlsCertificate) GetIssuer 

func (t *TlsCertificate) GetIssuer() *TlsCertificate

func (*TlsCertificate) Verify 

func (t *TlsCertificate) Verify(identity *SocketConnectable, trustedCa *TlsCertificate) TlsCertificateFlags

type TlsCertificateFlags 

type TlsCertificateFlags Enum
const (
	TLS_CERTIFICATE_UNKNOWN_CA TlsCertificateFlags = 1 << iota
	TLS_CERTIFICATE_BAD_IDENTITY
	TLS_CERTIFICATE_NOT_ACTIVATED
	TLS_CERTIFICATE_EXPIRED
	TLS_CERTIFICATE_REVOKED
	TLS_CERTIFICATE_INSECURE
	TLS_CERTIFICATE_GENERIC_ERROR
	TLS_CERTIFICATE_VALIDATE_ALL TlsCertificateFlags = 0x007f
)

type TlsClientConnection 

type TlsClientConnection struct{}

func (*TlsClientConnection) GetAcceptedCas 

func (t *TlsClientConnection) GetAcceptedCas() *L.List

func (*TlsClientConnection) GetServerIdentity 

func (t *TlsClientConnection) GetServerIdentity() *SocketConnectable

func (*TlsClientConnection) GetUseSsl3 

func (t *TlsClientConnection) GetUseSsl3() bool

func (*TlsClientConnection) GetValidationFlags 

func (t *TlsClientConnection) GetValidationFlags() TlsCertificateFlags

func (*TlsClientConnection) SetServerIdentity 

func (t *TlsClientConnection) SetServerIdentity(identity *SocketConnectable)

func (*TlsClientConnection) SetUseSsl3 

func (t *TlsClientConnection) SetUseSsl3(useSsl3 bool)

func (*TlsClientConnection) SetValidationFlags 

func (t *TlsClientConnection) SetValidationFlags(flags TlsCertificateFlags)

type TlsConnection 

type TlsConnection struct {
	Parent IOStream
	// contains filtered or unexported fields
}

func (*TlsConnection) EmitAcceptCertificate 

func (t *TlsConnection) EmitAcceptCertificate(peerCert *TlsCertificate, errors TlsCertificateFlags) bool

func (*TlsConnection) GetCertificate 

func (t *TlsConnection) GetCertificate() *TlsCertificate

func (*TlsConnection) GetPeerCertificate 

func (t *TlsConnection) GetPeerCertificate() *TlsCertificate

func (*TlsConnection) GetPeerCertificateErrors 

func (t *TlsConnection) GetPeerCertificateErrors() TlsCertificateFlags

func (*TlsConnection) GetRehandshakeMode 

func (t *TlsConnection) GetRehandshakeMode() TlsRehandshakeMode

func (*TlsConnection) GetRequireCloseNotify 

func (t *TlsConnection) GetRequireCloseNotify() bool

func (*TlsConnection) GetUseSystemCertdb 

func (t *TlsConnection) GetUseSystemCertdb() bool

func (*TlsConnection) Handshake 

func (t *TlsConnection) Handshake(cancellable *Cancellable, err **L.Error) bool

func (*TlsConnection) HandshakeAsync 

func (t *TlsConnection) HandshakeAsync(ioPriority int, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*TlsConnection) HandshakeFinish 

func (t *TlsConnection) HandshakeFinish(result *AsyncResult, err **L.Error) bool

func (*TlsConnection) SetCertificate 

func (t *TlsConnection) SetCertificate(certificate *TlsCertificate)

func (*TlsConnection) SetRehandshakeMode 

func (t *TlsConnection) SetRehandshakeMode(mode TlsRehandshakeMode)

func (*TlsConnection) SetRequireCloseNotify 

func (t *TlsConnection) SetRequireCloseNotify(requireCloseNotify bool)

func (*TlsConnection) SetUseSystemCertdb 

func (t *TlsConnection) SetUseSystemCertdb(useSystemCertdb bool)

type TlsRehandshakeMode 

type TlsRehandshakeMode Enum
const (
	TLS_REHANDSHAKE_NEVER TlsRehandshakeMode = iota
	TLS_REHANDSHAKE_SAFELY
	TLS_REHANDSHAKE_UNSAFELY
)

type Vfs 

type Vfs struct {
	Parent O.Object
}

func (*Vfs) GetFileForPath 

func (v *Vfs) GetFileForPath(path string) *File

func (*Vfs) GetFileForUri 

func (v *Vfs) GetFileForUri(uri string) *File

func (*Vfs) GetSupportedUriSchemes 

func (v *Vfs) GetSupportedUriSchemes() []string

func (*Vfs) IsActive 

func (v *Vfs) IsActive() bool

func (*Vfs) ParseName 

func (v *Vfs) ParseName(parseName string) *File

type Volume 

type Volume struct{}

func (*Volume) CanEject 

func (v *Volume) CanEject() bool

func (*Volume) CanMount 

func (v *Volume) CanMount() bool

func (*Volume) Eject 

func (v *Volume) Eject(flags MountUnmountFlags, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Volume) EjectFinish 

func (v *Volume) EjectFinish(result *AsyncResult, err **L.Error) bool

func (*Volume) EjectWithOperation 

func (v *Volume) EjectWithOperation(flags MountUnmountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Volume) EjectWithOperationFinish 

func (v *Volume) EjectWithOperationFinish(result *AsyncResult, err **L.Error) bool

func (*Volume) EnumerateIdentifiers 

func (v *Volume) EnumerateIdentifiers() []string

func (*Volume) GetActivationRoot 

func (v *Volume) GetActivationRoot() *File

func (*Volume) GetDrive 

func (v *Volume) GetDrive() *Drive

func (*Volume) GetIcon 

func (v *Volume) GetIcon() *Icon

func (*Volume) GetIdentifier 

func (v *Volume) GetIdentifier(kind string) string

func (*Volume) GetMount 

func (v *Volume) GetMount() *Mount

func (*Volume) GetName 

func (v *Volume) GetName() string

func (*Volume) GetUuid 

func (v *Volume) GetUuid() string

func (*Volume) Mount 

func (v *Volume) Mount(flags MountMountFlags, mountOperation *MountOperation, cancellable *Cancellable, callback AsyncReadyCallback, userData T.Gpointer)

func (*Volume) MountFinish 

func (v *Volume) MountFinish(result *AsyncResult, err **L.Error) bool

func (*Volume) ShouldAutomount 

func (v *Volume) ShouldAutomount() bool

type VolumeMonitor 

type VolumeMonitor struct {
	Parent O.Object
	Priv   T.Gpointer
}

func (*VolumeMonitor) GetConnectedDrives 

func (v *VolumeMonitor) GetConnectedDrives() *L.List

func (*VolumeMonitor) GetMountForUuid 

func (v *VolumeMonitor) GetMountForUuid(uuid string) *Mount

func (*VolumeMonitor) GetMounts 

func (v *VolumeMonitor) GetMounts() *L.List

func (*VolumeMonitor) GetVolumeForUuid 

func (v *VolumeMonitor) GetVolumeForUuid(uuid string) *Volume

func (*VolumeMonitor) GetVolumes 

func (v *VolumeMonitor) GetVolumes() *L.List

type Win32InputStream 

type Win32InputStream struct {
	Parent InputStream
	// contains filtered or unexported fields
}

func (*Win32InputStream) GetCloseHandle 

func (w *Win32InputStream) GetCloseHandle() bool

func (*Win32InputStream) GetHandle 

func (w *Win32InputStream) GetHandle() *T.Void

func (*Win32InputStream) SetCloseHandle 

func (w *Win32InputStream) SetCloseHandle(closeHandle bool)

type Win32OutputStream 

type Win32OutputStream struct {
	Parent OutputStream
	// contains filtered or unexported fields
}

func (*Win32OutputStream) GetCloseHandle 

func (w *Win32OutputStream) GetCloseHandle() bool

func (*Win32OutputStream) GetHandle 

func (w *Win32OutputStream) GetHandle() *T.Void

func (*Win32OutputStream) SetCloseHandle 

func (w *Win32OutputStream) SetCloseHandle(closeHandle bool)

type ZlibCompressor 

type ZlibCompressor struct{}

func (*ZlibCompressor) GetFileInfo 

func (z *ZlibCompressor) GetFileInfo() *FileInfo

func (*ZlibCompressor) SetFileInfo 

func (z *ZlibCompressor) SetFileInfo(fileInfo *FileInfo)

type ZlibCompressorFormat 

type ZlibCompressorFormat Enum
const (
	ZLIB_COMPRESSOR_FORMAT_ZLIB ZlibCompressorFormat = iota
	ZLIB_COMPRESSOR_FORMAT_GZIP
	ZLIB_COMPRESSOR_FORMAT_RAW
)

type ZlibDecompressor 

type ZlibDecompressor struct{}

func (*ZlibDecompressor) GetFileInfo 

func (z *ZlibDecompressor) GetFileInfo() *FileInfo

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.