!!1      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe )+F !,0WW!0,None )=Zhaskell-gi-base&A newtype for use on the haskell side.]haskell-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 Z below.^haskell-gi-base#Get the name assigned to the given Z._haskell-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 ]6 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.Z of strings.`haskell-gi-baseZ of pointers.ahaskell-gi-baseZ for signed integers (gint or gint32).bhaskell-gi-baseZ for unsigned integers (guint or guint32).chaskell-gi-baseZ for glong.dhaskell-gi-baseZ for gulong.ehaskell-gi-baseZ for signed 64 bit integers.fhaskell-gi-baseZ for unsigned 64 bit integers.ghaskell-gi-baseZ for floating point values.hhaskell-gi-baseZ for gdouble.ihaskell-gi-baseZ corresponding to gboolean.jhaskell-gi-baseZ corresponding to a  BoxedObject.khaskell-gi-baseZ corresponding to a GObject.lhaskell-gi-base An invalid Z> used as error return value in some functions which return a Z.mhaskell-gi-baseThe Z corresponding to a GVariant.nhaskell-gi-baseZ corresponding to a Z itself.ohaskell-gi-baseZ( for a NULL terminated array of strings.phaskell-gi-baseZ for a boxed type holding a  GByteArray.Z[\]^_`abcdefghijklmnopZ[\]^_`abcdefghinojkmplNone )+-1;<=FSTVxqhaskell-gi-base3Destroy the memory associated with a given pointer.rhaskell-gi-baseSome APIs, such as yU, pass around scalar types wrapped into a pointer. We encode such a type as follows.uhaskell-gi-baseA  Ehttps://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.whaskell-gi-baseA  Ehttps://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.yhaskell-gi-baseA  =https://developer.gnome.org/glib/stable/glib-Hash-Tables.html GHashTable. It is mapped to a  on the Haskell side.{haskell-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.}haskell-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  Bhttps://developer.gnome.org/gobject/stable/gobject-GParamSpec.html GParamSpec. See Data.GI.Base.GParamSpec for further methods.haskell-gi-baseA  :https://developer.gnome.org/glib/stable/glib-GVariant.htmlGVariant. See Data.GI.Base.GVariant for further methods.haskell-gi-baseSome functions are not marked as having a nullable return type in the introspection data. The result is that they currently do not return a Maybe type. This functions lets you work around this in a way that will not break when the introspection data is fixed.When you want to call a someHaskellGIFunction/ that may return null wrap the call like this. )nullToNothing (someHaskellGIFunction x y)WThe result will be a Maybe type even if the introspection data has not been fixed for someHaskellGIFunction yet.haskell-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.")QHaskell wrappers will raise this exception if the return value is an unexpected .haskell-gi-base A wrapped .haskell-gi-baseThe Z for this object.haskell-gi-base1Pointers to structs/unions without an associated Z.haskell-gi-base?Allocate a zero-initialized block of memory for the given type.haskell-gi-baseMake a copy of the given .haskell-gi-base;A pointer to a function for freeing the given pointer, or #D is the memory associated to the pointer does not need to be freed.haskell-gi-baseFlags with an associated Z.haskell-gi-baseEnums with an associated Z.haskell-gi-base.Wrapped boxed structures, identified by their Z.haskell-gi-basenA constraint ensuring that the given type is coercible to a ManagedPtr. It will hold for newtypes of the form "newtype Foo = Foo (ManagedPtr Foo)&which is the typical shape of wrapped s.haskell-gi-baseThin wrapper over &", supporting the extra notion of  disowningG, 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 u.haskell-gi-baseFree the given w.EZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.}~{|yzwxuvrstqNone ) 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 . s are equal.haskell-gi-baseCompute the hash for a ..haskell-gi-base%Check whether two pointers are equal.haskell-gi-baseCompute the hash for a .haskell-gi-basePack a  into a r .haskell-gi-base Extract a  from a r .haskell-gi-basePack a . into a  than can go into a  GHashTable.haskell-gi-base Extract a . wrapped into a  coming from a  GHashTable. None )+,-;=>?EFSThaskell-gi-baseProxy for passing a type to . We do not use M directly since it clashes with types defined in the autogenerated bindings.haskell-gi-baseXClass for types containing the information about an overloaded method of type `o -> s`.haskell-gi-base]A constraint enforcing that the signal exists for the given object, or one of its ancestors.haskell-gi-base<Isomorphic to Bool, but having some extra debug information.haskell-gi-baseMReturn 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  SignalInfo.haskell-gi-baseEA constraint that enforces that the given type has a given attribute.haskell-gi-baseDA constraint imposing that the given object has the given attribute.haskell-gi-base<Isomorphic to Bool, but having some extra debug information.haskell-gi-base=Whether a given type is in the given list. If found, return success, otherwise return failure.haskell-gi-baseSReturn the type encoding the attribute information for a given type and attribute.haskell-gi-baseMA 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 AttrInfo.haskell-gi-baseThe direct parents of this object: its direct parent type, if any, and the interfaces it implements. The interfaces inherited from parent types can be omitted.haskell-gi-base$Check that a type is in the list of GObjectParents of another GObject-derived type.haskell-gi-basexCheck whether a type appears in a list. We specialize the names/types a bit so the error messages are more informative.haskell-gi-base8Type error to be generated when an ancestor check fails.haskell-gi-base{Result of a ancestor check. Basically a Bool type with a bit of extra info in order to improve typechecker error messages.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-baseJoin two lists.haskell-gi-base>Support for overloaded labels in ghc < 8.0. This is like the i class introduced in ghc 8.0 (for use with the OverloadedLabels extension) with the difference that the j argument is lifted. (Using the unlifted Proxy# type in user code is a bit of a pain, hence the choice.)))None  )+<NVhaskell-gi-base A pointer to .haskell-gi-baseESame 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-baseZWhen the given value is of "Just a" form, execute the given action, otherwise do nothing.haskell-gi-baseLike J, but for actions on a monad, and with slightly different argument order.haskell-gi-baseCheck if the pointer is I, and wrap it on a  accordingly.haskell-gi-basedGiven 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-base\Apply the given conversion action to the given pointer if it is non-NULL, otherwise return #.haskell-gi-baseeApply 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-base@Make a zero-filled allocation of enough size to hold the given  type, using the GLib allocator.haskell-gi-basexMake 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-base<Allocate the given number of bytes using the GLib allocator.haskell-gi-baseAllocate space for the given  using the GLib allocator.haskell-gi-base_Copy memory into a destination (in the first argument) from a source (in the second argument).haskell-gi-base4If given a pointer to the memory location, free the  at that location, and then the pointer itself. Useful for freeing the memory associated to callbacks which are called just once, with no destroy notification.haskell-gi-base=Check that the given pointer is not NULL. If it is, raise a  exception.haskell-gi-baseAn annotated version of fromJust, which raises a  in case it encounters a #.haskell-gi-baseqPrint a string to the debug log in an atomic way (so the output of different threads does not get intermingled).None  )+<FVR haskell-gi-basebPrint some debug info (if the right environment valiable is set) about the object being disowned.haskell-gi-baseThin wrapper over .haskell-gi-baseKRun the finalizer for an owned pointer, assuming it has now been disowned.haskell-gi-base/Print some debug diagnostics for an allocation.haskell-gi-base Version of  taking a  and a corresponding , as in .haskell-gi-baseThin wrapper over .haskell-gi-base:Do not run the finalizers upon garbage collection of the .haskell-gi-basePerform an IO action on the  inside a managed pointer.haskell-gi-baseLike , but accepts a  type. If the passed value is #+ the inner action will be executed with a I argument.haskell-gi-base&Perform an IO action taking a list of  on a list of managed pointers.haskell-gi-basePerform the IO action with a transient managed pointer. The managed pointer will be valid while calling the action, but will be disowned as soon as the action finished.haskell-gi-base Return the V in a given managed pointer. As the name says, this is potentially unsafe: the given  may only be used before a call to [. This function is of most interest to the autogenerated bindings, for hand-written code " is almost always a better choice.haskell-gi-baseSame as ), but is polymorphic on the return type.haskell-gi-base=Print a warning when we try to access a disowned foreign ptr.haskell-gi-baseEnsure that the  in the given managed pointer is still alive (i.e. it has not been garbage collected by the runtime) at the point that this is called.haskell-gi-baseRCast to the given type, checking that the cast is valid. If it is not, we return #. Usage: "maybeWidget <- castTo Widget labelhaskell-gi-baseVCast to the given type, assuming that the cast will succeed. This function will call V if the cast is illegal.haskell-gi-basekPrint a warning when receiving a null pointer in a function that did not expect one, for easier debugging.haskell-gi-base"Construct a Haskell wrapper for a b, increasing its reference count, or taking ownership of the floating reference if there is one.haskell-gi-baseSame as ', but we steal ownership of the object.haskell-gi-base*Decrease the reference count of the given [. The memory associated with the object may be released if the reference count reaches 0.haskell-gi-baseDisown a GObject, that is, do not unref the associated foreign GObject when the Haskell object gets garbage collected. Returns the pointer to the underlying GObject.haskell-gi-baseVConstruct a Haskell wrapper for the given boxed object. We make a copy of the object.haskell-gi-baseLike i, but we do not make a copy (we "steal" the passed object, so now it is managed by the Haskell runtime).haskell-gi-base&Make a copy of the given boxed object.haskell-gi-baseLike B, but acting directly on a pointer, instead of a managed pointer.haskell-gi-baseWFree the memory associated with a boxed object. Note that this disowns the associated  via .haskell-gi-baseDisown a boxed object, that is, do not free the associated foreign GBoxed when the Haskell object gets garbage collected. Returns the pointer to the underlying .haskell-gi-base'Wrap a pointer, taking ownership of it.haskell-gi-base*Wrap a pointer, making a copy of the data.haskell-gi-base'Make a copy of a wrapped pointer using memcpy; into a freshly allocated memory region of the given size.haskell-gi-base*Print a debug message for deallocs if the HASKELL_GI_DEBUG_MEM$ environment variable has been set. None )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. None )( None )+<V$haskell-gi-baseConvert  into a ., using the GLib allocator..haskell-gi-baseGiven a set of pointers to blocks of memory of the specified size, copy the contents of these blocks to a freshly-allocated (with ) continuous area of memory.:      !"#$%&'()*+,-./012345:      !)*+,./0"#$%&'(-12345 None  );=EV]h+6haskell-gi-base A DictEntry ; is isomorphic to a two-tuple. Wrapping the values into a GVariantDictentry allows the ?! instance to do the right thing.8haskell-gi-baseHAn object representing a DBus signature, which is a particular type of ] too. (Just a string with some specific requirements.) In order to construct/deconstruct a 8 one can use c and d.9haskell-gi-baseJAn object representing a DBus object path, which is a particular type of ] too. (Just a string with some specific requirements.) In order to construct/deconstruct a 9 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 A and @V. For instance, to construct a single element tuple containing a string, you could do #toGVariant (GVariantSinglet "Test")>haskell-gi-baseThe typeclass for basic type , types, i.e. those that are not containers.?haskell-gi-baseCThe typeclass for types that can be automatically marshalled into  using @ and A.@haskell-gi-base2Convert a value of the given type into a GVariant.Ahaskell-gi-baseTry to decode a 8 into a target type. If the conversion fails we return #9. The type that was expected can be obtained by calling B,, and the actual type as understood by the " code can be obtained by calling gvariantToTypeString.Bhaskell-gi-baseDThe expected format string for this type (the argument is ignored).Chaskell-gi-base An alias for Nothing :: Maybe GVariant to save some typing.Dhaskell-gi-baseGet the expected type of a , in  notation. See  >https://developer.gnome.org/glib/stable/glib-GVariantType.html1 for the meaning of the resulting format string.Ehaskell-gi-baseTake ownership of a passed in C (typically created just for us, so if it is floating we sink it).Fhaskell-gi-base*Construct a Haskell wrapper for the given , without assuming ownership.Ghaskell-gi-base Remove a reference to the given .Hhaskell-gi-base Disown a X, i.e. do not unref the underlying object when the Haskell object is garbage collected.Yhaskell-gi-baseConvert a DBus handle (an  ) into a .Zhaskell-gi-baseExtract the DBus handle (an  ) inside a .]haskell-gi-baseDecode an UTF-8 encoded string  into .^haskell-gi-base Encode a  into an UTF-8 encoded string ._haskell-gi-baseVTry 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 9.ahaskell-gi-base Construct a 1 containing an object path. In order to build a 9 value see _.bhaskell-gi-base Extract a 9 from a !, represented as its underlying  representation.chaskell-gi-baseYTry to construct a DBus object path. If the passed string is not a valid DBus signature # will be returned.dhaskell-gi-base Return the  representation of a 8.ehaskell-gi-base Construct a 4 containing an DBus signature. In order to build a 8 value see c.fhaskell-gi-base Extract a 8 from a , represented as .ghaskell-gi-baseBox a  inside another .hhaskell-gi-baseUnbox a  contained inside another .ihaskell-gi-base/Extract a zero terminated list of bytes into a Y.jhaskell-gi-base Encode a Y into a list of bytes .khaskell-gi-base Convert a  value into a corresponding  of maybe type.lhaskell-gi-baseTry to decode a maybe  into the corresponding 5 type. If the conversion is successful this returns Just x , where x itself is of  type. So, in particular,  Just NothingT indicates a successful call, and means that the GVariant of maybe type was empty.mhaskell-gi-base Construct a " of type DictEntry from the given key and value. The key must be a basic O type, i.e. not a container. This is determined by whether it belongs to the > typeclass. On the other hand value is an arbitrary /, and in particular it can be a container type.nhaskell-gi-base Unpack a DictEntry variant into key and value@, which are returned as a two element tuple in case of success.ohaskell-gi-basePack a Map into a 1 for dictionary type, which is just an array of 6.phaskell-gi-base Unpack a  into a 9. Notice that this assumes that all the elements in the  array of 6= 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 r plus n directly.qhaskell-gi-base%Given a list of elements construct a  array containing them.rhaskell-gi-base Unpack a  array into its elements.shaskell-gi-baseGiven a list of , construct a , tuple containing the elements in the list.thaskell-gi-baseExtract the children of a  tuple into a list.yhaskell-gi-base:The empty tuple GVariant, mostly useful for type checking.haskell-gi-baseOne element tuples.?6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst??@AB>CD<=67:;9_`8cdEFGHJILKNMPORQTSVUXWZY\[]^bafehgijklmnopqrst None );=rhaskell-gi-baseNA convenience class for marshaling back and forth between Haskell values and s.haskell-gi-baseA type holding a d with an associated label. It is parameterized by a phantom type encoding the target type for the ' (useful when constructing properties).haskell-gi-baseA convenience alias for # ::  .haskell-gi-baseBuild a new, empty,  of the given type.haskell-gi-basePA convenience function for building a new GValue and setting the initial value.00None )VtE      !"#$%&'()*+,E  !$'*  #&),  "%(+None &')+-;=>?FSTVF-haskell-gi-baseConstraint on a obj/attr pair so that K is allowed..haskell-gi-baseConstraints on a obj/attr pair so J) is possible, producing a value of type result./haskell-gi-baseBConstructors for the different operations allowed on an attribute.0haskell-gi-baseAssign a value to an attribute1haskell-gi-base1Assign the result of an IO action to an attribute2haskell-gi-base(Apply an update function to an attribute3haskell-gi-base+Apply an IO update function to an attribute4haskell-gi-baseConstraint on a obj/value pair so that new works on values of type @value.5haskell-gi-baseConstraint on a obj/attr pair so that I works on values of type value.haskell-gi-base#A user friendly description of the 6$, useful when printing type errors.6haskell-gi-base$Possible operations on an attribute.;haskell-gi-baseWhether a given 62 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-base<Result of checking whether an op is allowed on an attribute.<haskell-gi-baseInfo describing an attribute.=haskell-gi-base1The operations that are allowed on the attribute.>haskell-gi-base"Constraint on the value being set.?haskell-gi-baseQConstraint on the type for which we are allowed to create/set/get the attribute.@haskell-gi-baseType returned by C.Ahaskell-gi-baseName of the attribute.Bhaskell-gi-base$Type which introduces the attribute.Chaskell-gi-base%Get the value of the given attribute.Dhaskell-gi-basefSet the value of the given attribute, after the object having the attribute has already been created.Ehaskell-gi-base(Set the value of the given attribute to NULL (for nullable attributes).Fhaskell-gi-baseBuild a GValue representing the attribute.Ghaskell-gi-baseA proxy for attribute labels.Ihaskell-gi-base+Set a number of properties for some object.Jhaskell-gi-base,Get the value of an attribute for an object.Khaskell-gi-baseSet a nullable attribute to NULL.Mhaskell-gi-baseSupport for overloaded labels.-./0213456789:;<A=>?@BFCDEGHIJK<A=>?@BFCDE6789:/0213;.54-JIKGH00102030None &')+,-;<=>?EFTV@haskell-gi-base Type for a  notify callback.Shaskell-gi-base_Connection information for a "notify" signal indicating that a specific property changed (see \ for the relevant constructor).Thaskell-gi-base.Whether to connect a handler to a signal with YH so that it runs before/after the default handler for the given signal.Uhaskell-gi-baseRun before the default handler.Vhaskell-gi-baseRun after the default handler.Whaskell-gi-base'Information about an overloaded signal.Yhaskell-gi-base4Connect a Haskell function to a signal of the given V, specifying whether the handler will be called before or after the default handler.Zhaskell-gi-base)Support for overloaded signal connectors.haskell-gi-base;A class that provides a constraint satisfied by every type.]haskell-gi-base Type of a  signal handler id.^haskell-gi-baseSame as YZ, specifying from the beginning that the handler is to be run before the default handler. [on object signal handler = liftIO $ connectSignal signal object handler SignalConnectBefore_haskell-gi-baseIConnect a signal to a handler, running the handler after the default one. ]after object signal handler = liftIO $ connectSignal signal object handler SignalConnectAfter`haskell-gi-base*Connect a signal to a handler, given as a .haskell-gi-base0Connect the given notify callback for a GObject.chaskell-gi-baseSupport for overloaded labels.STUVWXYZ[\]^_`^_Z[\TUV`]WXYSNone  )-FTVpehaskell-gi-baseMConstruct a GObject given the constructor and a list of settable attributes.haskell-gi-baseConstruct the  given the list of s.fhaskell-gi-baseConstruct the given /, given a set of actions constructing desired s to set at construction time.efefNone  )-;=>?FT@ghaskell-gi-base:Constructible types, i.e. those which can be allocated by h.ihaskell-gi-base%Default instance, assuming we have a .ghghNone )1Vjhaskell-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: Winstance GErrorClass PixbufError where gerrorClassDomain _ = "gdk-pixbuf-error-quark"lhaskell-gi-baseA human readable error message.mhaskell-gi-base3A code to identify a specific error within a given n. 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 v or x+, this is worked out for you automatically.nhaskell-gi-basejA 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-base A GQuark.ohaskell-gi-base_A GError, consisting of a domain, code and a human readable message. These can be accessed by r, s and t below.qhaskell-gi-base Create a new o.rhaskell-gi-base Return the domain for the given oD. This is a GQuark, a textual representation can be obtained with  !.shaskell-gi-baseThe numeric code for the given o.thaskell-gi-baseA text message describing the o.haskell-gi-base\Given the string representation of an error domain returns the corresponding error quark.uhaskell-gi-baseeThis will catch just a specific GError exception. If you need to catch a range of related errors, v* is probably more appropriate. Example: do image <- catchGErrorJust PixbufErrorCorruptImage loadImage (\errorMessage -> do log errorMessage return mssingImagePlaceholder)vhaskell-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 -> ... _ -> ...)whaskell-gi-base A verson of w# with the arguments swapped around.xhaskell-gi-base A verson of v# with the arguments swapped around.yhaskell-gi-base)Run the given function catching possible os in its execution. If a o5 is emitted this throws the corresponding exception.zhaskell-gi-baseLike yQ, but allows to specify a custom handler instead of just throwing the exception.{haskell-gi-baseIf the passed in  o is not #@, store a copy in the passed in pointer, unless the pointer is I.khaskell-gi-baseJThis must not use the value of its parameter so that it is safe to pass U.uhaskell-gi-baseThe error to catchhaskell-gi-baseThe computation to runhaskell-gi-base,Handler to invoke if an exception is raisedvhaskell-gi-baseThe computation to runhaskell-gi-base+Handler to invoke if an exception is raisedjklmnopqrstuvwxyz{oprstnmluvwxqjkyz{None ) KL X  PON2+"%#$ &('*-./1436587:9<;>=@?BAEDCFGHIJMQRSTUVYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst      !"#$%&'()*+,-./0213456789:;<A=>?@BFCDEGHKSTUVWXY]`efghjklmnopqrstuvwxyz{zMRY.436587:9<;>=@?BAFGHI&/EDCJ-('-./0213456789:;<A=>?@BFCDEGHKSTUVWXY]` KL PON X #$QT*"%UV2+1S "None )E Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst/0213IJZ\^_fhjklmnopqrstuvwxyz{/0213IJhfZ\^_#$%#$&#$'()*#$+#$,#$-#$.#/0#/1#23()4#$5#67#89(:;(:<(:=(:>(:?#@A#@B#@C#@D#$E(:F#GH#GI#GJ#GK#LM#LN(:O#PQ(:R#$S#$T(:U#VW#XY#XZ#8[#\#]^#_`#ab#cd#Ve#fg#hi#hj#kl#kl#km#km#kn#kn#ko#ko#kp#kp#kq#kq#kr#kr#ks#ks#tu#tv#tw#Lx#Ly#Lz#L#{|#2}#2~##6#6#6#$#$#$#$###P()              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ] ^ _ ` ` a a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrstuvwxyz{{|}~##t#V-haskell-gi-base-0.21.2-CI7cySoQQgr4HqHvunx3WjData.GI.Base.ShortPreludeData.GI.Base.OverloadingData.GI.Base.CallStackData.GI.Base.GTypeData.GI.Base.BasicTypesData.GI.Base.GHashTableData.GI.Base.UtilsData.GI.Base.ManagedPtrData.GI.Base.GParamSpecData.GI.Base.ClosureData.GI.Base.BasicConversionsData.GI.Base.GVariantData.GI.Base.GValueData.GI.Base.PropertiesData.GI.Base.AttributesData.GI.Base.SignalsData.GI.Base.GObjectData.GI.Base.ConstructibleData.GI.Base.GErrorData.MapMapData.ByteString ByteString Foreign.PtrnullPtr Control.MonadmaybeForeign.Concurrent newForeignPtrForeign.ForeignPtrnewForeignPtr_GI.GLib quarkToString Data.GI.BasebaseGHC.Base++map$ghc-prim GHC.Classes==fail>>=>>returnGHC.Real fromIntegral realToFracGHC.EnumEnumEqMonadGHC.ShowShowGHC.OverloadedLabelsIsLabel GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64MaybeIOGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtrSymbolGHC.Stack.Types CallStackFalseNothingJustTrueGHC.ForeignPtr ForeignPtrControl.Monad.IO.ClassliftIOMonadIO fromLabel>=>Data.TraversablemapM GHC.Stack callStackControl.Exception.Base onExceptionForeign.C.StringCStringunsafeForeignPtrToPtr GHC.ExceptionprettyCallStack Data.FoldablemapM_lengthForeign.C.TypesCIntCUIntCLongCULongCFloatCDoubleCIntPtrCUIntPtrForeign.StorablepokepeeksizeOfcastPtrToFunPtrcastFunPtrToPtrplusPtr Data.Functor<$>fromEnumtoEnumGHC.CharchrshowListshow showsPrec.ordwhen=<<GHC.Err undefinederror HasCallStack/=bytestring-0.10.8.2Data.ByteString.InternalGType gtypeToCGTypeCGType gtypeName gtypeString gtypePointergtypeInt gtypeUInt gtypeLong gtypeULong gtypeInt64 gtypeUInt64 gtypeFloat gtypeDouble gtypeBoolean gtypeBoxed gtypeObject gtypeInvalid gtypeVariant gtypeGType gtypeStrvgtypeByteArrayGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlag GParamSpecGVariant NullToNothing nullToNothingUnexpectedNullPointerReturnnullPtrErrorMsgGObject gobjectType WrappedPtrwrappedPtrCallocwrappedPtrCopywrappedPtrFree BoxedFlagsboxedFlagsType BoxedEnum boxedEnumType BoxedObject boxedTypeManagedPtrNewtype ManagedPtrmanagedForeignPtrmanagedPtrAllocCallStackmanagedPtrIsDisowned g_slist_free g_list_free&$fExceptionUnexpectedNullPointerReturn!$fShowUnexpectedNullPointerReturn$fNullToNothingMaybe$fNullToNothinga GEqualFunc GHashFunc gStrEqualgStrHash gDirectEqual gDirectHash ptrPackPtr ptrUnpackPtrcstringPackPtrcstringUnpackPtrMethodResolutionFailed MethodProxy MethodInfooverloadedMethod HasSignal ResolveSignal SignalListHasAttr HasAttributeResolveAttributeHasAttributeList AttributeList ParentTypesIsDescendantOfUnknownAncestorError IsLabelProxyfromLabelProxy$fHasAttributeListka$fHasAttrattrosafeFreeFunPtrPtrsafeFreeFunPtr ptr_to_g_freefreeMemwhenJustmaybeM maybeFromPtrmapFirst mapSecond mapFirstA mapSecondAconvertIfNonNullconvertFunPtrIfNonNull callocBytes callocMemcallocBoxedBytes allocBytesallocMemmemcpymaybeReleaseFunPtrcheckUnexpectedReturnNULLcheckUnexpectedNothingdbgLog newManagedPtrnewManagedPtr'newManagedPtr_disownManagedPtrwithManagedPtrmaybeWithManagedPtrwithManagedPtrList withTransientunsafeManagedPtrGetPtrunsafeManagedPtrCastPtrtouchManagedPtrcastTo unsafeCastTo newObject wrapObject unrefObject disownObjectnewBoxed wrapBoxed copyBoxed copyBoxedPtr freeBoxed disownBoxedwrapPtrnewPtr copyBytes noGParamSpecwrapGParamSpecPtrnewGParamSpecFromPtrunrefGParamSpecdisownGParamSpecClosure noClosure newCClosure$fBoxedObjectClosureunrefGHashTableunrefGByteArray 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$fEqGVariantSinglet$fShowGVariantSinglet$fEqGVariantHandle$fOrdGVariantHandle$fShowGVariantHandle$fOrdGVariantObjectPath$fEqGVariantObjectPath$fShowGVariantObjectPath$fOrdGVariantSignature$fEqGVariantSignature$fShowGVariantSignature$fEqGVariantDictEntry$fShowGVariantDictEntryIsGValuetoGValue fromGValueGValueConstructGValuenoGValue newGValue buildGValue 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$fBoxedObjectGValue$fIsGValueGType$fIsGValueBool$fIsGValueDouble$fIsGValueFloat$fIsGValueWord64$fIsGValueInt64$fIsGValueCULong$fIsGValueCLong$fIsGValueCUInt$fIsGValueCInt$fIsGValueWord32$fIsGValueInt32 $fIsGValuePtr$fIsGValueMaybe$fIsGValueMaybe0setObjectPropertyStringconstructObjectPropertyStringgetObjectPropertyStringsetObjectPropertyPtrconstructObjectPropertyPtrgetObjectPropertyPtrsetObjectPropertyIntconstructObjectPropertyIntgetObjectPropertyIntsetObjectPropertyUIntconstructObjectPropertyUIntgetObjectPropertyUIntsetObjectPropertyLongconstructObjectPropertyLonggetObjectPropertyLongsetObjectPropertyULongconstructObjectPropertyULonggetObjectPropertyULongsetObjectPropertyInt32constructObjectPropertyInt32getObjectPropertyInt32setObjectPropertyUInt32constructObjectPropertyUInt32getObjectPropertyUInt32setObjectPropertyInt64constructObjectPropertyInt64getObjectPropertyInt64setObjectPropertyUInt64constructObjectPropertyUInt64getObjectPropertyUInt64setObjectPropertyFloatconstructObjectPropertyFloatgetObjectPropertyFloatsetObjectPropertyDoubleconstructObjectPropertyDoublegetObjectPropertyDoublesetObjectPropertyBoolconstructObjectPropertyBoolgetObjectPropertyBoolsetObjectPropertyGTypeconstructObjectPropertyGTypegetObjectPropertyGTypesetObjectPropertyObjectconstructObjectPropertyObjectgetObjectPropertyObjectsetObjectPropertyBoxedconstructObjectPropertyBoxedgetObjectPropertyBoxedsetObjectPropertyStringArray"constructObjectPropertyStringArraygetObjectPropertyStringArraysetObjectPropertyEnumconstructObjectPropertyEnumgetObjectPropertyEnumsetObjectPropertyFlagsconstructObjectPropertyFlagsgetObjectPropertyFlagssetObjectPropertyVariantconstructObjectPropertyVariantgetObjectPropertyVariantsetObjectPropertyByteArray constructObjectPropertyByteArraygetObjectPropertyByteArraysetObjectPropertyPtrGListconstructObjectPropertyPtrGListgetObjectPropertyPtrGListsetObjectPropertyHashconstructObjectPropertyHashgetObjectPropertyHash AttrClearCAttrGetCAttrOp:=:=>:~:~>AttrConstructCAttrSetC AttrOpTagAttrGetAttrSet AttrConstruct AttrClear AttrOpAllowedAttrInfoAttrAllowedOpsAttrSetTypeConstraintAttrBaseTypeConstraint AttrGetType AttrLabel AttrOriginattrGetattrSet attrClear attrConstructAttrLabelProxysetgetclear$fIsLabelxAttrLabelProxy$fIsLabelProxyxAttrLabelProxy $fEqAttrOpTag$fOrdAttrOpTag$fEnumAttrOpTag$fBoundedAttrOpTag$fShowAttrOpTagGObjectNotifySignalInfoSignalConnectModeSignalConnectBeforeSignalConnectAfter SignalInfoHaskellCallbackType connectSignal SignalProxyPropertyNotifySignalHandlerIdonafterconnectSignalFunPtr$fNoConstraintka$fIsLabelslotSignalProxy$fIsLabelProxyslotSignalProxy#$fSignalInfoGObjectNotifySignalInfoconstructGObjectnew' Constructiblenew$fConstructibleatag GErrorClassgerrorClassDomain GErrorMessage GErrorCode GErrorDomainGError gerrorNew gerrorDomain gerrorCode gerrorMessagecatchGErrorJustcatchGErrorJustDomainhandleGErrorJusthandleGErrorJustDomainpropagateGError checkGErrormaybePokeGError$fBoxedObjectGError$fExceptionGError $fShowGError Data.ProxyProxy SignalCheckAttributeCheckIsElemCheckForAncestorType AncestorCheck FindElement JoinListsStorabledbg_g_object_disownownedFinalizerprintAllocDebug FinalizerPtrnotOwnedWarningnullPtrWarning dbgDealloc text-1.2.3.0Data.Text.InternalTextcontainers-0.5.11.0Data.Map.Internal AttrOpTextAttrOpIsAllowed OpAllowedGObjectNotifyCallback NoConstraintconnectGObjectNotifydoConstructGObjectGQuarkgErrorQuarkFromDomain