h)Q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                            0.26.3 Safe-Inferred/$JP$JP Safe-InferredUhaskell-gi-base7The Haskell type corresponding to a gint on the C side.Vhaskell-gi-base9The Haskell type corresponding to a GQuark on the C side.Whaskell-gi-base*The size in bytes of a GValue struct in C.Xhaskell-gi-baseThe offset in bytes inside a GError of its domain field.Yhaskell-gi-baseThe offset in bytes inside a GError of its code field.Zhaskell-gi-baseThe offset in bytes inside a GError of its emssage field.VUWXYZVUWXYZ Safe-Inferred/16!%\haskell-gi-base9A pointer to an equality checking function on the C side.]haskell-gi-base.A pointer to a hashing function on the C side.^haskell-gi-base6Destroy the memory pointed to by a given pointer type._haskell-gi-baseSome APIs, such as f, pass around scalar types wrapped into a pointer. We encode such a type as follows.bhaskell-gi-baseA  https://developer.gnome.org/glib/stable/glib-Singly-Linked-Lists.htmlGSList?, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.dhaskell-gi-baseA  https://developer.gnome.org/glib/stable/glib-Doubly-Linked-Lists.htmlGList?, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.fhaskell-gi-baseA  =https://developer.gnome.org/glib/stable/glib-Hash-Tables.html GHashTable. It is mapped to a  on the Haskell side.hhaskell-gi-baseA  =https://developer.gnome.org/glib/stable/glib-Byte-Arrays.html GByteArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is packed to a  on the Haskell side.jhaskell-gi-baseA  https://developer.gnome.org/glib/stable/glib-Pointer-Arrays.html GPtrArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions-, it is mapped to a list on the Haskell side.lhaskell-gi-baseA  8https://developer.gnome.org/glib/stable/glib-Arrays.htmlGArray'. Marshalling for this type is done in Data.GI.Base.BasicConversions-, it is mapped to a list on the Haskell side.nhaskell-gi-base(An enum usable as a flag for a function.ohaskell-gi-baseA  https://developer.gnome.org/gobject/stable/gobject-GParamSpec.html GParamSpec. See Data.GI.Base.GParamSpec for further methods.qhaskell-gi-baseA  :https://developer.gnome.org/glib/stable/glib-GVariant.htmlGVariant. See Data.GI.Base.GVariant for further methods.shaskell-gi-baseA 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 .vhaskell-gi-base&A newtype for use on the Haskell side.yhaskell-gi-baseA 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.zhaskell-gi-baseFlags with an associated v.{haskell-gi-baseEnums with an associated v.|haskell-gi-base A wrapped |*, or any other type that descends from it.}haskell-gi-baseChunks of memory whose allocation/deallocation info has been registered with the GLib type system.~haskell-gi-baseA wrapped object that has an associated GLib type. This does not necessarily descend from |%, that constraint is implemented by | below.haskell-gi-baseThe v for this object.haskell-gi-baseA ptr to a memory block which we know how to allocate and fill with zero.haskell-gi-base?Allocate a zero-initialized block of memory for the given type.haskell-gi-basePointers to chunks of memory which we know how to copy and release.haskell-gi-baseMake a copy of the given .haskell-gi-base6A pointer to a function for freeing the given pointer.haskell-gi-base?A constraint ensuring that the given type is a newtype over a .haskell-gi-baseThin wrapper over "", supporting the extra notion of  disowning, that is, not running the finalizers associated with the foreign ptr.haskell-gi-base' for the call that created the pointer.haskell-gi-baseWhen disowned, the  for the disowning call.haskell-gi-baseFree the given b.haskell-gi-baseFree the given d.haskell-gi-base#Get the name assigned to the given v.haskell-gi-baseA convenient synonym for Nothing :: Maybe GParamSpec.haskell-gi-baseTwo 0s are equal if they wrap the same underlying C .haskell-gi-baseA default instance for  IsManagedPtr for newtypes over .4stu~|vwxyqr}{zoplmjkhifgdebcn_`a^]\4stu~|vwxyqr}{zoplmjkhifgdebcn_`a^]\ Safe-Inferred"/01/q[haskell-gi-baseA 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.haskell-gi-baseA proxy for carrying the types MethodInfoName needs (this is used for  , see below).haskell-gi-base$This is for debugging purposes, see  below.haskell-gi-baseInformation about a fully resolved symbol, for debugging purposes.haskell-gi-baseClass for types containing the information about an overloaded method of type o -> s.haskell-gi-baseReturned when the method is not found, hopefully making the resulting error messages somewhat clearer.haskell-gi-baseA constraint that always fails with a type error, for documentation purposes.haskell-gi-baseA constraint enforcing that the signal exists for the given object, or one of its ancestors.haskell-gi-baseReturn the type encoding the signal information for a given type and signal.haskell-gi-baseThe 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 .haskell-gi-baseA constraint that enforces that the given type has a given attribute.haskell-gi-baseA constraint imposing that the given object has the given attribute.haskell-gi-base=Whether a given type is in the given list. If found, return success, otherwise return failure.haskell-gi-baseReturn the type encoding the attribute information for a given type and attribute.haskell-gi-baseA constraint on a type, to be fulfilled whenever it has a type instance for *. This is here for nicer error reporting.haskell-gi-baseThe 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 .haskell-gi-base$Check that a type is in the list of  of another type.haskell-gi-baseCheck whether a type appears in a list. We specialize the names/types a bit so the error messages are more informative.haskell-gi-baseAll the types that are ascendants of this type, including interfaces that the type implements.haskell-gi-baseLook in the given list of (symbol, tag) tuples for the tag corresponding to the given symbol. If not found raise the given type error.haskell-gi-base/Safe coercions to a parent class. For instance: #show $ label `asA` Gtk.Widgethaskell-gi-baseReturn the fully qualified method name that a given overloaded method call resolves to (mostly useful for debugging). resolveMethod widget #showhaskell-gi-baseDefault instance, which will give rise to an error for types without an associated  instance.haskell-gi-baseDefault instance, which will give rise to an error for types without an associated .haskell-gi-base The actual method being invoked.[[None"7vhaskell-gi-base %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.haskell-gi-basev of pointers.haskell-gi-basev for signed integers (gint or gint32).haskell-gi-basev for unsigned integers (guint or guint32).haskell-gi-basev for glong.haskell-gi-basev for gulong.haskell-gi-basev for signed 64 bit integers.haskell-gi-basev for unsigned 64 bit integers.haskell-gi-basev for floating point values.haskell-gi-basev for gdouble.haskell-gi-basev corresponding to gboolean.haskell-gi-basev! corresponding to a boxed object.haskell-gi-basev corresponding to a GObject.haskell-gi-base An invalid v> used as error return value in some functions which return a v.haskell-gi-baseThe v corresponding to a GVariant.haskell-gi-baseThe v corresponding to  .haskell-gi-baseThe v corresponding to !.haskell-gi-basev corresponding to a v itself.haskell-gi-basev( for a NULL terminated array of strings.haskell-gi-basev for a boxed type holding a  GByteArray.haskell-gi-baseThe v for boxed  StablePtrs. Safe-Inferred8haskell-gi-base.Args are zero_terminated, clear_, element_sizehaskell-gi-base Allocate a l! with elements of the given size. Safe-Inferred "/Cwhaskell-gi-base Similar to , but accepts an additional (ignored) argument. The first argument is interpreted as a , and released.haskell-gi-base A pointer to .haskell-gi-baseSame as freeHaskellFunPtr, but it does nothing when given a nullPtr.haskell-gi-base Pointer to g_free.haskell-gi-baseA wrapper for g_free.haskell-gi-baseWhen the given value is of "Just a" form, execute the given action, otherwise do nothing.haskell-gi-baseLike "#, but for actions on a monad, and with slightly different argument order.haskell-gi-baseCheck if the pointer is 1, and wrap it on a  accordingly.haskell-gi-baseGiven a function and a list of two-tuples, apply the function to every first element of the tuples.haskell-gi-baseSame for the second element.haskell-gi-baseApplicative version of .haskell-gi-baseApplicative version of .haskell-gi-baseApply the given conversion action to the given pointer if it is non-NULL, otherwise return  .haskell-gi-baseApply the given conversion action to the given function pointer if it is non-NULL, otherwise return  .haskell-gi-base7Make a zero-filled allocation using the GLib allocator.haskell-gi-baseMake a zero-filled allocation of enough size to hold the given  type, using the GLib allocator.haskell-gi-baseMake 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.haskell-gi-basehttps://developer.gnome.org/glib/stable/glib-GVariantType.html1 for the meaning of the resulting format string.haskell-gi-baseTake ownership of a passed in  (typically created just for us, so if it is floating we sink it).haskell-gi-base*Construct a Haskell wrapper for the given q, without assuming ownership.haskell-gi-base Remove a reference to the given q.haskell-gi-base Disown a q, i.e. do not unref the underlying object when the Haskell object is garbage collected.haskell-gi-baseConvert a DBus handle (an  ) into a q.haskell-gi-baseExtract the DBus handle (an  ) inside a q.haskell-gi-baseDecode an UTF-8 encoded string q into .haskell-gi-base Encode a  into an UTF-8 encoded string q.haskell-gi-baseTry to construct a DBus object path. If the passed string is not a valid object path   will be returned.haskell-gi-base Return the  representation of a .haskell-gi-base Construct a q1 containing an object path. In order to build a  value see .haskell-gi-base Extract a  from a q!, represented as its underlying  representation.haskell-gi-baseTry to construct a DBus object path. If the passed string is not a valid DBus signature   will be returned.haskell-gi-base Return the  representation of a .haskell-gi-base Construct a q4 containing an DBus signature. In order to build a  value see .haskell-gi-base Extract a  from a q, represented as .haskell-gi-baseBox a q inside another q.haskell-gi-baseUnbox a q contained inside another q.haskell-gi-base/Extract a zero terminated list of bytes into a T.haskell-gi-base Encode a T into a list of bytes q.haskell-gi-base Convert a  value into a corresponding q of maybe type.haskell-gi-baseTry to decode a maybe q into the corresponding 5 type. If the conversion is successful this returns Just x , where x itself is of  type. So, in particular,  Just Nothing indicates a successful call, and means that the GVariant of maybe type was empty.haskell-gi-base Construct a q" of type DictEntry from the given key and value. The key must be a basic q type, i.e. not a container. This is determined by whether it belongs to the  typeclass. On the other hand value is an arbitrary q/, and in particular it can be a container type.haskell-gi-base Unpack a DictEntry variant into key and value, which are returned as a two element tuple in case of success.haskell-gi-basePack a Map into a q1 for dictionary type, which is just an array of .haskell-gi-base Unpack a q into a 9. Notice that this assumes that all the elements in the q array of = are of the same type, which is not necessary for a generic q, so this is somewhat restrictive. For the general case it is necessary to use  plus  directly.haskell-gi-base%Given a list of elements construct a q array containing them.haskell-gi-base Unpack a q array into its elements.haskell-gi-baseGiven a list of q, construct a q, tuple containing the elements in the list.haskell-gi-baseExtract the children of a q tuple into a list.haskell-gi-base:The empty tuple GVariant, mostly useful for type checking.haskell-gi-baseOne element tuples.??  Safe-Inferred "1~haskell-gi-baseClass for types that can be marshaled back and forth between Haskell values and 7s. These are low-level methods, you might want to use  and ' instead for a higher level interface.haskell-gi-baseA type holding a  with an associated label. It is parameterized by a phantom type encoding the target type for the ' (useful when constructing properties).haskell-gi-base!Haskell-side representation of a GValue.haskell-gi-base(A pointer to a function freeing GValues.haskell-gi-baseBuild a new, empty,  of the given type.haskell-gi-baseTake ownership of a passed in .haskell-gi-base*Construct a Haskell wrapper for the given , making a copy.haskell-gi-baseA convenience function for building a new GValue and setting the initial value.haskell-gi-base Disown a , i.e. do not unref the underlying object when the Haskell object is garbage collected.haskell-gi-base Return the v contained by a .haskell-gi-base Unset the ), freeing all resources associated to it.haskell-gi-baseA convenient alias for Nothing :: Maybe GValue.haskell-gi-base Create a  from the given Haskell value.haskell-gi-base)Create a Haskell object out of the given .haskell-gi-baseSet the value of  containing a haskell-gi-baseLike  , but the  takes ownership of the haskell-gi-baseGet the value of a  containing a haskell-gi-base:Pack the given list of GValues contiguously into a C arrayhaskell-gi-base=Unpack an array of contiguous GValues into a list of GValues.haskell-gi-base Map over the s inside a C array.haskell-gi-baseSet the value of  containing a ohaskell-gi-baseGet the value of a  containing a ohaskell-gi-base2s are registered as boxed in the GLib type system.haskell-gi-baseFind the associated v for .haskell-gi-base*There are no types in the bindings that a  can be safely cast to.haskell-gi-basev for the ! containing values of this type.haskell-gi-baseSet the  to the given Haskell value.haskell-gi-base!Get the Haskel value inside the .%% Safe-Inferredz haskell-gi-baseCheck whether two L s are equal.haskell-gi-baseCompute the hash for a L.haskell-gi-base%Check whether two pointers are equal.haskell-gi-baseCompute the hash for a .haskell-gi-basePack a  into a _ .haskell-gi-base Extract a  from a _ .haskell-gi-basePack a L into a  than can go into a  GHashTable.haskell-gi-base Extract a L wrapped into a  coming from a  GHashTable.haskell-gi-basePack a  to  into a  than can go into a  GHashTable.haskell-gi-base Extract a  to  wrapped into a  coming from a  GHashTable. ]\ ]\ Safe-Inferred)*/01<d/haskell-gi-baseConstraint on a obj/attr pair so that  is allowed.haskell-gi-baseConstraints on a obj/attr pair so ) is possible, producing a value of type result.haskell-gi-baseConstructors for the different operations allowed on an attribute.haskell-gi-baseAssign a value to an attributehaskell-gi-base1Assign the result of an IO action to an attributehaskell-gi-base(Apply an update function to an attributehaskell-gi-base+Apply an IO update function to an attributehaskell-gi-baseAssign 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).haskell-gi-base-Connect the given signal to a signal handler.haskell-gi-baseLike ', but connect after the default signal.haskell-gi-baseConstraint on a obj/value pair so that ( works on values of type value.haskell-gi-baseConstraint on a obj/attr pair so that  works on values of type value.haskell-gi-base#A user friendly description of the $, useful when printing type errors.haskell-gi-base$Possible operations on an attribute.haskell-gi-base8It is possible to read the value of the attribute with .haskell-gi-base9It is possible to write the value of the attribute with .haskell-gi-base5It is possible to set the value of the attribute in (.haskell-gi-baseIt is possible to clear the value of the (nullable) attribute with .haskell-gi-baseCheck if the given element is a member, and if so raise the given error.haskell-gi-baseError to be raised when AttrConstruct is allowed, but an implementation has not been provided.haskell-gi-baseError to be raised when AttrSet is allowed, but an implementation has not been provided.haskell-gi-baseError to be raised when AttrGet is allowed, but an implementation has not been provided.haskell-gi-baseError to be raised when AttrClear is allowed, but an implementation has not been provided.haskell-gi-baseError to be raised when an operation is allowed, but an implementation has not been provided.haskell-gi-baseWhether a given 2 is allowed on an attribute, given the info type.haskell-gi-base+Look in the given list to see if the given + is a member, if not return an error type.haskell-gi-basePretty print a type, indicating the parent type that introduced the attribute, if different.haskell-gi-baseInfo describing an attribute.haskell-gi-base1The operations that are allowed on the attribute.haskell-gi-baseConstraint on the type for which we are allowed to create/set/get the attribute.haskell-gi-baseType returned by .haskell-gi-base"Constraint on the value being set.haskell-gi-baseConstraint on the value being set, with allocation allowed (see  below).haskell-gi-base#Type resulting from the allocation.haskell-gi-baseName of the attribute.haskell-gi-base$Type which introduces the attribute.haskell-gi-base%Get the value of the given attribute.haskell-gi-baseSet the value of the given attribute, after the object having the attribute has already been created.haskell-gi-base(Set the value of the given attribute to NULL (for nullable attributes).haskell-gi-baseBuild a  ) representing the attribute.haskell-gi-baseAllocate 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.haskell-gi-baseReturn some information about the overloaded attribute, useful for debugging. See & for how to access this conveniently.haskell-gi-baseA proxy for attribute labels.haskell-gi-base+Set a number of properties for some object.haskell-gi-base,Get the value of an attribute for an object.haskell-gi-baseSet a nullable attribute to NULL.haskell-gi-baseReturn the fully qualified attribute name that a given overloaded attribute resolves to (mostly useful for debugging). resolveAttr #sensitive button''0000 Safe-Inferredhaskell-gi-baseA , which is simply an integer.haskell-gi-base)Construct a GQuark from the given string. Safe-Inferred "%&x)haskell-gi-base"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.haskell-gi-base"Information on a property of type H 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.haskell-gi-baseIdentifier for the property.haskell-gi-base#Identifier for display to the user.haskell-gi-baseDescription of the property.haskell-gi-baseDefault value.haskell-gi-base0Handler invoked when the property is being set.haskell-gi-base8Handler that returns the current value of the property.haskell-gi-baseSet of flags, or   for the default set of flags.haskell-gi-baseMinimum value, or  , which would be replaced by MININT.haskell-gi-baseMaximum value, or  , which would be replaced by MAXINT.haskell-gi-baseInformation 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.haskell-gi-baseIdentifier for the property.haskell-gi-base#Identifier for display to the user.haskell-gi-baseDescription of the property.haskell-gi-base0Handler invoked when the property is being set.haskell-gi-base8Handler that returns the current value of the property.haskell-gi-baseSet of flags, or   for the default set of flags.haskell-gi-base=The basic constructor for a GObject. They are all isomorphic.haskell-gi-base-Low-level getter and setter for the property.haskell-gi-base7Flags controlling the behaviour of the the parameters. haskell-gi-basethe parameter is readable haskell-gi-basethe parameter is writable haskell-gi-base3the parameter will be set upon object construction haskell-gi-base7the parameter can only be set upon object construction haskell-gi-base calls to *+ for this property will not automatically result in a "notify" signal being emitted: the implementation must call *,3 themselves in case the property actually changes. haskell-gi-baseCatch-all for unknown valueshaskell-gi-base(Take ownership of a ParamSpec passed in .haskell-gi-base*Construct a Haskell wrapper for the given o, without assuming ownership.haskell-gi-base Remove a reference to the given o.haskell-gi-base Disown a o3, i.e. do not longer unref the associated foreign o when the Haskell o gets garbage collected.haskell-gi-base2Default set of flags when constructing properties.haskell-gi-baseThe 3 pointing to the setter and getter of the property.haskell-gi-base6Construct a copy of the object from the given pointer.haskell-gi-base4Wrap a Haskell getter/setter into a lower level one.haskell-gi-base Create a o for a Haskell value.haskell-gi-base Create a o for an integer param.haskell-gi-base Create a o for a string param.haskell-gi-baseSet the given user data on the o.haskell-gi-base Get the user data for the given  on the o.haskell-gi-base do log errorMessage return mssingImagePlaceholder)haskell-gi-baseCatch 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 -> ... _ -> ...)haskell-gi-base A verson of # with the arguments swapped around.haskell-gi-base A verson of # with the arguments swapped around.haskell-gi-base)Run the given function catching possible s in its execution. If a 5 is emitted this throws the corresponding exception.haskell-gi-baseLike , but allows to specify a custom handler instead of just throwing the exception.haskell-gi-baseIf the passed in   is not  , store a copy in the passed in pointer, unless the pointer is 1.haskell-gi-base2s are registered as boxed in the GLib type system.haskell-gi-base*There are no types in the bindings that a  can be safely cast to.haskell-gi-baseThis must not use the value of its parameter so that it is safe to pass &.haskell-gi-baseThe error to catchhaskell-gi-baseThe computation to runhaskell-gi-base,Handler to invoke if an exception is raisedhaskell-gi-baseThe computation to runhaskell-gi-base+Handler to invoke if an exception is raised Safe-Inferred).TL:;<=>?@ABCDEFGHI1234"K756MNRSfgqr|stu~vwxy}{zoplmjkhidebcn_`a^]\ 0/ ,+- #  !*'Q &%8O9().TL:;<=>?@ABCDEFGHI1234"K756MNRS 0/ ,+- #  !*'Q &%8O9( Safe-Inferredܸhaskell-gi-base)Set a property on an object to the given .haskell-gi-baseA convenience wrapper over + that does the wrapping of a value into a .haskell-gi-baseGet the  for the given property.haskell-gi-baseA convenience wrapper over  that unwraps the  into a Haskell value.haskell-gi-base!Set a property for a type with a  instance.haskell-gi-base'Construct a property for a type with a  instance.haskell-gi-base*Get a nullable property for a type with a  instance.haskell-gi-baseSet a property of type .haskell-gi-baseConstruct a property of type .haskell-gi-base$Get the value of a property of type .haskell-gi-baseSet a property of type .haskell-gi-baseConstruct a property of type .haskell-gi-base$Get the value of a property of type .haskell-gi-baseConstruct a property of type o.haskell-gi-baseGet a property of type o.haskell-gi-baseSet a property of type o.1 Safe-Inferred>fgqr|stu~vwxy}{zoplmjkhidebcn_`a^]\23423523678923:23;23<2=>2=?2@A78B23C2DE7FG7FH7FI7FJ7FK2LM2LN2LO2LP2QR7FS2TU2TV2TW2TX2YZ2Y[2\]7F^2Q_2Q`2ab78c2\d2ef2eg23h23i23j23k2Dl2Dm2Dn2op2@q2@r2Y2Ys2Yt2Yu2vw2vx2vy2z{2z|2}~2}~2}2}2}2}2}2}2}2}2}2}2}2}2}.2}.22a222222"22!!                                                                                                                                                                                                                          ) )                                                 (  2v   2a    2 haskell-gi-base-0.26.3-inplaceData.GI.Base.ShortPreludeData.GI.Base.CallStackData.GI.Base.Internal.CTypesData.GI.Base.OverloadingData.GI.Base.BasicTypesData.GI.Base.GTypeData.GI.Base.GArrayData.GI.Base.UtilsData.GI.Base.ManagedPtrData.GI.Base.GClosureData.GI.Base.BasicConversionsData.GI.Base.GVariantData.GI.Base.GValueData.GI.Base.GHashTableData.GI.Base.GQuarkData.GI.Base.GParamSpecData.GI.Base.SignalsData.GI.Base.AttributesData.GI.Base.GObjectData.GI.Base.ConstructibleData.GI.Base.GErrorData.GI.Base.Propertieshaskell-gi-baseData.MapMapData.ByteString ByteString Foreign.PtrnullPtr SignalInfoAttrInfoGError GParamSpec Control.MonadmaybeForeign.Concurrent newForeignPtrForeign.ForeignPtrnewForeignPtr_newGValueGI.GObject.Objects.ObjectobjectSetProperty objectNotify Foreign.CCIntGI.GLib quarkToString Data.GI.BasebaseGHC.Base++map$ghc-prim GHC.Classes==>>=>>returnGHC.Real fromIntegral realToFracGHC.EnumEnumEqMonadGHC.ShowShow GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 GHC.MaybeMaybeIOGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtrGHC.Stack.Types CallStackSymbolNothingJustGHC.ForeignPtr ForeignPtr/= HasCallStackGHC.Errerror undefined=<<whenord. showsPrecshowshowListGHC.CharchrtoEnumfromEnumplusPtrcastFunPtrToPtrcastPtrToFunPtrForeign.StorablesizeOfpeekpoke Data.FoldablelengthmapM_Foreign.C.TypesCUIntPtrCIntPtrCDoubleCFloatCULongCLongCUInt GHC.ExceptionprettyCallStackunsafeForeignPtrToPtrForeign.C.StringCString Data.Functor<$>Control.Exception.Base onExceptionData.TraversablemapM GHC.Stack callStack>=>Control.Monad.IO.ClassMonadIOliftIObytestring-0.11.3.1Data.ByteString.InternalC_gintGQuark cgvalueSizegerror_domain_offsetgerror_code_offsetgerror_message_offsetHasParentTypes GEqualFunc GHashFuncGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlagGVariantUnexpectedNullPointerReturnnullPtrErrorMsgGType gtypeToCGTypeCGType BoxedFlags BoxedEnumGObjectGBoxed TypedObjectglibType CallocPtrboxedPtrCallocBoxedPtr boxedPtrCopy boxedPtrFreeManagedPtrNewtype toManagedPtr ManagedPtrmanagedForeignPtrmanagedPtrAllocCallStackmanagedPtrIsDisowned g_slist_free g_list_free gtypeName noGParamSpec$fEqManagedPtr$fManagedPtrNewtypea&$fExceptionUnexpectedNullPointerReturn!$fShowUnexpectedNullPointerReturn $fEqGType $fShowGType MethodProxyOverloadedMethodInfooverloadedMethodInfoResolvedSymbolInforesolvedSymbolNameresolvedSymbolURLOverloadedMethodoverloadedMethodMethodResolutionFailedUnsupportedMethodError 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 gtypeError gtypeParam gtypeGType gtypeStrvgtypeByteArraygtypeStablePtr allocGArraysafeFreeFunPtrPtr'safeFreeFunPtrPtrsafeFreeFunPtr ptr_to_g_freefreeMemwhenJustmaybeM maybeFromPtrmapFirst mapSecond mapFirstA mapSecondAconvertIfNonNullconvertFunPtrIfNonNull callocBytes callocMemcallocBoxedBytes allocBytesallocMemmemcpymaybeReleaseFunPtrcheckUnexpectedReturnNULLcheckUnexpectedNothingdbgLog newManagedPtrnewManagedPtr'newManagedPtr_disownManagedPtrwithManagedPtrmaybeWithManagedPtrwithManagedPtrList withTransientunsafeManagedPtrGetPtrunsafeManagedPtrCastPtrtouchManagedPtrcheckInstanceTypecastTo unsafeCastTo newObject 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$fIsGVariant(,,,,)$fIsGVariant(,,,)$fIsGVariant(,,)$fIsGVariant(,)$fIsGVariant()$fIsGVariant[]$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$fShowGVariantSingletIsGValue 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$fGBoxedGValue$fTypedObjectGValue$fHasParentTypesGValue$fIsGValueMaybe$fIsGValueStablePtr$fIsGValueGType$fIsGValueBool$fIsGValueDouble$fIsGValueFloat$fIsGValueWord64$fIsGValueInt64$fIsGValueCULong$fIsGValueCLong$fIsGValueCUInt$fIsGValueCInt$fIsGValueWord32$fIsGValueInt32 $fIsGValuePtr$fIsGValueMaybe0$fIsGValueMaybe1 gStrEqualgStrHash gDirectEqual gDirectHash ptrPackPtr ptrUnpackPtrcstringPackPtrcstringUnpackPtr gvaluePackPtrgvalueUnpackPtrgQuarkFromStringCStringPropertyInfo$sel:name:CStringPropertyInfo$sel:nick:CStringPropertyInfo$sel:blurb:CStringPropertyInfo%$sel:defaultValue:CStringPropertyInfo$sel:flags:CStringPropertyInfo$sel:setter:CStringPropertyInfo$sel:getter:CStringPropertyInfoCIntPropertyInfo$sel:name:CIntPropertyInfo$sel:nick:CIntPropertyInfo$sel:blurb:CIntPropertyInfo"$sel:defaultValue:CIntPropertyInfo$sel:setter:CIntPropertyInfo$sel:getter:CIntPropertyInfo$sel:flags:CIntPropertyInfo$sel:minValue:CIntPropertyInfo$sel:maxValue:CIntPropertyInfo PropertyInfo$sel:name:PropertyInfo$sel:nick:PropertyInfo$sel:blurb:PropertyInfo$sel:setter:PropertyInfo$sel:getter:PropertyInfo$sel:flags:PropertyInfo PropGetSetter$sel:propGetter:PropGetSetter$sel:propSetter:PropGetSetter GParamFlagGParamReadableGParamWritableGParamConstructGParamConstructOnlyGParamExplicitNotifyAnotherGParamFlagwrapGParamSpecPtrnewGParamSpecFromPtrunrefGParamSpecdisownGParamSpecgParamSpecValuegParamSpecCIntgParamSpecCStringgetGParamSpecGetterSetter$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#$fSignalInfoGObjectNotifySignalInfoDerivedGObjectGObjectParentTypeGObjectPrivateDataobjectTypeNameobjectClassInitobjectInstanceInit GObjectClassconstructGObjectnew'gtypeFromClassgtypeFromInstance registerGTypegobjectGetPrivateDatagobjectGetUserDatagobjectSetUserDatagobjectModifyUserDatagobjectSetPrivateDatagobjectModifyPrivateDatagobjectInstallPropertygobjectInstallCIntPropertygobjectInstallCStringProperty 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:ParentTypesGClosure text-2.0.1Data.Text.InternalTextcontainers-0.6.6Data.Map.Internal GHC.Stable StablePtrD:R:ParentTypesGValue AttrOpText CheckNotElemConstructNotProvidedErrorSetNotProvidedErrorGetNotProvidedErrorClearNotProvidedErrorOpNotProvidedErrorAttrOpIsAllowedTypeOriginInfoGObjectConstructor defaultFlags pspecQuark objectFromPtr wrapGetSetgParamSpecSetQDatagParamSpecGetQDataGObjectNotifyCallback proxyDetailconnectGObjectNotifydoConstructGObject privateKeyinstanceSetUserDatainstanceSetPrivateDatagErrorQuarkFromDomainD:R:ParentTypesGErrorgobjectSetPropertysetObjectPropertygobjectGetPropertygetObjectProperty