h%/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                 Safe-Inferred-012201None-/3>?#Nhaskell-gi-base3Destroy the memory associated with a given pointer.Ohaskell-gi-baseSome APIs, such as V, pass around scalar types wrapped into a pointer. We encode such a type as follows.Rhaskell-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.Thaskell-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.Vhaskell-gi-baseA  =https://developer.gnome.org/glib/stable/glib-Hash-Tables.html GHashTable. It is mapped to a  on the Haskell side.Xhaskell-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.Zhaskell-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.\haskell-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.^haskell-gi-base(An enum usable as a flag for a function._haskell-gi-baseA  https://developer.gnome.org/gobject/stable/gobject-GParamSpec.html GParamSpec. See Data.GI.Base.GParamSpec for further methods.ahaskell-gi-baseA  :https://developer.gnome.org/glib/stable/glib-GVariant.htmlGVariant. See Data.GI.Base.GVariant for further methods.chaskell-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 .fhaskell-gi-base&A newtype for use on the haskell side.ihaskell-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 f below.jhaskell-gi-baseFlags with an associated f.khaskell-gi-baseEnums with an associated f.lhaskell-gi-base A wrapped l*, or any other type that descends from it.mhaskell-gi-baseChunks of memory whose allocation/deallocation info has been registered with the GLib type system.nhaskell-gi-baseA wrapped object that has an associated GLib type. This does not necessarily descend from l%, that constraint is implemented by l below.ohaskell-gi-baseThe f for this object.phaskell-gi-baseA ptr to a memory block which we know how to allocate and fill with zero.qhaskell-gi-base?Allocate a zero-initialized block of memory for the given type.rhaskell-gi-basePointers to chunks of memory which we know how to copy and release.shaskell-gi-baseMake a copy of the given r.thaskell-gi-base6A pointer to a function for freeing the given pointer.uhaskell-gi-base?A constraint ensuring that the given type is a newtype over a w.whaskell-gi-baseThin wrapper over M", supporting the extra notion of  disowning, that is, not running the finalizers associated with the foreign ptr.zhaskell-gi-base' for the call that created the pointer.{haskell-gi-baseWhen disowned, the  for the disowning call.|haskell-gi-baseFree the given R.}haskell-gi-baseFree the given T.~haskell-gi-base#Get the name assigned to the given f.haskell-gi-baseA convenient synonym for Nothing :: Maybe GParamSpec.haskell-gi-baseTwo w0s are equal if they wrap the same underlying C .haskell-gi-baseA default instance for  IsManagedPtr for newtypes over w.2NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2wxyz{uvrstpqcdenolfghi~abmkj_`\]Z[XYVWTU}RS|^OPQNNone &ohaskell-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 i6 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.f of strings.haskell-gi-basef of pointers.haskell-gi-basef for signed integers (gint or gint32).haskell-gi-basef for unsigned integers (guint or guint32).haskell-gi-basef for glong.haskell-gi-basef for gulong.haskell-gi-basef for signed 64 bit integers.haskell-gi-basef for unsigned 64 bit integers.haskell-gi-basef for floating point values.haskell-gi-basef for gdouble.haskell-gi-basef corresponding to gboolean.haskell-gi-basef! corresponding to a boxed object.haskell-gi-basef corresponding to a GObject.haskell-gi-base An invalid f> used as error return value in some functions which return a f.haskell-gi-baseThe f corresponding to a GVariant.haskell-gi-baseThe f corresponding to .haskell-gi-basef corresponding to a f itself.haskell-gi-basef( for a NULL terminated array of strings.haskell-gi-basef for a boxed type holding a  GByteArray.haskell-gi-baseThe f for boxed  StablePtrs.None) 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-baseCheck whether two 8 s are equal.haskell-gi-baseCompute the hash for a 8.haskell-gi-base%Check whether two pointers are equal.haskell-gi-baseCompute the hash for a .haskell-gi-basePack a  into a O .haskell-gi-base Extract a  from a O .haskell-gi-basePack a 8 into a  than can go into a  GHashTable.haskell-gi-base Extract a 8 wrapped into a  coming from a  GHashTable.  None*haskell-gi-base Allocate a \! with elements of the given size.None-./>?3W5haskell-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-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-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-baseAll the types that are ascendants of this type, including interfaces that the type implements.haskell-gi-base$Check that a type is in the list of  of another type.haskell-gi-base/Safe coercions to a parent class. For instance: #show $ label `asA` Gtk.Widgethaskell-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 .55None  -?=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 K, 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-basel+haskell-gi-base A DictEntry a; is isomorphic to a two-tuple. Wrapping the values into a GVariantDictentry allows the ! instance to do the right thing.haskell-gi-baseAn object representing a DBus signature, which is a particular type of a too. (Just a string with some specific requirements.) In order to construct/deconstruct a  one can use  and .haskell-gi-baseAn object representing a DBus object path, which is a particular type of a too. (Just a string with some specific requirements.) In order to construct/deconstruct a  one can use  and .haskell-gi-baseHaskell has no notion of one element tuples, but GVariants do, so the following allows for marshalling one element tuples properly using  and . For instance, to construct a single element tuple containing a string, you could do #toGVariant (GVariantSinglet "Test")haskell-gi-baseThe typeclass for basic type a, types, i.e. those that are not containers.haskell-gi-baseThe typeclass for types that can be automatically marshalled into a using  and .haskell-gi-base2Convert a value of the given type into a GVariant.haskell-gi-baseTry to decode a a8 into a target type. If the conversion fails we return  9. The type that was expected can be obtained by calling ,, and the actual type as understood by the a" code can be obtained by calling gvariantToTypeString.haskell-gi-baseThe expected format string for this type (the argument is ignored).haskell-gi-base An alias for Nothing :: Maybe GVariant to save some typing.haskell-gi-baseGet the expected type of a a, in a notation. See  >https://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 a, without assuming ownership.haskell-gi-base Remove a reference to the given a.haskell-gi-base Disown a a, i.e. do not unref the underlying object when the Haskell object is garbage collected.haskell-gi-baseConvert a DBus handle (an  ) into a a.haskell-gi-baseExtract the DBus handle (an  ) inside a a.haskell-gi-baseDecode an UTF-8 encoded string a into .haskell-gi-base Encode a  into an UTF-8 encoded string a.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 a1 containing an object path. In order to build a  value see .haskell-gi-base Extract a  from a a!, 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 a4 containing an DBus signature. In order to build a  value see .haskell-gi-base Extract a  from a a, represented as .haskell-gi-baseBox a a inside another a.haskell-gi-baseUnbox a a contained inside another a.haskell-gi-base/Extract a zero terminated list of bytes into a 7.haskell-gi-base Encode a 7 into a list of bytes a.haskell-gi-base Convert a  value into a corresponding a of maybe type.haskell-gi-baseTry to decode a maybe a 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 a" of type DictEntry from the given key and value. The key must be a basic a type, i.e. not a container. This is determined by whether it belongs to the  typeclass. On the other hand value is an arbitrary a/, 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 a1 for dictionary type, which is just an array of .haskell-gi-base Unpack a a into a 9. Notice that this assumes that all the elements in the a array of = are of the same type, which is not necessary for a generic a, 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 a array containing them.haskell-gi-base Unpack a a array into its elements.haskell-gi-baseGiven a list of a, construct a a, tuple containing the elements in the list.haskell-gi-baseExtract the children of a a tuple into a list.haskell-gi-base:The empty tuple GVariant, mostly useful for type checking.haskell-gi-baseOne element tuples.?? None  />shaskell-gi-baseA convenience class for marshaling back and forth between Haskell values and s.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-baseA convenience alias for   ::  .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 Unset the ), freeing all resources associated to it.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-base2s are registered as boxed in the GLib type system.haskell-gi-baseFind the associated f for .haskell-gi-base*There are no types in the bindings that a  can be safely cast to.::None'(-./9>"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-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$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-baseWhether a given 2 is allowed on an attribute, given the info type.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-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.##0000Nonehaskell-gi-baseA , which is simply an integer.haskell-gi-base)Construct a GQuark from the given string.None  #$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 = 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-Low-level getter and setter for the property.haskell-gi-base(Take ownership of a ParamSpec passed in .haskell-gi-base*Construct a Haskell wrapper for the given _, without assuming ownership.haskell-gi-base Remove a reference to the given _.haskell-gi-base Disown a _3, i.e. do not longer unref the associated foreign _ when the Haskell _ gets garbage collected.haskell-gi-base Create a _ for a Haskell value.haskell-gi-base Create a _ for an integer param.haskell-gi-base Create a _ for a string param.haskell-gi-base?Ohaskell-gi-baseGenerate an informative type error whenever one tries to use a signal for which code generation has failed.haskell-gi-baseConnection information for a "notify" signal indicating that a specific property changed (see  for the relevant constructor).haskell-gi-base.Whether to connect a handler to a signal with  so that it runs before/after the default handler for the given signal.haskell-gi-baseRun before the default handler.haskell-gi-baseRun after the default handler.haskell-gi-base'Information about an overloaded signal.haskell-gi-base The type for the signal handler.haskell-gi-base5Connect a Haskell function to a signal of the given l, specifying whether the handler will be called before or after the default handler.haskell-gi-base)Support for overloaded signal connectors.haskell-gi-baseA basic signal name connector.haskell-gi-base+A signal connector annotated with a detail.haskell-gi-baseA signal connector for the notify signal on the given property.haskell-gi-base Type of a l signal handler id.haskell-gi-base%Connect a signal to a signal handler.haskell-gi-baseConnect a signal to a handler, running the handler after the default one.haskell-gi-base*Connect a signal to a handler, given as a .haskell-gi-base)Disconnect a previously connected signal.haskell-gi-baseSupport for overloaded labels.None '(/?haskell-gi-base?This typeclass contains the data necessary for defining a new l type from Haskell.haskell-gi-baseThe parent typehaskell-gi-base+Type of the private data for each instance.haskell-gi-base&Name of the type, it should be unique.haskell-gi-baseCode to run when the class is inited. This is a good place to register signals and properties for the type.haskell-gi-baseCode to run when each instance of the type is constructed. Returns the private data to be associated with the new instance (use  and  to manipulate this further).haskell-gi-baseWrapper around  GObjectClass on the C-side.haskell-gi-baseConstruct a GObject given the constructor and a list of settable attributes. See % for a more general version.haskell-gi-baseConstruct the given l/, given a set of actions constructing desired s to set at construction time.haskell-gi-base Find the f associated to a given .haskell-gi-base Find the f for a given l.haskell-gi-base!Register the given type into the GObject' type system and return the resulting f, if it has not been registered already. If the type has been registered already the existing f will be returned instead.Note that for this function to work the type must be an instance of .haskell-gi-base6Get the private data associated with the given object.haskell-gi-base,Get the value of a given key for the object.haskell-gi-base-Set the value of the user data for the given l to a " to the given Haskell object. The  will be freed when the object is destroyed, or the value is replaced.haskell-gi-baseA combination of  and , for convenience.haskell-gi-base6Set the private data associated with the given object.haskell-gi-base-Modify the private data for the given object.haskell-gi-base?Add a Haskell object-valued property to the given object class.haskell-gi-baseAdd a '(+-valued property to the given object class.haskell-gi-baseAdd a 8+-valued property to the given object class.None />haskell-gi-base:Constructible types, i.e. those which can be allocated by .haskell-gi-baseAllocate a new instance of the given type, with the given attributes.haskell-gi-base%Default instance, assuming we have a l.None /3{haskell-gi-baseEach error domain's error enumeration type should be an instance of this class. This class helps to hide the raw error and domain codes from the user. Example for  https://hackage.haskell.org/package/gi-gdkpixbuf/docs/GI-GdkPixbuf-Enums.html#t:PixbufError PixbufError: instance GErrorClass PixbufError where gerrorClassDomain _ = "gdk-pixbuf-error-quark"haskell-gi-baseA human readable error message.haskell-gi-base3A code to identify a specific error within a given . Most of time you will not need to deal with this raw code since there is an enumeration type for each error domain. Of course which enumeration to use depends on the error domain, but if you use  or +, this is worked out for you automatically.haskell-gi-baseA code used to identify the "namespace" of the error. Within each error domain all the error codes are defined in an enumeration. Each gtk/gnome module that uses GErrors has its own error domain. The rationale behind using error domains is so that each module can organise its own error codes without having to coordinate on a global error code list.haskell-gi-baseA GError, consisting of a domain, code and a human readable message. These can be accessed by ,  and  below.haskell-gi-base Create a new .haskell-gi-base Return the domain for the given . This is a GQuark, a textual representation can be obtained with )*.haskell-gi-baseThe numeric code for the given .haskell-gi-baseA text message describing the .haskell-gi-baseThis will catch just a specific GError exception. If you need to catch a range of related errors, * is probably more appropriate. Example: do image <- catchGErrorJust PixbufErrorCorruptImage loadImage (\errorMessage -> 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 K.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 raisedNone *+ /  ,-.()  !"#$%&'346789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx{yz|}~3789:;<=>?@ABCDEFGHIJKLM#6 *+ ,-. /  !$% '&()"4Nonehaskell-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 .+NoneNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx{yz|}~,-.,-/,-0123,-4,-5,-6,78,79,:;12<,-=,>?1@A1@B1@C1@D1@E,FG,FH,FI,FJ,KL1@M,NO,NP,NQ,NR,ST,SU1@V,WX,KY,KZ,[\,]^,-_,-`,ab,ac,[d,ef,:g,:h,>i,>j,>k12l,mn,op,Wq,-r,-st,uvwx,yz,{|,{|,{},{},{(,{(,{~,{~,{,{,{,{,{,{,{,{,S,S,S,S,,,,,,,                            ,,                                                                                                                                                                                             & &                                                                      %,, , haskell-gi-base-0.24.2-inplaceData.GI.Base.ShortPreludeData.GI.Base.CallStackData.GI.Base.OverloadingData.GI.Base.BasicTypesData.GI.Base.GTypeData.GI.Base.GHashTableData.GI.Base.GArrayData.GI.Base.UtilsData.GI.Base.ManagedPtrData.GI.Base.GClosureData.GI.Base.BasicConversionsData.GI.Base.GVariantData.GI.Base.GValueData.GI.Base.AttributesData.GI.Base.GQuarkData.GI.Base.GParamSpecData.GI.Base.SignalsData.GI.Base.GObjectData.GI.Base.ConstructibleData.GI.Base.GErrorData.GI.Base.PropertiesData.MapMapData.ByteString ByteString Foreign.PtrnullPtrGError SignalInfoAttrInfo Control.MonadmaybeForeign.Concurrent newForeignPtrForeign.ForeignPtrnewForeignPtr_newGValue 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.PtrPtrFunPtrSymbolGHC.Stack.Types CallStackNothingJust Data.FoldablemapM_ Data.Functor<$>.=<<GHC.Errerror undefinedlengthData.TraversablemapMfromEnumtoEnumshowshowList showsPrec/= GHC.ExceptionprettyCallStack GHC.Stack callStack HasCallStackordwhenHasParentTypesControl.Exception.Base onExceptionbytestring-0.10.10.0Data.ByteString.InternalForeign.C.StringCStringForeign.C.TypesCDoubleCFloatCIntPtrCLongCUIntCUIntPtrCULongcastFunPtrToPtrcastPtrToFunPtrplusPtrGHC.ForeignPtr ForeignPtrGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlag GParamSpecGVariantUnexpectedNullPointerReturnnullPtrErrorMsgGType gtypeToCGTypeCGType BoxedFlags BoxedEnumGObjectGBoxed TypedObjectglibType CallocPtrboxedPtrCallocBoxedPtr boxedPtrCopy boxedPtrFreeManagedPtrNewtype toManagedPtr ManagedPtrmanagedForeignPtrmanagedPtrAllocCallStackmanagedPtrIsDisowned g_slist_free g_list_free gtypeName noGParamSpecGHC.CharchrunsafeForeignPtrToPtr$fEqManagedPtr$fManagedPtrNewtypea&$fExceptionUnexpectedNullPointerReturn!$fShowUnexpectedNullPointerReturn gtypeString gtypePointergtypeInt gtypeUInt gtypeLong gtypeULong gtypeInt64 gtypeUInt64 gtypeFloat gtypeDouble gtypeBoolean gtypeBoxed gtypeObject gtypeInvalid gtypeVariant gtypeError gtypeGType gtypeStrvgtypeByteArraygtypeStablePtr GEqualFunc GHashFunc gStrEqualgStrHash gDirectEqual gDirectHash ptrPackPtr ptrUnpackPtrcstringPackPtrcstringUnpackPtr allocGArray MethodInfooverloadedMethodMethodResolutionFailedUnsupportedMethodError HasSignal ResolveSignal SignalListHasAttr HasAttributeResolveAttributeHasAttributeList AttributeList ParentTypesIsDescendantOfasA$fHasParentTypesa$fHasAttributeListka$fHasAttrattro>=>Foreign.StorablepeekpokesizeOfsafeFreeFunPtrPtrsafeFreeFunPtr 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 copyBytesControl.Monad.IO.ClassMonadIOliftIOGClosure 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$fShowGVariantSingletIsGValuetoGValue fromGValueGValueConstructnoGValue newGValue wrapGValuePtrnewGValueFromPtr buildGValue disownGValue unsetGValue set_string get_string set_pointer get_pointer set_int32 get_int32set_intget_int set_uint32 get_uint32set_uintget_uintset_longget_long set_ulong get_ulong set_int64 get_int64 set_uint64 get_uint64 set_float get_float set_double get_double set_boolean get_boolean set_gtype get_gtype set_object get_object set_boxed get_boxed set_variant get_variantset_enumget_enum set_flags get_flags set_stablePtrtake_stablePtr get_stablePtrpackGValueArrayunpackGValueArrayWithLengthmapGValueArrayWithLength$fGBoxedGValue$fTypedObjectGValue$fHasParentTypesGValue$fIsGValueStablePtr$fIsGValueGType$fIsGValueBool$fIsGValueDouble$fIsGValueFloat$fIsGValueWord64$fIsGValueInt64$fIsGValueCULong$fIsGValueCLong$fIsGValueCUInt$fIsGValueCInt$fIsGValueWord32$fIsGValueInt32 $fIsGValuePtr$fIsGValueMaybe$fIsGValueMaybe0 AttrClearCAttrGetCAttrOp:=:=>:~:~>:&=AttrConstructCAttrSetC AttrOpTagAttrGetAttrSet AttrConstruct AttrClear AttrOpAllowedAttrAllowedOpsAttrBaseTypeConstraint AttrGetTypeAttrSetTypeConstraintAttrTransferTypeConstraintAttrTransferType AttrLabel AttrOriginattrGetattrSet attrClear attrConstruct attrTransferAttrLabelProxysetgetclear$fIsLabelxAttrLabelProxy $fEqAttrOpTag$fOrdAttrOpTag$fEnumAttrOpTag$fBoundedAttrOpTag$fShowAttrOpTagGQuarkgQuarkFromStringCStringPropertyInfo$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:PropGetSetterwrapGParamSpecPtrnewGParamSpecFromPtrunrefGParamSpecdisownGParamSpecgParamSpecValuegParamSpecCIntgParamSpecCStringgetGParamSpecGetterSetter$fIsGFlagGParamFlag$fOrdGParamFlag$fEnumGParamFlag$fShowGParamFlag$fEqGParamFlagSignalCodeGenErrorGObjectNotifySignalInfoSignalConnectModeSignalConnectBeforeSignalConnectAfterHaskellCallbackType connectSignal SignalProxy:::PropertyNotifySignalHandlerIdonafterconnectSignalFunPtrdisconnectSignalHandler$fIsLabelslotSignalProxy#$fSignalInfoGObjectNotifySignalInfoDerivedGObjectGObjectParentTypeGObjectPrivateDataobjectTypeNameobjectClassInitobjectInstanceInit GObjectClassconstructGObjectnew'gtypeFromClassgtypeFromInstance registerGTypegobjectGetPrivateDatagobjectGetUserDatagobjectSetUserDatagobjectModifyUserDatagobjectSetPrivateDatagobjectModifyPrivateDatagobjectInstallPropertygobjectInstallCIntPropertygobjectInstallCStringProperty Constructible$fConstructibleatag GErrorClassgerrorClassDomain GErrorMessage GErrorCode GErrorDomain gerrorNew gerrorDomain gerrorCode gerrorMessagecatchGErrorJustcatchGErrorJustDomainhandleGErrorJusthandleGErrorJustDomainpropagateGError checkGErrormaybePokeGError$fGBoxedGError$fTypedObjectGError$fHasParentTypesGError$fExceptionGError $fShowGErrorsetObjectPropertyStringconstructObjectPropertyStringgetObjectPropertyStringsetObjectPropertyPtrconstructObjectPropertyPtrgetObjectPropertyPtrsetObjectPropertyIntconstructObjectPropertyIntgetObjectPropertyIntsetObjectPropertyUIntconstructObjectPropertyUIntgetObjectPropertyUIntsetObjectPropertyLongconstructObjectPropertyLonggetObjectPropertyLongsetObjectPropertyULongconstructObjectPropertyULonggetObjectPropertyULongsetObjectPropertyInt32constructObjectPropertyInt32getObjectPropertyInt32setObjectPropertyUInt32constructObjectPropertyUInt32getObjectPropertyUInt32setObjectPropertyInt64constructObjectPropertyInt64getObjectPropertyInt64setObjectPropertyUInt64constructObjectPropertyUInt64getObjectPropertyUInt64setObjectPropertyFloatconstructObjectPropertyFloatgetObjectPropertyFloatsetObjectPropertyDoubleconstructObjectPropertyDoublegetObjectPropertyDoublesetObjectPropertyBoolconstructObjectPropertyBoolgetObjectPropertyBoolsetObjectPropertyGTypeconstructObjectPropertyGTypegetObjectPropertyGTypesetObjectPropertyObjectconstructObjectPropertyObjectgetObjectPropertyObjectsetObjectPropertyBoxedconstructObjectPropertyBoxedgetObjectPropertyBoxedsetObjectPropertyStringArray"constructObjectPropertyStringArraygetObjectPropertyStringArraysetObjectPropertyEnumconstructObjectPropertyEnumgetObjectPropertyEnumsetObjectPropertyFlagsconstructObjectPropertyFlagsgetObjectPropertyFlagssetObjectPropertyClosureconstructObjectPropertyClosuregetObjectPropertyClosuresetObjectPropertyVariantconstructObjectPropertyVariantgetObjectPropertyVariantsetObjectPropertyByteArray constructObjectPropertyByteArraygetObjectPropertyByteArraysetObjectPropertyPtrGListconstructObjectPropertyPtrGListgetObjectPropertyPtrGListsetObjectPropertyHashconstructObjectPropertyHashgetObjectPropertyHashsetObjectPropertyCallbackconstructObjectPropertyCallbackgetObjectPropertyCallbacksetObjectPropertyGErrorconstructObjectPropertyGErrorgetObjectPropertyGErrorsetObjectPropertyGValueconstructObjectPropertyGValuegetObjectPropertyGValueStorable FinalizerPtrD:R:ParentTypesGClosure text-1.2.3.2Data.Text.InternalTextcontainers-0.6.2.1Data.Map.Internal GHC.Stable StablePtrD:R:ParentTypesGValueD:R:ParentTypesGError