GI.GObject.FunctionsboxedCopyboxedFreeenumCompleteTypeInfoenumGetValueenumGetValueByNameenumGetValueByNickenumRegisterStaticflagsCompleteTypeInfoflagsGetFirstValueflagsGetValueByNameflagsGetValueByNickflagsRegisterStaticgtypeGetTypeparamTypeRegisterStaticparamValueConvertparamValueDefaultsparamValueSetDefaultparamValueValidateparamValuesCmppointerTypeRegisterStaticsignalAccumulatorFirstWinssignalAccumulatorTrueHandledsignalAddEmissionHooksignalChainFromOverriddensignalConnectClosuresignalConnectClosureByIdsignalEmitvsignalGetInvocationHintsignalHandlerBlocksignalHandlerDisconnectsignalHandlerFindsignalHandlerIsConnectedsignalHandlerUnblocksignalHandlersBlockMatchedsignalHandlersDestroysignalHandlersDisconnectMatchedsignalHandlersUnblockMatchedsignalHasHandlerPendingsignalListIdssignalLookupsignalOverrideClassClosuresignalParseNamesignalRemoveEmissionHooksignalStopEmissionsignalStopEmissionByNamesignalTypeCclosureNewsourceSetClosuresourceSetDummyCallbackstrdupValueContentstypeAddClassPrivatetypeAddInstancePrivatetypeAddInterfaceDynamictypeAddInterfaceStatictypeCheckClassIsAtypeCheckInstancetypeCheckInstanceIsAtypeCheckInstanceIsFundamentallyAtypeCheckIsValueTypetypeCheckValuetypeCheckValueHoldstypeDefaultInterfacePeektypeDefaultInterfaceReftypeDefaultInterfaceUnreftypeDepthtypeEnsuretypeFreeInstancetypeFundamentaltypeFundamentalNexttypeGetInstanceCounttypeGetPlugintypeGetQdatatypeGetTypeRegistrationSerialtypeInitWithDebugFlagstypeInterfacestypeIsAtypeNameFromClasstypeNameFromInstancetypeNextBasetypeRegisterDynamictypeRegisterFundamentaltypeRegisterStatictypeSetQdatatypeTestFlagsboxedCopy :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m (Ptr ())boxedFree :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m ()enumCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> EnumValue -> m TypeInfoenumGetValue :: (HasCallStack, MonadIO m) => EnumClass -> Int32 -> m EnumValueenumGetValueByName :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m EnumValueenumGetValueByNick :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m EnumValueenumRegisterStatic :: (HasCallStack, MonadIO m) => Text -> EnumValue -> m GTypeenumToString :: (HasCallStack, MonadIO m) => GType -> Int32 -> m TextflagsCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> FlagsValue -> m TypeInfoflagsGetFirstValue :: (HasCallStack, MonadIO m) => FlagsClass -> Word32 -> m FlagsValueflagsGetValueByName :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m FlagsValueflagsGetValueByNick :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m FlagsValueflagsRegisterStatic :: (HasCallStack, MonadIO m) => Text -> FlagsValue -> m GTypeflagsToString :: (HasCallStack, MonadIO m) => GType -> Word32 -> m TextgtypeGetType :: (HasCallStack, MonadIO m) => m GTypeparamSpecBoolean :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Bool -> [ParamFlags] -> m GParamSpecparamSpecBoxed :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpecparamSpecChar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int8 -> Int8 -> Int8 -> [ParamFlags] -> m GParamSpecparamSpecDouble :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Double -> Double -> Double -> [ParamFlags] -> m GParamSpecparamSpecEnum :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> Int32 -> [ParamFlags] -> m GParamSpecparamSpecFlags :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> Word32 -> [ParamFlags] -> m GParamSpecparamSpecFloat :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Float -> Float -> Float -> [ParamFlags] -> m GParamSpecparamSpecGtype :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpecparamSpecInt :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int32 -> Int32 -> Int32 -> [ParamFlags] -> m GParamSpecparamSpecInt64 :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int64 -> Int64 -> Int64 -> [ParamFlags] -> m GParamSpecparamSpecLong :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> CLong -> CLong -> CLong -> [ParamFlags] -> m GParamSpecparamSpecObject :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpecparamSpecParam :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpecparamSpecPointer :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> [ParamFlags] -> m GParamSpecparamSpecString :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Maybe Text -> [ParamFlags] -> m GParamSpecparamSpecUchar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word8 -> Word8 -> Word8 -> [ParamFlags] -> m GParamSpecparamSpecUint :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word32 -> Word32 -> Word32 -> [ParamFlags] -> m GParamSpecparamSpecUint64 :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word64 -> Word64 -> Word64 -> [ParamFlags] -> m GParamSpecparamSpecUlong :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> CULong -> CULong -> CULong -> [ParamFlags] -> m GParamSpecparamSpecUnichar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Char -> [ParamFlags] -> m GParamSpecparamSpecVariant :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> VariantType -> Maybe GVariant -> [ParamFlags] -> m GParamSpecparamTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> ParamSpecTypeInfo -> m GTypeparamValueConvert :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> Bool -> m BoolparamValueDefaults :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m BoolparamValueSetDefault :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m ()paramValueValidate :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m BoolparamValuesCmp :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> m Int32pointerTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> m GTypesignalAccumulatorFirstWins :: (HasCallStack, MonadIO m) => SignalInvocationHint -> GValue -> GValue -> Ptr () -> m BoolsignalAccumulatorTrueHandled :: (HasCallStack, MonadIO m) => SignalInvocationHint -> GValue -> GValue -> Ptr () -> m BoolsignalAddEmissionHook :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> SignalEmissionHook -> m CULongsignalChainFromOverridden :: (HasCallStack, MonadIO m) => [GValue] -> GValue -> m ()signalConnectClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Closure -> Bool -> m CULongsignalConnectClosureById :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> Closure -> Bool -> m CULongsignalEmitv :: (HasCallStack, MonadIO m) => [GValue] -> Word32 -> Word32 -> m GValuesignalGetInvocationHint :: (HasCallStack, MonadIO m, IsObject a) => a -> m SignalInvocationHintsignalHandlerBlock :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()signalHandlerDisconnect :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()signalHandlerFind :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe Closure -> Ptr () -> Ptr () -> m CULongsignalHandlerIsConnected :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m BoolsignalHandlerUnblock :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()signalHandlersBlockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe Closure -> Ptr () -> Ptr () -> m Word32signalHandlersDestroy :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()signalHandlersDisconnectMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe Closure -> Ptr () -> Ptr () -> m Word32signalHandlersUnblockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe Closure -> Ptr () -> Ptr () -> m Word32signalHasHandlerPending :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> Bool -> m BoolsignalListIds :: (HasCallStack, MonadIO m) => GType -> m [Word32]signalLookup :: (HasCallStack, MonadIO m) => Text -> GType -> m Word32signalName :: (HasCallStack, MonadIO m) => Word32 -> m TextsignalOverrideClassClosure :: (HasCallStack, MonadIO m) => Word32 -> GType -> Closure -> m ()signalParseName :: (HasCallStack, MonadIO m) => Text -> GType -> Bool -> m (Bool, Word32, Word32)signalQuery :: (HasCallStack, MonadIO m) => Word32 -> m SignalQuerysignalRemoveEmissionHook :: (HasCallStack, MonadIO m) => Word32 -> CULong -> m ()signalStopEmission :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> m ()signalStopEmissionByName :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m ()signalTypeCclosureNew :: (HasCallStack, MonadIO m) => GType -> Word32 -> m ClosuresourceSetClosure :: (HasCallStack, MonadIO m) => Source -> Closure -> m ()sourceSetDummyCallback :: (HasCallStack, MonadIO m) => Source -> m ()strdupValueContents :: (HasCallStack, MonadIO m) => GValue -> m TexttypeAddClassPrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m ()typeAddInstancePrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m Int32typeAddInterfaceDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> GType -> a -> m ()typeAddInterfaceStatic :: (HasCallStack, MonadIO m) => GType -> GType -> InterfaceInfo -> m ()typeCheckClassIsA :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m BooltypeCheckInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m BooltypeCheckInstanceIsA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m BooltypeCheckInstanceIsFundamentallyA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m BooltypeCheckIsValueType :: (HasCallStack, MonadIO m) => GType -> m BooltypeCheckValue :: (HasCallStack, MonadIO m) => GValue -> m BooltypeCheckValueHolds :: (HasCallStack, MonadIO m) => GValue -> GType -> m BooltypeChildren :: (HasCallStack, MonadIO m) => GType -> m [GType]typeDefaultInterfacePeek :: (HasCallStack, MonadIO m) => GType -> m TypeInterfacetypeDefaultInterfaceRef :: (HasCallStack, MonadIO m) => GType -> m TypeInterfacetypeDefaultInterfaceUnref :: (HasCallStack, MonadIO m) => TypeInterface -> m ()typeDepth :: (HasCallStack, MonadIO m) => GType -> m Word32typeEnsure :: (HasCallStack, MonadIO m) => GType -> m ()typeFreeInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m ()typeFromName :: (HasCallStack, MonadIO m) => Text -> m GTypetypeFundamental :: (HasCallStack, MonadIO m) => GType -> m GTypetypeFundamentalNext :: (HasCallStack, MonadIO m) => m GTypetypeGetInstanceCount :: (HasCallStack, MonadIO m) => GType -> m Int32typeGetPlugin :: (HasCallStack, MonadIO m) => GType -> m TypePlugintypeGetQdata :: (HasCallStack, MonadIO m) => GType -> Word32 -> m (Ptr ())typeGetTypeRegistrationSerial :: (HasCallStack, MonadIO m) => m Word32typeInit :: (HasCallStack, MonadIO m) => m ()typeInitWithDebugFlags :: (HasCallStack, MonadIO m) => [TypeDebugFlags] -> m ()typeInterfaces :: (HasCallStack, MonadIO m) => GType -> m [GType]typeIsA :: (HasCallStack, MonadIO m) => GType -> GType -> m BooltypeName :: (HasCallStack, MonadIO m) => GType -> m TexttypeNameFromClass :: (HasCallStack, MonadIO m) => TypeClass -> m TexttypeNameFromInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m TexttypeNextBase :: (HasCallStack, MonadIO m) => GType -> GType -> m GTypetypeParent :: (HasCallStack, MonadIO m) => GType -> m GTypetypeQname :: (HasCallStack, MonadIO m) => GType -> m Word32typeQuery :: (HasCallStack, MonadIO m) => GType -> m TypeQuerytypeRegisterDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> Text -> a -> [TypeFlags] -> m GTypetypeRegisterFundamental :: (HasCallStack, MonadIO m) => GType -> Text -> TypeInfo -> TypeFundamentalInfo -> [TypeFlags] -> m GTypetypeRegisterStatic :: (HasCallStack, MonadIO m) => GType -> Text -> TypeInfo -> [TypeFlags] -> m GTypetypeSetQdata :: (HasCallStack, MonadIO m) => GType -> Word32 -> Ptr () -> m ()typeTestFlags :: (HasCallStack, MonadIO m) => GType -> Word32 -> m BoolboxedCopy Source #boxedType: The type of srcBoxed.srcBoxed: The boxed structure to be copied.Returns: The newly created copy of the boxed structure.Provide a copy of a boxed structure srcBoxed which is of type boxedType.boxedFree Source #boxedType: The type of boxed.boxed: The boxed structure to be freed.Free the boxed structure boxed which is of type boxedType.enumCompleteTypeInfo Source #gEnumType: the type identifier of the type being completed-> EnumValueconstValues: An array of EnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0.-> m TypeInfoThis function is meant to be called from the complete_type_info function of a TypePlugin implementation, as in the following example:enumGetValue Source #=> EnumClassenumClass: a EnumClassvalue: the value to look up-> m EnumValueReturns: the EnumValue for value, or Nothing if value is not a member of the enumerationReturns the EnumValue for a value.enumGetValueByName Source #name: the name to look upReturns: the EnumValue with name name, or Nothing if the enumeration doesn't have a member with that nameLooks up a EnumValue by name.enumGetValueByNick Source #nick: the nickname to look upReturns: the EnumValue with nickname nick, or Nothing if the enumeration doesn't have a member with that nicknameLooks up a EnumValue by nickname.enumRegisterStatic Source #name: A nul-terminated string used as the name of the new type.constStaticValues: An array of EnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated.Returns: The new type identifier.It is normally more convenient to let [glib-mkenums][glib-mkenums], generate a my_enum_get_type() function from a usual C enumeration definition than to write one yourself using enumRegisterStatic.enumToString Source #gEnumType: the type identifier of a EnumClass typeReturns: a newly-allocated text stringflagsCompleteTypeInfo Source #gFlagsType: the type identifier of the type being completed-> FlagsValueconstValues: An array of FlagsValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0.This function is meant to be called from the complete_type_info() function of a TypePlugin implementation, see the example for enumCompleteTypeInfo above.flagsGetFirstValue Source #=> FlagsClassflagsClass: a FlagsClass-> m FlagsValueReturns: the first FlagsValue which is set in value, or Nothing if none is setReturns the first FlagsValue which is set in value.flagsGetValueByName Source #Returns: the FlagsValue with name name, or Nothing if there is no flag with that nameLooks up a FlagsValue by name.flagsGetValueByNick Source #Returns: the FlagsValue with nickname nick, or Nothing if there is no flag with that nicknameLooks up a FlagsValue by nickname.flagsRegisterStatic Source #constStaticValues: An array of FlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. GObject keeps a reference to the data, so it cannot be stack-allocated.It is normally more convenient to let [glib-mkenums][glib-mkenums] generate a my_flags_get_type() function from a usual C enumeration definition than to write one yourself using flagsRegisterStatic.flagsToString Source #flagsType: the type identifier of a FlagsClass typegtypeGetType :: (HasCallStack, MonadIO m) => m GType Source #paramSpecBoolean Source #name: canonical name of the property specifiednick: nick name for the property specifiedblurb: description of the property specifieddefaultValue: default value for the property specified-> [ParamFlags]flags: flags for the property specifiedReturns: a newly created parameter specificationCreates a new ParamSpecBoolean instance specifying a G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with paramSpecEnum, both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API.paramSpecBoxed Source #boxedType: G_TYPE_BOXED derived type of this propertyCreates a new ParamSpecBoxed instance specifying a G_TYPE_BOXED derived property.paramSpecChar Source #minimum: minimum value for the property specifiedmaximum: maximum value for the property specifiedCreates a new ParamSpecChar instance specifying a G_TYPE_CHAR property.paramSpecDouble Source #Creates a new ParamSpecDouble instance specifying a G_TYPE_DOUBLE property.paramSpecEnum Source #enumType: a GType derived from G_TYPE_ENUMCreates a new ParamSpecEnum instance specifying a G_TYPE_ENUM property.paramSpecFlags Source #flagsType: a GType derived from G_TYPE_FLAGSCreates a new ParamSpecFlags instance specifying a G_TYPE_FLAGS property.paramSpecFloat Source #Creates a new ParamSpecFloat instance specifying a G_TYPE_FLOAT property.paramSpecGtype Source #isAType: a GType whose subtypes are allowed as values of the property (use G_TYPE_NONE for any type)Creates a new ParamSpecGType instance specifying a G_TYPE_GTYPE property.paramSpecInt Source #Creates a new ParamSpecInt instance specifying a G_TYPE_INT property.paramSpecInt64 Source #Creates a new ParamSpecInt64 instance specifying a G_TYPE_INT64 property.paramSpecLong Source #Creates a new ParamSpecLong instance specifying a G_TYPE_LONG property.paramSpecObject Source #objectType: G_TYPE_OBJECT derived type of this propertyCreates a new ParamSpecBoxed instance specifying a G_TYPE_OBJECT derived property.paramSpecParam Source #paramType: a GType derived from G_TYPE_PARAMCreates a new ParamSpecParam instance specifying a G_TYPE_PARAM property.paramSpecPointer Source #Creates a new ParamSpecPointer instance specifying a pointer property. Where possible, it is better to use paramSpecObject or paramSpecBoxed to expose memory management information.paramSpecString Source #Creates a new ParamSpecString instance.paramSpecUchar Source #Creates a new ParamSpecUChar instance specifying a G_TYPE_UCHAR property.paramSpecUint Source #Creates a new ParamSpecUInt instance specifying a G_TYPE_UINT property.paramSpecUint64 Source #Creates a new ParamSpecUInt64 instance specifying a G_TYPE_UINT64 property.paramSpecUlong Source #Creates a new ParamSpecULong instance specifying a G_TYPE_ULONG property.paramSpecUnichar Source #Creates a new ParamSpecUnichar instance specifying a G_TYPE_UINT property. Value structures for this property can be accessed with valueSetUint and valueGetUint.paramSpecVariant Source #defaultValue: a GVariant of type type to use as the default value, or NothingReturns: the newly created ParamSpecCreates a new ParamSpecVariant instance specifying a GVariant property.If defaultValue is floating, it is consumed.paramTypeRegisterStatic Source #name: 0-terminated string used as the name of the new ParamSpec type.-> ParamSpecTypeInfopspecInfo: The ParamSpecTypeInfo for this ParamSpec type.Registers name as the name of a new static type derived from G_TYPE_PARAM. The type system uses the information contained in the ParamSpecTypeInfo structure pointed to by info to manage the ParamSpec type and its instances.paramValueConvert Source #pspec: a valid ParamSpecsrcValue: souce ValuedestValue: destination Value of correct type for pspecstrictValidation: True requires destValue to conform to pspec without modificationsReturns: True if transformation and validation were successful, False otherwise and destValue is left untouched.Transforms srcValue into destValue if possible, and then validates destValue, in order for it to conform to pspec. If strictValidation is True this function will only succeed if the transformed destValue complied to pspec without modifications.See also valueTypeTransformable, valueTransform and paramValueValidate.paramValueDefaults Source #value: a Value of correct type for pspecReturns: whether value contains the canonical default for this pspecparamValueSetDefault Source #paramValueValidate Source #Returns: whether modifying value was necessary to ensure validityEnsures that the contents of value comply with the specifications set out by pspec. For example, a ParamSpecInt might require that integers stored in value may not be smaller than -42 and not be greater than +42. If value contains an integer outside of this range, it is modified accordingly, so the resulting value will fit into the range -42 .. +42.paramValuesCmp Source #value1: a Value of correct type for pspecvalue2: a Value of correct type for pspecReturns: -1, 0 or +1, for a less than, equal to or greater than resultpointerTypeRegisterStatic Source #name: the name of the new pointer type.Returns: a new G_TYPE_POINTER derived type id for name.signalAccumulatorFirstWins Source #=> SignalInvocationHintihint: standard SignalAccumulator parameterreturnAccu: standard SignalAccumulator parameterhandlerReturn: standard SignalAccumulator parameterdummy: standard SignalAccumulator parameterReturns: standard SignalAccumulator resultA predefined SignalAccumulator for signals intended to be used as a hook for application code to provide a particular value. Usually only one such value is desired and multiple handlers for the same signal don't make much sense (except for the case of the default handler defined in the class structure, in which case you will usually want the signal connection to override the class handler).signalAccumulatorTrueHandled Source #A predefined SignalAccumulator for signals that return a boolean values. The behavior that this accumulator gives is that a return of True stops the signal emission: no further callbacks will be invoked, while a return of False allows the emission to continue. The idea here is that a True return indicates that the callback handled the signal, and no further handling is needed.signalAddEmissionHook Source #signalId: the signal identifier, as returned by signalLookup.detail: the detail on which to call the hook.-> SignalEmissionHookhookFunc: a SignalEmissionHook function.Returns: the hook id, for later use with signalRemoveEmissionHook.signalChainFromOverridden Source #=> [GValue]instanceAndParams: the argument list of the signal emission. The first element in the array is a Value for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal.returnValue: Location for the return value.Calls the original class closure of a signal. This function should only be called from an overridden class closure; see signalOverrideClassClosure and g_signal_override_class_handler().signalConnectClosure Source #instance: the instance to connect to.detailedSignal: a string of the form "signal-name::detail".closure: the closure to connect.after: whether the handler should be called before or after the default handler of the signal.Returns: the handler ID (always greater than 0 for successful connections)signalConnectClosureById Source #signalId: the id of the signal.detail: the detail.signalEmitv Source #instanceAndParams: argument list for the signal emission. The first element in the array is a Value for the instance the signal is being emitted on. The rest are any arguments to be passed to the signal.signalId: the signal iddetail: the detailNote that signalEmitv doesn't change returnValue if no handlers are connected, in contrast to g_signal_emit() and g_signal_emit_valist().signalGetInvocationHint Source #instance: the instance to query-> m SignalInvocationHintReturns: the invocation hint of the innermost signal emission.signalHandlerBlock Source #instance: The instance to block the signal handler of.handlerId: Handler id of the handler to be blocked.The handlerId has to be a valid signal handler id, connected to a signal of instance.signalHandlerDisconnect Source #instance: The instance to remove the signal handler from.handlerId: Handler id of the handler to be disconnected.Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The handlerId becomes invalid and may be reused.signalHandlerFind Source #instance: The instance owning the signal handler to be found.-> [SignalMatchType]mask: Mask indicating which of signalId, detail, closure, func and/or data the handler has to match.signalId: Signal the handler has to be connected to.detail: Signal detail the handler has to be connected to.closure: The closure the handler will invoke.func: The C closure callback of the handler (useless for non-C closures).data: The closure data of the handler's closure.Returns: A valid non-0 signal handler id for a successful match.Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. The match mask has to be non-0 for successful matches. If no handler was found, 0 is returned.signalHandlerIsConnected Source #instance: The instance where a signal handler is sought.handlerId: the handler ID.Returns: whether handlerId identifies a handler connected to instance.Returns whether handlerId is the ID of a handler connected to instance.signalHandlerUnblock Source #instance: The instance to unblock the signal handler of.handlerId: Handler id of the handler to be unblocked.Undoes the effect of a previous signalHandlerBlock call. A blocked handler is skipped during signal emissions and will not be invoked, unblocking it (for exactly the amount of times it has been blocked before) reverts its "blocked" state, so the handler will be recognized by the signal system and is called upon future or currently ongoing signal emissions (since the order in which handlers are called during signal emissions is deterministic, whether the unblocked handler in question is called as part of a currently ongoing emission depends on how far that emission has proceeded yet).The handlerId has to be a valid id of a signal handler that is connected to a signal of instance and is currently blocked.signalHandlersBlockMatched Source #instance: The instance to block handlers from.mask: Mask indicating which of signalId, detail, closure, func and/or data the handlers have to match.signalId: Signal the handlers have to be connected to.detail: Signal detail the handlers have to be connected to.closure: The closure the handlers will invoke.func: The C closure callback of the handlers (useless for non-C closures).data: The closure data of the handlers' closures.Returns: The number of handlers that matched.Blocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of blocked handlers otherwise.signalHandlersDestroy Source #instance: The instance whose signal handlers are destroyedDestroy all signal handlers of a type instance. This function is an implementation detail of the Object dispose implementation, and should not be used outside of the type system.signalHandlersDisconnectMatched Source #instance: The instance to remove handlers from.Disconnects all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of disconnected handlers otherwise.signalHandlersUnblockMatched Source #instance: The instance to unblock handlers from.Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of unblocked handlers otherwise. The match criteria should not apply to any handlers that are not currently blocked.signalHasHandlerPending Source #instance: the object whose signal handlers are sought.signalId: the signal id.mayBeBlocked: whether blocked handlers should count as match.Returns: True if a handler is connected to the signal, False otherwise.signalListIds Source #itype: Instance or interface type.-> m [Word32]Returns: Newly allocated array of signal IDs.Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through signalQuery.signalLookup Source #name: the signal's name.itype: the type that the signal operates on.Returns: the signal's identifying number, or 0 if no signal was found.signalName Source #signalId: the signal's identifying number.Returns: the signal name, or Nothing if the signal number was invalid.signalOverrideClassClosure Source #instanceType: the instance type on which to override the class closure for the signal.classClosure: the closure.Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of instanceType. instanceType must be derived from the type to which the signal belongs.See signalChainFromOverridden and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one.signalParseName Source #itype: The interface/instance type that introduced "signal-name".forceDetailQuark: True forces creation of a GQuark for the detail.Returns: Whether the signal name could successfully be parsed and signalIdP and detailP contain valid return values.Internal function to parse a signal name into its signalId and detail quark.signalQuery Source #signalId: The signal id of the signal to query information for.-> m SignalQueryQueries the signal system for in-depth information about a specific signal. This function will fill in a user-provided structure to hold signal-specific information. If an invalid signal id is passed in, the signalId member of the SignalQuery is 0. All members filled into the SignalQuery structure should be considered constant and have to be left untouched.signalRemoveEmissionHook Source #signalId: the id of the signalhookId: the id of the emission hook, as returned by signalAddEmissionHooksignalStopEmission Source #instance: the object whose signal handlers you wish to stop.detail: the detail which the signal was emitted with.This will prevent the default method from running, if the signal was SignalFlagsRunLast and you connected normally (i.e. without the "after" flag).signalStopEmissionByName Source #This is just like signalStopEmission except it will look up the signal id for you.signalTypeCclosureNew Source #itype: the GType identifier of an interface or classed typestructOffset: the offset of the member function of itype's class structure which is to be invoked by the new closureReturns: a floating reference to a new CClosureCreates a new closure which invokes the function found at the offset structOffset in the class structure of the interface or classed type identified by itype.sourceSetClosure Source #Set the callback for a source as a Closure.If the source is not one of the standard GLib types, the closureCallback and closureMarshal fields of the SourceFuncs structure must have been filled in with pointers to appropriate functions.sourceSetDummyCallback Source #Sets a dummy callback for source. The callback will do nothing, and if the source expects a Bool return value, it will return True. (If the source expects any other type of return value, it will return a 0/Nothing value; whatever valueInit initializes a Value to for that type.)strdupValueContents Source #=> GValuevalue: Value which contents are to be described.Returns: Newly allocated string.Return a newly allocated string, which describes the contents of a Value. The main purpose of this function is to describe Value contents for debugging output, the way in which the contents are described may change between different GLib versions.typeAddClassPrivate Source #classType: GType of an classed typetypeAddInstancePrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m Int32 Source #typeAddInterfaceDynamic Source #:: (HasCallStack, MonadIO m, IsTypePlugin a)instanceType: GType value of an instantiable typeinterfaceType: GType value of an interface typeplugin: TypePlugin structure to retrieve the InterfaceInfo fromAdds the dynamic interfaceType to instantiableType. The information contained in the TypePlugin structure pointed to by plugin is used to manage the relationship.typeAddInterfaceStatic Source #-> InterfaceInfoinfo: InterfaceInfo structure for this (instanceType, interfaceType) combinationAdds the static interfaceType to instantiableType. The information contained in the InterfaceInfo structure pointed to by info is used to manage the relationship.typeCheckClassIsA :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m Bool Source #typeCheckInstance Source #=> TypeInstanceinstance: a valid TypeInstance structureReturns: True if instance is valid, False otherwisetypeCheckInstanceIsA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool Source #typeCheckInstanceIsFundamentallyA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool Source #typeCheckIsValueType :: (HasCallStack, MonadIO m) => GType -> m Bool Source #typeCheckValue :: (HasCallStack, MonadIO m) => GValue -> m Bool Source #typeCheckValueHolds :: (HasCallStack, MonadIO m) => GValue -> GType -> m Bool Source #typeChildren Source #type: the parent type-> m [GType]Returns: Newly allocated and 0-terminated array of child types, free with freetypeDefaultInterfacePeek Source #gType: an interface type-> m TypeInterfaceReturns: the default vtable for the interface, or Nothing if the type is not currently in useIf the interface type gType is currently in use, returns its default interface vtable.typeDefaultInterfaceRef Source #Returns: the default vtable for the interface; call typeDefaultInterfaceUnref when you are done using the interface.Increments the reference count for the interface type gType, and returns the default interface vtable for the type.If the type is not currently in use, then the default vtable for the type will be created and initalized by calling the base interface init and default vtable init functions for the type (the baseInit and classInit members of TypeInfo). Calling typeDefaultInterfaceRef is useful when you want to make sure that signals and properties for an interface have been installed.typeDefaultInterfaceUnref Source #gIface: the default vtable structure for a interface, as returned by typeDefaultInterfaceRefDecrements the reference count for the type corresponding to the interface default vtable gIface. If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the classFinalize member of TypeInfo) will be called.typeDepth Source #type: a GTypeReturns: the depth of typetypeEnsure Source #In theory, simply calling the type's _get_type() method (or using the corresponding macro) is supposed take care of this. However, _get_type() methods are often marked G_GNUC_CONST for performance reasons, even though this is technically incorrect (since G_GNUC_CONST requires that the function not have side effects, which _get_type() methods do on the first call). As a result, if you write a bare call to a _get_type() macro, it may get optimized out by the compiler. Using typeEnsure guarantees that the type's _get_type() method is called.typeFreeInstance Source #typeFromName Source #name: type name to lookupReturns: corresponding type ID or 0typeFundamental Source #typeId: valid type IDReturns: fundamental type IDtypeFundamentalNext Source #=> m GTypeReturns: the next available fundamental type ID to be registered, or 0 if the type system ran out of fundamental type IDsReturns the next free fundamental type id which can be used to register a new fundamental type with typeRegisterFundamental. The returned type ID represents the highest currently registered fundamental type identifier.typeGetInstanceCount Source #Returns: the number of instances allocated of the given type; if instance counts are not available, returns 0.typeGetPlugin Source #type: GType to retrieve the plugin for-> m TypePluginReturns: the corresponding plugin if type is a dynamic type, Nothing otherwiseReturns the TypePlugin structure for type.typeGetQdata Source #quark: a GQuark id to identify the dataReturns: the data, or Nothing if no data was foundObtains data which has previously been attached to type with typeSetQdata.Note that this does not take subtyping into account; data attached to one type with typeSetQdata cannot be retrieved from a subtype using typeGetQdata.typeGetTypeRegistrationSerial Source #Returns: An unsigned int, representing the state of type registrationsReturns an opaque serial number that represents the state of the set of registered types. Any time a type is registered this serial changes, which means you can cache information based on type lookups (such as typeFromName) and know if the cache is still valid at a later time by comparing the current serial with the one at the type lookup.typeInit :: (HasCallStack, MonadIO m) => m () Source #Deprecated: (Since version 2.36)the type system is now initialised automaticallytypeInitWithDebugFlags Source #=> [TypeDebugFlags]debugFlags: bitwise combination of TypeDebugFlags values for debugging purposestypeInterfaces Source #type: the type to list interface types forReturns: Newly allocated and 0-terminated array of interface types, free with freetypeIsA Source #type: type to check anchestry forisAType: possible anchestor of type or interface that type could conform toReturns: True if type is a isATypeIf isAType is a derivable type, check whether type is a descendant of isAType. If isAType is an interface, check whether type conforms to it.typeName Source #type: type to return name forReturns: static type name or NothingtypeNameFromClass :: (HasCallStack, MonadIO m) => TypeClass -> m Text Source #typeNameFromInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m Text Source #typeNextBase Source #leafType: descendant of rootType and the type to be returnedrootType: immediate parent of the returned typeReturns: immediate child of rootType and anchestor of leafTypeGiven a leafType and a rootType which is contained in its anchestry, return the type that rootType is the immediate parent of. In other words, this function determines the type that is derived directly from rootType which is also a base class of leafType. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type.typeParent Source #type: the derived typeReturns: the parent typetypeQname Source #type: type to return quark of type name forReturns: the type names quark or 0typeQuery Source #type: GType of a static, classed type-> m TypeQueryQueries the type system for information about a specific type. This function will fill in a user-provided structure to hold type-specific information. If an invalid GType is passed in, the type member of the TypeQuery is 0. All members filled into the TypeQuery structure should be considered constant and have to be left untouched.typeRegisterDynamic Source #parentType: type from which this type will be derivedtypeName: 0-terminated string used as the name of the new typeplugin: TypePlugin structure to retrieve the TypeInfo from-> [TypeFlags]flags: bitwise combination of TypeFlags valuesReturns: the new type identifier or G_TYPE_INVALID if registration failedRegisters typeName as the name of a new dynamic type derived from parentType. The type system uses the information contained in the TypePlugin structure pointed to by plugin to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type.typeRegisterFundamental Source #typeId: a predefined type identifier-> TypeInfoinfo: TypeInfo structure for this type-> TypeFundamentalInfofinfo: TypeFundamentalInfo structure for this typeReturns: the predefined type identifierRegisters typeId as the predefined identifier and typeName as the name of a fundamental type. If typeId is already registered, or a type named typeName is already registered, the behaviour is undefined. The type system uses the information contained in the TypeInfo structure pointed to by info and the TypeFundamentalInfo structure pointed to by finfo to manage the type and its instances. The value of flags determines additional characteristics of the fundamental type.typeRegisterStatic Source #Returns: the new type identifierRegisters typeName as the name of a new static type derived from parentType. The type system uses the information contained in the TypeInfo structure pointed to by info to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type.typeSetQdata Source #typeTestFlags :: (HasCallStack, MonadIO m) => GType -> Word32 -> m Bool Source #
