h,ߔ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                     0.26.8 Safe-Inferred/$R+""+R Safe-InferredU7The Haskell type corresponding to a gint on the C side.V9The Haskell type corresponding to a GQuark on the C side.W*The size in bytes of a GValue struct in C.XThe offset in bytes inside a GError of its domain field.YThe offset in bytes inside a GError of its code field.ZThe offset in bytes inside a GError of its emssage field.WYXZUVVUWXYZNone/18%\9A pointer to an equality checking function on the C side.].A pointer to a hashing function on the C side.^6Destroy the memory pointed to by a given pointer type._Some APIs, such as f, pass around scalar types wrapped into a pointer. We encode such a type as follows.bA  +https://docs.gtk.org/glib/struct.SList.htmlGSList?, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.dA  *https://docs.gtk.org/glib/struct.List.htmlGList?, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.fA  /https://docs.gtk.org/glib/struct.HashTable.html GHashTable. It is mapped to a  on the Haskell side.hA  /https://docs.gtk.org/glib/struct.ByteArray.html GByteArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is packed to a  on the Haskell side.jA  .https://docs.gtk.org/glib/struct.PtrArray.html GPtrArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions-, it is mapped to a list on the Haskell side.lA  +https://docs.gtk.org/glib/struct.Array.htmlGArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions-, it is mapped to a list on the Haskell side.n(An enum usable as a flag for a function.oA  1https://docs.gtk.org/gobject/class.ParamSpec.html GParamSpec. See Data.GI.Base.GParamSpec for further methods.qA  -https://docs.gtk.org/glib/struct.Variant.htmlGVariant. See Data.GI.Base.GVariant for further methods.sA common omission in the introspection data is missing (nullable) annotations for return types, when they clearly are nullable. (A common idiom is "Returns: valid value, or %NULL if something went wrong.")Haskell wrappers will raise this exception if the return value is an unexpected .v&A newtype for use on the Haskell side.yA type identifier in the GLib type system. This is the low-level type associated with the representation in memory, when using this on the Haskell side use v below.zFlags with an associated v.{Enums with an associated v.| A wrapped |*, or any other type that descends from it.}Chunks of memory whose allocation/deallocation info has been registered with the GLib type system.~A wrapped object that has an associated GLib type. This does not necessarily descend from |%, that constraint is implemented by | below.The v for this object.A ptr to a memory block which we know how to allocate and fill with zero.?Allocate a zero-initialized block of memory for the given type.Pointers to chunks of memory which we know how to copy and release.Make a copy of the given .6A pointer to a function for freeing the given pointer.?A constraint ensuring that the given type is a newtype over a .Thin wrapper over ", supporting the extra notion of  disowning, that is, not running the finalizers associated with the foreign ptr.When disowned, the  for the disowning call.' for the call that created the pointer.Free the given b.Free the given d.#Get the name assigned to the given v.A convenient synonym for Nothing :: Maybe GParamSpec.Two 0s are equal if they wrap the same underlying C .A default instance for  IsManagedPtr for newtypes over .4{zylm}hi^\]fgde|opjkbcvwxqrn_`a~stu4stu~|vwxyqr}{zoplmjkhifgdebcn_`a^]\None"/01*[A constraint on a type, to be fulfilled whenever it has a type instance for . This leads to nicer errors, thanks to the overlappable instance below.A proxy for carrying the types MethodInfoName needs (this is used for  , see below).$This is for debugging purposes, see  below.Information about a fully resolved symbol, for debugging purposes.Class for types containing the information about an overloaded method of type o -> s.Returned when the method is not found, hopefully making the resulting error messages somewhat clearer.A constraint that always fails with a type error, for documentation purposes.A constraint enforcing that the signal exists for the given object, or one of its ancestors.Return the type encoding the signal information for a given type and signal.The list of signals defined for a given type. Each element of the list is a tuple, with the first element of the tuple the name of the signal, and the second the type encoding the information of the signal. This type will be an instance of .A constraint that enforces that the given type has a given attribute.A constraint imposing that the given object has the given attribute.=Whether a given type is in the given list. If found, return success, otherwise return failure.Return the type encoding the attribute information for a given type and attribute.A constraint on a type, to be fulfilled whenever it has a type instance for *. This is here for nicer error reporting.The list of attributes defined for a given type. Each element of the list is a tuple, with the first element of the tuple the name of the attribute, and the second the type encoding the information of the attribute. This type will be an instance of .$Check that a type is in the list of  of another type.Check whether a type appears in a list. We specialize the names/types a bit so the error messages are more informative.All the types that are ascendants of this type, including interfaces that the type implements.Look in the given list of (symbol, tag) tuples for the tag corresponding to the given symbol. If not found raise the given type error./Safe coercions to a parent class. For instance: #show $ label `asA` Gtk.WidgetReturn the fully qualified method name that a given overloaded method call resolves to (mostly useful for debugging). resolveMethod widget #showDefault instance, which will give rise to an error for types without an associated  instance.Default instance, which will give rise to an error for types without an associated . The actual method being invoked.[[None"1 %Note: compile-time vs run-time GTypesNotice that there are two types of GType's: the fundamental ones, which are created with G_TYPE_MAKE_FUNDAMENTAL(n) and always have the same runtime representation, and the ones that are registered in the GObject type system at runtime, and whose y6 may change for each program run (and generally does).For the first type it is safe to use hsc to read the numerical values of the CGType at compile type, but for the second type it is essential to call the corresponding _get_type() function at runtime, and not use the value of the corresponding "constant" at compile time via hsc.v of strings.v of pointers.v for signed integers (gint or gint32).v for unsigned integers (guint or guint32).v for glong.v for gulong.v for signed 64 bit integers.v for unsigned 64 bit integers.v for floating point values.v for gdouble.v corresponding to gboolean.v! corresponding to a boxed object.v corresponding to a GObject. An invalid v> used as error return value in some functions which return a v.The v corresponding to a GVariant.The v corresponding to  .v corresponding to a v itself.v( for a NULL terminated array of strings.v for a boxed type holding a  GByteArray.The v for boxed  StablePtrs.The v for a generic Haskell value.The v corresponding to !.None2.Args are zero_terminated, clear_, element_size Allocate a l! with elements of the given size.None "/; Similar to , but accepts an additional (ignored) argument. The first argument is interpreted as a , and released. A pointer to .Same as freeHaskellFunPtr, but it does nothing when given a nullPtr. Pointer to g_free.A wrapper for g_free.When the given value is of "Just a" form, execute the given action, otherwise do nothing.Like "#, but for actions on a monad, and with slightly different argument order.Check if the pointer is 6, and wrap it on a  accordingly.Given a function and a list of two-tuples, apply the function to every first element of the tuples.Same for the second element.Applicative version of .Applicative version of .Apply the given conversion action to the given pointer if it is non-NULL, otherwise return .Apply the given conversion action to the given function pointer if it is non-NULL, otherwise return .7Make a zero-filled allocation using the GLib allocator.Make a zero-filled allocation of enough size to hold the given  type, using the GLib allocator.Make a zero filled allocation of n bytes for a boxed object. The difference with a normal callocBytes is that the returned memory is allocated using whatever memory allocator g_boxed_copy uses, which in particular may well be different from a plain g_malloc. In particular g_slice_alloc is often used for allocating boxed objects, which are then freed using g_slice_free.)/Constraint on a obj/attr pair so that  is allowed.Constraints on a obj/attr pair so ) is possible, producing a value of type result.Constructors for the different operations allowed on an attribute.Assign a value to an attribute1Assign the result of an IO action to an attribute(Apply an update function to an attribute+Apply an IO update function to an attributeAssign a value to an attribute, allocating any necessary memory for representing the Haskell value as a C value. Note that it is the responsibility of the caller to make sure that the memory is freed when no longer used, otherwise there will be a memory leak. In the majority of cases you probably want to use  instead, which has no potential memory leaks (at the cost of sometimes requiring some explicit Haskell -> C marshalling).-Connect the given signal to a signal handler.Like ', but connect after the default signal.Constraint on a obj/value pair so that ) works on values of type value.Constraint on a obj/attr pair so that  works on values of type value.#A user friendly description of the $, useful when printing type errors.$Possible operations on an attribute.8It is possible to read the value of the attribute with .9It is possible to write the value of the attribute with .5It is possible to set the value of the attribute in ).It is possible to clear the value of the (nullable) attribute with .Check if the given element is a member, and if so raise the given error.Error to be raised when AttrConstruct is allowed, but an implementation has not been provided.Error to be raised when AttrSet is allowed, but an implementation has not been provided.Error to be raised when AttrGet is allowed, but an implementation has not been provided.Error to be raised when AttrClear is allowed, but an implementation has not been provided.Error to be raised when an operation is allowed, but an implementation has not been provided.Whether a given 2 is allowed on an attribute, given the info type.+Look in the given list to see if the given + is a member, if not return an error type.Pretty print a type, indicating the parent type that introduced the attribute, if different.Info describing an attribute.1The operations that are allowed on the attribute.Constraint on the type for which we are allowed to create/set/get the attribute.Type returned by ."Constraint on the value being set.Constraint on the value being set, with allocation allowed (see  below).#Type resulting from the allocation.Name of the attribute.$Type which introduces the attribute.%Get the value of the given attribute.Set the value of the given attribute, after the object having the attribute has already been created.(Set the value of the given attribute to NULL (for nullable attributes).Build a  * representing the attribute.Allocate memory as necessary to generate a settable type from the transfer type. This is useful for types which needs allocations for marshalling from Haskell to C, this makes the allocation explicit.Return some information about the overloaded attribute, useful for debugging. See & for how to access this conveniently.A proxy for attribute labels.+Set a number of properties for some object.,Get the value of an attribute for an object.Set a nullable attribute to NULL.Return the fully qualified attribute name that a given overloaded attribute resolves to (mostly useful for debugging). resolveAttr #sensitive button+,-./0'-1111None}A , which is simply an integer.)Construct a GQuark from the given string.None "%&+Information on a property of type `type gboolean` to be registered. A property name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a property name must be a letter. Names which violate these rules lead to undefined behaviour.When creating and looking up a property, either separator can be used, but they cannot be mixed. Using '-' is considerably more efficient and in fact required when using property names as detail strings for signals.Beyond the name, properties have two more descriptive strings associated with them, the nick, which should be suitable for use as a label for the property in a property editor, and the blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized."Information on a property of type  to be registered. A property name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a property name must be a letter. Names which violate these rules lead to undefined behaviour.When creating and looking up a property, either separator can be used, but they cannot be mixed. Using '-' is considerably more efficient and in fact required when using property names as detail strings for signals.Beyond the name, properties have two more descriptive strings associated with them, the nick, which should be suitable for use as a label for the property in a property editor, and the blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized."Information on a property of type K to be registered. A property name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a property name must be a letter. Names which violate these rules lead to undefined behaviour.When creating and looking up a property, either separator can be used, but they cannot be mixed. Using '-' is considerably more efficient and in fact required when using property names as detail strings for signals.Beyond the name, properties have two more descriptive strings associated with them, the nick, which should be suitable for use as a label for the property in a property editor, and the blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized.Maximum value, or , which would be replaced by MAXINT.Minimum value, or , which would be replaced by MININT.Set of flags, or  for the default set of flags.8Handler that returns the current value of the property.0Handler invoked when the property is being set.Default value.Description of the property.#Identifier for display to the user.Identifier for the property.Information on a property encoding a Haskell value. Note that from the C side this property will appear as an opaque pointer. Use the specialized constructors below for creating properties meaningful from the C side.A property name consists of segments consisting of ASCII letters and digits, separated by either the '-' or '_' character. The first character of a property name must be a letter. Names which violate these rules lead to undefined behaviour.When creating and looking up a property, either separator can be used, but they cannot be mixed. Using '-' is considerably more efficient and in fact required when using property names as detail strings for signals.Beyond the name, properties have two more descriptive strings associated with them, the nick, which should be suitable for use as a label for the property in a property editor, and the blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized.Set of flags, or  for the default set of flags.8Handler that returns the current value of the property.0Handler invoked when the property is being set.Description of the property.#Identifier for display to the user.Identifier for the property.=The basic constructor for a GObject. They are all isomorphic.-Low-level getter and setter for the property.7Flags controlling the behaviour of the the parameters. the parameter is readable the parameter is writable 3the parameter will be set upon object construction 7the parameter can only be set upon object construction  calls to 23 for this property will not automatically result in a "notify" signal being emitted: the implementation must call 243 themselves in case the property actually changes. Catch-all for unknown values(Take ownership of a ParamSpec passed in .*Construct a Haskell wrapper for the given o, without assuming ownership. Remove a reference to the given o. Disown a o3, i.e. do not longer unref the associated foreign o when the Haskell o gets garbage collected.2Default set of flags when constructing properties.The 3 pointing to the setter and getter of the property.6Construct a copy of the object from the given pointer.4Wrap a Haskell getter/setter into a lower level one. Create a o for a Haskell value. Create a o for an integer param. Create a o for a string param. Create a o for a bool param.Set the given user data on the o. Get the user data for the given  on the o. IO () is a function that registers the callbacks in the interface, and -interfaceFinalize :: Maybe (Ptr () -> IO ()) is the (optional) finalizer.Wrapper around  GObjectClass on the C-side.Construct a GObject given the constructor and a list of settable attributes. See ) for a more general version.Construct the given |/, given a set of actions constructing desired s to set at construction time.Construct the | given the list of s. Find the v associated to a given . Find the v for a given |.!Register the given type into the GObject' type system and return the resulting v, if it has not been registered already. If the type has been registered already the existing v will be returned instead.Note that for this function to work the type must be an instance of . do log errorMessage return mssingImagePlaceholder)Catch all GErrors from a particular error domain. The handler function should just deal with one error enumeration type. If you need to catch errors from more than one error domain, use this function twice with an appropriate handler functions for each. catchGErrorJustDomain loadImage (\err message -> case err of PixbufErrorCorruptImage -> ... PixbufErrorInsufficientMemory -> ... PixbufErrorUnknownType -> ... _ -> ...) A verson of # with the arguments swapped around. A verson of # with the arguments swapped around.)Run the given function catching possible s in its execution. If a 5 is emitted this throws the corresponding exception.Like , but allows to specify a custom handler instead of just throwing the exception.If the passed in   is not , store a copy in the passed in pointer, unless the pointer is 6.2s are registered as boxed in the GLib type system.*There are no types in the bindings that a  can be safely cast to.This must not use the value of its parameter so that it is safe to pass $.The error to catchThe computation to run,Handler to invoke if an exception is raisedThe computation to run+Handler to invoke if an exception is raisedNone[(%'&2PSN5#$8967T MQ 43OABCDKL?@GHIJ=>EF;<: -., {zylm}hi^\]fgde|opjkbcvwxqrn_`a~stu '2T=>?@ABCDEFGHIJKLO6789:;<5P 43 ,-./01  ! )*(%S $#MQN&NoneK)Set a property on an object to the given .A convenience wrapper over + that does the wrapping of a value into a .Get the  for the given property.A convenience wrapper over  that unwraps the  into a Haskell value.!Set a property for a type with a  instance.'Construct a property for a type with a  instance.*Get a nullable property for a type with a  instance.Set a property of type .Construct a property of type .$Get the value of a property of type .Set a property of type .Construct a property of type .$Get the value of a property of type .Construct a property of type o.Get a property of type o.Set a property of type o.;None{zylm}hi^\]fgde|opjkbcvwxqrn_`a~stu<=><=?<=@ABC<=D<=E<=F>=>>returnGHC.Internal.Real fromIntegral realToFracGHC.Internal.EnumEnumEqMonadGHC.Internal.ShowShow GHC.TypesBoolCharDoubleFloatGHC.Internal.MaybeMaybe~IOGHC.Internal.WordWord8Word16Word32Word64GHC.Internal.PtrPtrFunPtrGHC.Internal.Stack.Types CallStackSymbolNothingJustGHC.Internal.ForeignPtr ForeignPtr/=$dm==$dm/= HasCallStackGHC.Internal.Errerror undefined=<<whenord.$dm>> $dmreturnGHC.Internal.StackprettyCallStack showsPrecshowshowList $dmshowsPrec$dmshow $dmshowListGHC.Internal.CharchrtoEnumfromEnumGHC.Internal.Data.Functor<$>plusPtrcastFunPtrToPtrcastPtrToFunPtrGHC.Internal.Foreign.StorablesizeOfpeekpokeGHC.Internal.Foreign.C.TypesCUIntPtrCIntPtrCDoubleCFloatCULongCLongCUIntGHC.Internal.Data.FoldablelengthmapM_&GHC.Internal.Foreign.C.String.EncodingCString#GHC.Internal.Control.Exception.Base onExceptionGHC.Internal.Data.TraversablemapM callStackGHC.Internal.Control.Monad>=>bytestring-0.11.5.3-e682c795d56ad64c1f7c5ce2f6a69507a9f59830c5d190049540fd229fa2f867Data.ByteString.Internal.TypeC_gintGQuark cgvalueSizegerror_domain_offsetgerror_code_offsetgerror_message_offsetHasParentTypes GEqualFunc GHashFuncGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlagGVariantUnexpectedNullPointerReturnnullPtrErrorMsgGType gtypeToCGTypeCGType BoxedFlags BoxedEnumGObjectGBoxed TypedObjectglibType CallocPtrboxedPtrCallocBoxedPtr boxedPtrCopy boxedPtrFreeManagedPtrNewtype toManagedPtr ManagedPtrmanagedPtrIsDisownedmanagedPtrAllocCallStackmanagedForeignPtr g_slist_free g_list_free gtypeName noGParamSpec$fEqManagedPtr$fManagedPtrNewtypea&$fExceptionUnexpectedNullPointerReturn!$fShowUnexpectedNullPointerReturn $fEqGType $fShowGType MethodProxyOverloadedMethodInfooverloadedMethodInfoResolvedSymbolInforesolvedSymbolURLresolvedSymbolNameOverloadedMethodoverloadedMethodMethodResolutionFailedUnsupportedMethodError HasSignal ResolveSignal SignalListHasAttr HasAttributeResolveAttributeHasAttributeList AttributeListIsDescendantOf ParentTypesasA resolveMethod$fHasParentTypesa$fHasAttributeListka$fHasAttrattro$fShowResolvedSymbolInfo gtypeString gtypePointergtypeInt gtypeUInt gtypeLong gtypeULong gtypeInt64 gtypeUInt64 gtypeFloat gtypeDouble gtypeBoolean gtypeBoxed gtypeObject gtypeInvalid gtypeVariant gtypeParam gtypeGType gtypeStrvgtypeByteArraygtypeStablePtr gtypeHValue gtypeError allocGArraysafeFreeFunPtrPtr'safeFreeFunPtrPtrsafeFreeFunPtr ptr_to_g_freefreeMemwhenJustmaybeM maybeFromPtrmapFirst mapSecond mapFirstA mapSecondAconvertIfNonNullconvertFunPtrIfNonNull callocBytes callocMemcallocBoxedBytes allocBytesallocMemmemcpymaybeReleaseFunPtrcheckUnexpectedReturnNULLcheckUnexpectedNothingdbgLog newManagedPtrnewManagedPtr'newManagedPtr_disownManagedPtrwithManagedPtrmaybeWithManagedPtrwithManagedPtrList withTransientunsafeManagedPtrGetPtrunsafeManagedPtrCastPtrtouchManagedPtrcheckInstanceTypecastTo unsafeCastTo newObject withNewObject wrapObject releaseObject unrefObject disownObjectnewBoxed wrapBoxed copyBoxed copyBoxedPtr freeBoxed disownBoxedwrapPtrnewPtr copyBytesGClosure noGClosure newGClosurewrapGClosurePtrnewGClosureFromPtr unrefGClosuredisownGClosure$fGBoxedGClosure$fTypedObjectGClosure$fHasParentTypesGClosureunrefGHashTableunrefGByteArray unrefPtrArray unrefGArray gflagsToWord wordToGFlags packGList unpackGList packGSList unpackGSList packGArray unpackGArray packGPtrArrayunpackGPtrArraypackGByteArrayunpackGByteArraypackGHashTableunpackGHashTablepackByteStringpackZeroTerminatedByteStringunpackByteStringWithLengthunpackZeroTerminatedByteStringpackStorableArraypackZeroTerminatedStorableArrayunpackStorableArrayWithLength!unpackZeroTerminatedStorableArraypackMapStorableArray"packMapZeroTerminatedStorableArray unpackMapStorableArrayWithLength$unpackMapZeroTerminatedStorableArraypackUTF8CArraypackZeroTerminatedUTF8CArrayunpackZeroTerminatedUTF8CArrayunpackUTF8CArrayWithLengthpackFileNameArraypackZeroTerminatedFileNameArray!unpackZeroTerminatedFileNameArrayunpackFileNameArrayWithLengthstringToCStringcstringToString textToCStringwithTextCString cstringToTextbyteStringToCStringcstringToByteString packPtrArraypackZeroTerminatedPtrArrayunpackPtrArrayWithLengthunpackZeroTerminatedPtrArraymapZeroTerminatedCArraypackBlockArrayunpackBlockArrayWithLengthunpackBoxedArrayWithLengthmapCArrayWithLength mapGArray mapPtrArraymapGList mapGSListGVariantDictEntryGVariantSignatureGVariantObjectPathGVariantHandleGVariantSingletIsGVariantBasicType IsGVariant toGVariant fromGVarianttoGVariantFormatString noGVariantgvariantGetTypeStringwrapGVariantPtrnewGVariantFromPtr unrefGVariantdisownGVariantgvariantFromBoolgvariantToBoolgvariantFromWord8gvariantToWord8gvariantFromInt16gvariantToInt16gvariantFromWord16gvariantToWord16gvariantFromInt32gvariantToInt32gvariantFromWord32gvariantToWord32gvariantFromInt64gvariantToInt64gvariantFromWord64gvariantToWord64gvariantFromHandlegvariantToHandlegvariantFromDoublegvariantToDoublegvariantToTextgvariantFromTextnewGVariantObjectPathgvariantObjectPathToTextgvariantFromObjectPathgvariantToObjectPathnewGVariantSignaturegvariantSignatureToTextgvariantFromSignaturegvariantToSignaturegvariantFromGVariantgvariantToGVariantgvariantToBytestringgvariantFromBytestringgvariantFromMaybegvariantToMaybegvariantFromDictEntrygvariantToDictEntrygvariantFromMap gvariantToMapgvariantFromListgvariantToListgvariantFromTuplegvariantToTuple$fIsGVariantTuple5$fIsGVariantTuple4$fIsGVariantTuple3$fIsGVariantTuple2$fIsGVariantUnit$fIsGVariantList$fIsGVariantMaybe$fIsGVariantByteString$fIsGVariantGVariant$fIsGVariantText$fIsGVariantDouble$fIsGVariantWord64$fIsGVariantInt64$fIsGVariantWord32$fIsGVariantInt32$fIsGVariantWord16$fIsGVariantInt16$fIsGVariantWord8$fIsGVariantBool$fIsGVariantMap$fIsGVariantBasicTypeText$fIsGVariantBasicTypeDouble$fIsGVariantBasicTypeWord64$fIsGVariantBasicTypeInt64$fIsGVariantBasicTypeWord32$fIsGVariantBasicTypeInt32$fIsGVariantBasicTypeWord16$fIsGVariantBasicTypeInt16$fIsGVariantBasicTypeWord8$fIsGVariantBasicTypeBool$fIsGVariantGVariantSinglet#$fIsGVariantBasicTypeGVariantHandle$fIsGVariantGVariantHandle'$fIsGVariantBasicTypeGVariantObjectPath$fIsGVariantGVariantObjectPath&$fIsGVariantBasicTypeGVariantSignature$fIsGVariantGVariantSignature$fIsGVariantGVariantDictEntry$fEqGVariantDictEntry$fShowGVariantDictEntry$fOrdGVariantSignature$fEqGVariantSignature$fShowGVariantSignature$fOrdGVariantObjectPath$fEqGVariantObjectPath$fShowGVariantObjectPath$fEqGVariantHandle$fOrdGVariantHandle$fShowGVariantHandle$fEqGVariantSinglet$fShowGVariantSingletHValueNoHValueIsGValue gvalueGType_ gvalueSet_ gvalueGet_GValueConstruct get_flags set_flagsget_enumset_enum get_variant set_variant get_boxed set_boxedptr_to_gvalue_free newGValue wrapGValuePtrnewGValueFromPtr buildGValue disownGValue gvalueType unsetGValuenoGValuetoGValue fromGValue set_object get_object set_stablePtrtake_stablePtr get_stablePtrpackGValueArrayunpackGValueArrayWithLengthmapGValueArrayWithLength set_param get_param set_hvalue get_hvalue$fGBoxedGValue$fTypedObjectGValue$fHasParentTypesGValue$fIsGValueMaybe$fIsGValueStablePtr$fIsGValueGType$fIsGValueBool$fIsGValueDouble$fIsGValueFloat$fIsGValueWord64$fIsGValueInt64$fIsGValueCULong$fIsGValueCLong$fIsGValueCUInt$fIsGValueCInt$fIsGValueWord32$fIsGValueInt32 $fIsGValuePtr$fIsGValueMaybe0$fIsGValueMaybe1$fIsGValueHValue $fShowHValue $fEqHValue gStrEqualgStrHash gDirectEqual gDirectHash ptrPackPtr ptrUnpackPtrcstringPackPtrcstringUnpackPtr gvaluePackPtrgvalueUnpackPtrgQuarkFromStringGBooleanPropertyInfogettersetterflags defaultValueblurbnicknameCStringPropertyInfoCIntPropertyInfomaxValueminValue PropertyInfo PropGetSetter propSetter propGetter GParamFlagGParamReadableGParamWritableGParamConstructGParamConstructOnlyGParamExplicitNotifyAnotherGParamFlagwrapGParamSpecPtrnewGParamSpecFromPtrunrefGParamSpecdisownGParamSpecgParamSpecValuegParamSpecCIntgParamSpecCStringgParamSpecGBooleangetGParamSpecGetterSetter$fIsGFlagGParamFlag$fOrdGParamFlag$fEnumGParamFlag$fShowGParamFlag$fEqGParamFlagSignalHandlerId SignalProxyHaskellCallbackType connectSignal dbgSignalInfoSignalConnectModeSignalConnectBeforeSignalConnectAfterafteron AttrClearCAttrGetCAttrOp:=:=>:~:~>:&=OnAfterAttrConstructCAttrSetC AttrOpTagAttrGetAttrSet AttrConstruct AttrClear AttrOpAllowedAttrAllowedOpsAttrBaseTypeConstraint AttrGetTypeAttrSetTypeConstraintAttrTransferTypeConstraintAttrTransferType AttrLabel AttrOriginattrGetattrSet attrClear attrConstruct attrTransfer dbgAttrInfoAttrLabelProxysetgetclear resolveAttr$fIsLabelxAttrLabelProxy $fEqAttrOpTag$fOrdAttrOpTag$fEnumAttrOpTag$fBoundedAttrOpTag$fShowAttrOpTagSignalCodeGenErrorGObjectNotifySignalInfo:::PropertyNotifyconnectSignalFunPtrdisconnectSignalHandler resolveSignal$fIsLabelslotSignalProxy#$fSignalInfoGObjectNotifySignalInfoDerivedGObjectGObjectParentTypeGObjectPrivateDataobjectTypeNameobjectClassInitobjectInstanceInitobjectInterfaces GObjectClassconstructGObjectnew'gtypeFromClassgtypeFromInstance registerGTypegobjectGetPrivateDatagobjectGetUserDatagobjectSetUserDatagobjectModifyUserDatagobjectSetPrivateDatagobjectModifyPrivateDatagobjectInstallPropertygobjectInstallCIntPropertygobjectInstallCStringPropertygobjectInstallGBooleanProperty Constructible$fConstructibleatag GErrorClassgerrorClassDomain GErrorMessage GErrorCode GErrorDomain gerrorNew gerrorDomain gerrorCode gerrorMessagecatchGErrorJustcatchGErrorJustDomainhandleGErrorJusthandleGErrorJustDomainpropagateGError checkGErrormaybePokeGError$fGBoxedGError$fTypedObjectGError$fHasParentTypesGError$fExceptionGError $fShowGError!setObjectPropertyIsGValueInstance'constructObjectPropertyIsGValueInstance!getObjectPropertyIsGValueInstancesetObjectPropertyStringconstructObjectPropertyStringgetObjectPropertyStringsetObjectPropertyPtrconstructObjectPropertyPtrgetObjectPropertyPtrsetObjectPropertyIntconstructObjectPropertyIntgetObjectPropertyIntsetObjectPropertyUIntconstructObjectPropertyUIntgetObjectPropertyUIntsetObjectPropertyLongconstructObjectPropertyLonggetObjectPropertyLongsetObjectPropertyULongconstructObjectPropertyULonggetObjectPropertyULongsetObjectPropertyInt32constructObjectPropertyInt32getObjectPropertyInt32setObjectPropertyUInt32constructObjectPropertyUInt32getObjectPropertyUInt32setObjectPropertyInt64constructObjectPropertyInt64getObjectPropertyInt64setObjectPropertyUInt64constructObjectPropertyUInt64getObjectPropertyUInt64setObjectPropertyFloatconstructObjectPropertyFloatgetObjectPropertyFloatsetObjectPropertyDoubleconstructObjectPropertyDoublegetObjectPropertyDoublesetObjectPropertyBoolconstructObjectPropertyBoolgetObjectPropertyBoolsetObjectPropertyGTypeconstructObjectPropertyGTypegetObjectPropertyGTypesetObjectPropertyObjectconstructObjectPropertyObjectgetObjectPropertyObjectsetObjectPropertyBoxedconstructObjectPropertyBoxedgetObjectPropertyBoxedsetObjectPropertyStringArray"constructObjectPropertyStringArraygetObjectPropertyStringArraysetObjectPropertyEnumconstructObjectPropertyEnumgetObjectPropertyEnumsetObjectPropertyFlagsconstructObjectPropertyFlagsgetObjectPropertyFlagssetObjectPropertyClosureconstructObjectPropertyClosuregetObjectPropertyClosuresetObjectPropertyVariantconstructObjectPropertyVariantgetObjectPropertyVariantsetObjectPropertyByteArray constructObjectPropertyByteArraygetObjectPropertyByteArraysetObjectPropertyPtrGListconstructObjectPropertyPtrGListgetObjectPropertyPtrGListsetObjectPropertyHashconstructObjectPropertyHashgetObjectPropertyHashsetObjectPropertyCallbackconstructObjectPropertyCallbackgetObjectPropertyCallbacksetObjectPropertyGErrorconstructObjectPropertyGErrorgetObjectPropertyGErrorsetObjectPropertyGValueconstructObjectPropertyGValuegetObjectPropertyGValue constructObjectPropertyParamSpecgetObjectPropertyParamSpecsetObjectPropertyParamSpecIsElemCheckForAncestorType FindElement g_array_newStorabledbg_g_object_disownownedFinalizerprintAllocDebug FinalizerPtrnotOwnedWarningnullPtrWarning dbgDeallocD:R:ParentTypesGClosuretext-2.1.1-0991e8349455bfbefd0cceb458d9970e70be4756698daba914831eb8bdcc57aaData.Text.InternalTextGHC.Internal.IntInt32safe_get_boxed_hvalueGHC.Internal.Stable StablePtrD:R:ParentTypesGValue AttrOpText CheckNotElemConstructNotProvidedErrorSetNotProvidedErrorGetNotProvidedErrorClearNotProvidedErrorOpNotProvidedErrorAttrOpIsAllowedTypeOriginInfoGObjectConstructor defaultFlags pspecQuark objectFromPtr wrapGetSetgParamSpecSetQDatagParamSpecGetQDataGObjectNotifyCallback proxyDetailconnectGObjectNotifydoConstructGObject privateKeyinstanceSetUserDatainstanceSetPrivateDatagErrorQuarkFromDomainD:R:ParentTypesGErrorunsafeForeignPtrToPtrbaseControl.Monad.IO.ClassMonadIOliftIOInt16Int64Int8IntgobjectSetPropertysetObjectPropertygobjectGetPropertygetObjectProperty