m6      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q rstuvwxyz{|}~Safe+F& (,SS ,(Safe,V7The Haskell type corresponding to a gint on the C side.W9The Haskell type corresponding to a GQuark on the C side.X*The size in bytes of a GValue struct in C.YThe offset in bytes inside a GError of its domain field.ZThe offset in bytes inside a GError of its code field.[The offset in bytes inside a GError of its emssage field.VWXYZ[WVXYZ[None+-1;<=>?FSTV`#]3Destroy the memory associated with a given pointer.^Some APIs, such as eU, pass around scalar types wrapped into a pointer. We encode such a type as follows.aA  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.cA  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.eA  =https://developer.gnome.org/glib/stable/glib-Hash-Tables.html GHashTable. It is mapped to a  on the Haskell side.gA  =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.iA  @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.kA  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.m(An enum usable as a flag for a function.nA  Bhttps://developer.gnome.org/gobject/stable/gobject-GParamSpec.html GParamSpec. See Data.GI.Base.GParamSpec for further methods.pA  :https://developer.gnome.org/glib/stable/glib-GVariant.htmlGVariant. See Data.GI.Base.GVariant for further methods.rA 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 .u&A newtype for use on the Haskell side.xA 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 u below.yFlags with an associated u.zEnums with an associated u.{ A wrapped {*, or any other type that descends from it.|cChunks of memory whose allocation/deallocation info has been registered with the GLib type system.}[A wrapped object that has an associated GLib type. This does not necessarily descend from {%, that constraint is implemented by { below.~The u for this object.JA ptr to a memory block which we know how to allocate and fill with zero.?Allocate a zero-initialized block of memory for the given type.DPointers to chunks of memory which we know how to copy and release.Make a copy of the given .6A pointer to a function for freeing the given pointer.?A constraint ensuring that the given type is a newtype over a .Thin wrapper over #", supporting the extra notion of  disowningG, that is, not running the finalizers associated with the foreign ptr. ' for the call that created the pointer.When disowned, the   for the disowning call.Free the given a.Free the given c.#Get the name assigned to the given u.A convenient synonym for Nothing :: Maybe GParamSpec.Two 0s are equal if they wrap the same underlying C .A default instance for  IsManagedPtr for newtypes over .2]^_`abcdefghijklmnopqrstuvwxyz{|}~2rst}~{uvwxpq|zynoklijghefcdabm^_`]Nonev? %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 x6 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.u of strings.u of pointers.u for signed integers (gint or gint32).u for unsigned integers (guint or guint32).u for glong.u for gulong.u for signed 64 bit integers.u for unsigned 64 bit integers.u for floating point values.u for gdouble.u corresponding to gboolean.u! corresponding to a boxed object.u corresponding to a GObject. An invalid u> used as error return value in some functions which return a u.The u corresponding to a GVariant.The u corresponding to .u corresponding to a u itself.u( for a NULL terminated array of strings.u for a boxed type holding a  GByteArray.The u for boxed  StablePtrs.None}| 9A pointer to an equality checking function on the C side..A pointer to a hashing function on the C side.Check whether two * s are equal.Compute the hash for a *.%Check whether two pointers are equal.Compute the hash for a .Pack a  into a ^ . Extract a  from a ^ .Pack a * into a  than can go into a  GHashTable. Extract a * wrapped into a  coming from a  GHashTable. None.Args are zero_terminated, clear_, element_size Allocate a k! with elements of the given size.None+,-;<=>?FSTg\MA constraint on a type, to be fulfilled whenever it has a type instance for I. This leads to nicer errors, thanks to the overlappable instance below.OClass for types containing the information about an overloaded method of type o -> s.gReturned when the method is not found, hopefully making the resulting error messages somewhat clearer.NA constraint that always fails with a type error, for documentation purposes.]A constraint enforcing that the signal exists for the given object, or one of its ancestors.MReturn the type encoding the signal information for a given type and signal.The list of signals defined for a given type. Each element of the list is a tuple, with the first element of the tuple the name of the signal, and the second the type encoding the information of the signal. This type will be an instance of  .EA constraint that enforces that the given type has a given attribute.DA constraint imposing that the given object has the given attribute.=Whether a given type is in the given list. If found, return success, otherwise return failure.SReturn the type encoding the attribute information for a given type and attribute.MA constraint on a type, to be fulfilled whenever it has a type instance for *. This is here for nicer error reporting.The list of attributes defined for a given type. Each element of the list is a tuple, with the first element of the tuple the name of the attribute, and the second the type encoding the information of the attribute. This type will be an instance of ._All the types that are ascendants of this type, including interfaces that the type implements.$Check that a type is in the list of  of another type.xCheck whether a type appears in a list. We specialize the names/types a bit so the error messages are more informative.Look in the given list of (symbol, tag) tuples for the tag corresponding to the given symbol. If not found raise the given type error./Safe coercions to a parent class. For instance: #show $ label `asA` Gtk.WidgetTDefault instance, which will give rise to an error for types without an associated  instance.TDefault instance, which will give rise to an error for types without an associated .\\ None +<NVi A pointer to .ESame as freeHaskellFunPtr, but it does nothing when given a nullPtr. Pointer to g_free.A wrapper for g_free.ZWhen the given value is of "Just a" form, execute the given action, otherwise do nothing.Like  !J, but for actions on a monad, and with slightly different argument order.Check if the pointer is E, and wrap it on a  accordingly.dGiven a function and a list of two-tuples, apply the function to every first element of the tuples.Same for the second element.Applicative version of .Applicative version of .\Apply the given conversion action to the given pointer if it is non-NULL, otherwise return !.eApply the given conversion action to the given function pointer if it is non-NULL, otherwise return !.7Make a zero-filled allocation using the GLib allocator.@Make a zero-filled allocation of enough size to hold the given  type, using the GLib allocator.xMake 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.<Allocate the given number of bytes using the GLib allocator.Allocate space for the given  using the GLib allocator._Copy memory into a destination (in the first argument) from a source (in the second argument).4If 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.=Check that the given pointer is not NULL. If it is, raise a r exception.An annotated version of fromJust, which raises a r in case it encounters a !.qPrint a string to the debug log in an atomic way (so the output of different threads does not get intermingled). None +<FVi"bPrint some debug info (if the right environment valiable is set) about the object being disowned.Thin wrapper over "#.KRun the finalizer for an owned pointer, assuming it has now been disowned./Print some debug diagnostics for an allocation. Version of  taking a  and a corresponding , as in $#.Thin wrapper over "%.:Do not run the finalizers upon garbage collection of the .Perform an IO action on the  inside a managed pointer.Like , but accepts a  type. If the passed value is !+ the inner action will be executed with a E argument.&Perform an IO action taking a list of  on a list of managed pointers.Perform 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. 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.Same as ), but is polymorphic on the return type.=Print a warning when we try to access a disowned foreign ptr.Ensure 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.@Check whether the given object is an instance of the given type.`Cast from one object type to another, checking that the cast is valid. If it is not, we return !. Usage: "maybeWidget <- castTo Widget labelXCast a typed object to a new type (without any assumption that both types descend from {A), assuming that the cast will succeed. This function will call R if the cast is illegal.kPrint a warning when receiving a null pointer in a function that did not expect one, for easier debugging."Construct a Haskell wrapper for a {b, increasing its reference count, or taking ownership of the floating reference if there is one.Same as ', but we steal ownership of the object.Unref the given {[ and disown it. Use this if you want to manually release the memory associated to a given { (assuming that no other reference to the underlying C object exists) before the garbage collector does it. It is typically not safe to access the { after calling this function.*Decrease the reference count of the given {[. The memory associated with the object may be released if the reference count reaches 0.Disown 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.VConstruct a Haskell wrapper for the given boxed object. We make a copy of the object.Like i, but we do not make a copy (we "steal" the passed object, so now it is managed by the Haskell runtime).&Make a copy of the given boxed object.Like B, but acting directly on a pointer, instead of a managed pointer.WFree the memory associated with a boxed object. Note that this disowns the associated  via .Disown 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 |.'Wrap a pointer, taking ownership of it.*Wrap a pointer, making a copy of the data.'Make a copy of a wrapped pointer using memcpy; into a freshly allocated memory region of the given size.Same as  dbgDeallocPtr , but for *s, and no callstack needs to be provided. None-FT .The basic type. This corresponds to a wrapped GClosure) on the C side, which is a boxed object.A convenience alias for Nothing :: Maybe (GClosure a). Create a new  holding the given $. Note that after calling this the  will be freed whenever the N is garbage collected, so it is generally not safe to refer to the generated  after this function returns.Take ownership of a passed in  to a .$Construct a Haskell wrapper for the , without assuming ownership.*Decrease the reference count of the given @. If the reference count reaches 0 the memory will be released. UDisown (that is, remove from te purview of the Haskell Garbage Collector) the given . 2s are registered as boxed in the GLib type system. Find the associated u for the given closure.  None+<VCGiven a Haskell list of items, construct a GList with those values.8Given a GSList construct the corresponding Haskell list.DGiven a Haskell list of items, construct a GSList with those values.8Given a GSList construct the corresponding Haskell list.5Convert  into a *, using the GLib allocator.?Given 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.:  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF:  !"/012+,.-#$%&'()*:;<=?@A3456789>BCDEFNone;=V]U6+G A DictEntry p; is isomorphic to a two-tuple. Wrapping the values into a GVariantDictentry allows the P! instance to do the right thing.IHAn object representing a DBus signature, which is a particular type of p] too. (Just a string with some specific requirements.) In order to construct/deconstruct a I one can use t and u.JJAn object representing a DBus object path, which is a particular type of p] too. (Just a string with some specific requirements.) In order to construct/deconstruct a J one can use p and q.MHaskell has no notion of one element tuples, but GVariants do, so the following allows for marshalling one element tuples properly using R and QV. For instance, to construct a single element tuple containing a string, you could do #toGVariant (GVariantSinglet "Test")OThe typeclass for basic type p, types, i.e. those that are not containers.PCThe typeclass for types that can be automatically marshalled into p using Q and R.Q2Convert a value of the given type into a GVariant.RTry to decode a p8 into a target type. If the conversion fails we return !9. The type that was expected can be obtained by calling S,, and the actual type as understood by the p" code can be obtained by calling gvariantToTypeString.SDThe expected format string for this type (the argument is ignored).T An alias for Nothing :: Maybe GVariant to save some typing.UGet the expected type of a p, in p notation. See  >https://developer.gnome.org/glib/stable/glib-GVariantType.html1 for the meaning of the resulting format string.VTake ownership of a passed in C (typically created just for us, so if it is floating we sink it).W*Construct a Haskell wrapper for the given p, without assuming ownership.X Remove a reference to the given p.Y Disown a pX, i.e. do not unref the underlying object when the Haskell object is garbage collected.jConvert a DBus handle (an  ) into a p.kExtract the DBus handle (an  ) inside a p.nDecode an UTF-8 encoded string p into .o Encode a  into an UTF-8 encoded string p.pVTry to construct a DBus object path. If the passed string is not a valid object path ! will be returned.q Return the  representation of a J.r Construct a p1 containing an object path. In order to build a J value see p.s Extract a J from a p!, represented as its underlying  representation.tYTry to construct a DBus object path. If the passed string is not a valid DBus signature ! will be returned.u Return the  representation of a I.v Construct a p4 containing an DBus signature. In order to build a I value see t.w Extract a I from a p, represented as .xBox a p inside another p.yUnbox a p contained inside another p.z/Extract a zero terminated list of bytes into a U.{ Encode a U into a list of bytes p.| Convert a  value into a corresponding p of maybe type.}Try to decode a maybe p 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.~ Construct a p" of type DictEntry from the given key and value. The key must be a basic pO type, i.e. not a container. This is determined by whether it belongs to the O typeclass. On the other hand value is an arbitrary p/, and in particular it can be a container type. Unpack a DictEntry variant into key and value@, which are returned as a two element tuple in case of success.Pack a Map into a p1 for dictionary type, which is just an array of G. Unpack a p into a 9. Notice that this assumes that all the elements in the p array of G= are of the same type, which is not necessary for a generic pQ, so this is somewhat restrictive. For the general case it is necessary to use  plus  directly.%Given a list of elements construct a p array containing them. Unpack a p array into its elements.Given a list of p, construct a p, tuple containing the elements in the list.Extract the children of a p tuple into a list.:The empty tuple GVariant, mostly useful for type checking.One element tuples.?GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~?PQRSOTUMNGHKLJpqItuVWXY[Z]\_^a`cbedgfihkjmlnosrwvyxz{|}~None -;=FTi NA convenience class for marshaling back and forth between Haskell values and s.A 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-side representation of a GValue.A convenience alias for ! ::  .Build a new, empty,  of the given type.Take ownership of a passed in .*Construct a Haskell wrapper for the given , making a copy.PA convenience function for building a new GValue and setting the initial value. Disown a X, i.e. do not unref the underlying object when the Haskell object is garbage collected. Return the u contained by a . Unset the ), freeing all resources associated to it.Set the value of  containing a Like  , but the  takes ownership of the Get the value of a  containing a :Pack the given list of GValues contiguously into a C array=Unpack an array of contiguous GValues into a list of GValues. Map over the s inside a C array.2s are registered as boxed in the GLib type system.Find the associated u for .;;None&'+,-7;=>?FSTVi?,Constraint on a obj/attr pair so that * is allowed.Constraints on a obj/attr pair so )) is possible, producing a value of type result. BConstructors for the different operations allowed on an attribute. Assign a value to an attribute 1Assign the result of an IO action to an attribute (Apply an update function to an attribute +Apply an IO update function to an attribute;Assign a value to an attribute, allocating any necessary memory for representing the Haskell value as a C value. Note that it is the responsibility of the caller to make sure that the memory is freed when no longer used, otherwise there will be a memory leak. In the majority of cases you probably want to use  | instead, which has no potential memory leaks (at the cost of sometimes requiring some explicit Haskell -> C marshalling).-Connect the given signal to a signal handler.Constraint on a obj/value pair so that & works on values of type value.Constraint on a obj/attr pair so that ( works on values of type value.#A user friendly description of the $, useful when printing type errors.$Possible operations on an attribute.8It is possible to read the value of the attribute with ).9It is possible to write the value of the attribute with (.5It is possible to set the value of the attribute in &.DIt is possible to clear the value of the (nullable) attribute with *.ICheck if the given element is a member, and if so raise the given error._Error to be raised when AttrConstruct is allowed, but an implementation has not been provided.YError to be raised when AttrSet is allowed, but an implementation has not been provided.YError to be raised when AttrGet is allowed, but an implementation has not been provided.[Error to be raised when AttrClear is allowed, but an implementation has not been provided.^Error to be raised when an operation is allowed, but an implementation has not been provided.Whether a given 2 is allowed on an attribute, given the info type. +Look in the given list to see if the given  + is a member, if not return an error type. ]Pretty print a type, indicating the parent type that introduced the attribute, if different.Info describing an attribute.1The operations that are allowed on the attribute.QConstraint on the type for which we are allowed to create/set/get the attribute.Type returned by !."Constraint on the value being set.AConstraint on the value being set, with allocation allowed (see  below).#Type resulting from the allocation.Name of the attribute. $Type which introduces the attribute.!%Get the value of the given attribute."fSet the value of the given attribute, after the object having the attribute has already been created.#(Set the value of the given attribute to NULL (for nullable attributes).$Build a ' representing the attribute.%Allocate memory as necessary to generate a settable type from the transfer type. This is useful for types which needs allocations for marshalling from Haskell to C, this makes the allocation explicit.&A proxy for attribute labels.(+Set a number of properties for some object.),Get the value of an attribute for an object.*Set a nullable attribute to NULL.$      $%!"#&'()*$ $%!"#     )(*&' 0 0 0 0None*1A 1, which is simply an integer.3)Construct a GQuark from the given string.123123None "#QVbi)4"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.YBeyond 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 blurbT, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized.="Information on a property of type 0 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.YBeyond 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 blurbT, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized.?Identifier for the property.@#Identifier for display to the user.ADescription of the property.BDefault value.C0Handler invoked when the property is being set.D8Handler that returns the current value of the property.ESet of flags, or ! for the default set of flags.FMinimum value, or !, which would be replaced by MININT.GMaximum value, or !, which would be replaced by MAXINT.HInformation 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.YBeyond 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 blurbT, which should be a somewhat longer description, suitable for e.g. a tooltip. The nick and blurb should ideally be localized.JIdentifier for the property.K#Identifier for display to the user.LDescription of the property.M0Handler invoked when the property is being set.N8Handler that returns the current value of the property.OSet of flags, or ! for the default set of flags. =The basic constructor for a GObject. They are all isomorphic.P-Low-level getter and setter for the property.T7Flags controlling the behaviour of the the parameters. Uthe parameter is readable Vthe parameter is writable W3the parameter will be set upon object construction X7the parameter can only be set upon object construction Y calls to ()r 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. ZCatch-all for unknown values[(Take ownership of a ParamSpec passed in .\*Construct a Haskell wrapper for the given n, without assuming ownership.] Remove a reference to the given n.^ Disown a n3, i.e. do not longer unref the associated foreign n when the Haskell n gets garbage collected. 2Default set of flags when constructing properties. The 13 pointing to the setter and getter of the property.6Construct a copy of the object from the given pointer.4Wrap a Haskell getter/setter into a lower level one._ Create a n for a Haskell value.` Create a n for an integer param.a Create a n for a string param.Set the given user data on the n. Get the user data for the given 1 on the n.b<Attempt to get the Haskell setter and getter for the given n$. This will only be possible if the na was created with one of the functions above, if this is not the case the function will return !.Haskell side getterHaskell side setterSetter for the /456:;<789=>?ECD@ABFGHIJOMNKLPQRSTUVWXYZ[\]^_`ab/[\]^HIJOMNKL_456:;<789a=>?ECD@ABFG`TUVWXYZPQRSb None&'+,-;<=>?FSTVir Type of a { signal handler id.)Support for overloaded signal connectors.'Information about an overloaded signal. The type for the signal handler.5Connect a Haskell function to a signal of the given {U, specifying whether the handler will be called before or after the default handler..Whether to connect a handler to a signal with H so that it runs before/after the default handler for the given signal.Run before the default handler.Run after the default handler.%Connect a signal to a signal handler.hlGenerate an informative type error whenever one tries to use a signal for which code generation has failed. Type for a { "notify" callback.i_Connection information for a "notify" signal indicating that a specific property changed (see l for the relevant constructor).jA basic signal name connector.k+A signal connector annotated with a detail.lA signal connector for the notify signal on the given property.mIConnect a signal to a handler, running the handler after the default one.9Given a signal proxy, determine the corresponding detail.n*Connect a signal to a handler, given as a .o)Disconnect a previously connected signal.0Connect the given notify callback for a GObject.pSupport for overloaded labels.jlkhimnomjlknoihNone&'-<FTVi$'r?This typeclass contains the data necessary for defining a new { type from Haskell.sThe parent typet+Type of the private data for each instance.u&Name of the type, it should be unique.vlCode to run when the class is inited. This is a good place to register signals and properties for the type.wCode 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).xWrapper around  GObjectClass on the C-side.zRConstruct a GObject given the constructor and a list of settable attributes. See & for a more general version.{Construct the given {/, given a set of actions constructing desired s to set at construction time.Construct the { given the list of s.| Find the u associated to a given x.} Find the u for a given {.~!Register the given type into the GObject' type system and return the resulting u_, if it has not been registered already. If the type has been registered already the existing u will be returned instead.ENote that for this function to work the type must be an instance of r.<Quark with the key to the private data for this object type.6Get the private data associated with the given object.,Get the value of a given key for the object.-Set the value of the user data for the given { to a  StablePtr" to the given Haskell object. The  StablePtrG will be freed when the object is destroyed, or the value is replaced.A combination of  and , for convenience.Like , but it works on the raw object pointer. Note that this is unsafe, unless used in a context where we are sure that the GC will not release the object while we run.6Set the private data associated with the given object.*Set the private data for a given instance.-Modify the private data for the given object.?Add a Haskell object-valued property to the given object class.Add a +,+-valued property to the given object class.Add a *+-valued property to the given object class.rstuvwxyz{|}~z{rstuvw~xy|}None -;=>?FT(':Constructible types, i.e. those which can be allocated by .EAllocate a new instance of the given type, with the given attributes.%Default instance, assuming we have a {.None -1FTVWEach 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"A human readable error message.3A 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.jA 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._A GError, consisting of a domain, code and a human readable message. These can be accessed by ,  and  below. Create a new . Return the domain for the given D. This is a GQuark, a textual representation can be obtained with -..The numeric code for the given .A text message describing the .\Given the string representation of an error domain returns the corresponding error quark.eThis 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)Catch all GErrors from a particular error domain. The handler function should just deal with one error enumeration type. If you need to catch errors from more than one error domain, use this function twice with an appropriate handler functions for each. catchGErrorJustDomain loadImage (\err message -> case err of PixbufErrorCorruptImage -> ... PixbufErrorInsufficientMemory -> ... PixbufErrorUnknownType -> ... _ -> ...) A verson of # with the arguments swapped around. A verson of # with the arguments swapped around.)Run the given function catching possible s in its execution. If a 5 is emitted this throws the corresponding exception.Like Q, but allows to specify a custom handler instead of just throwing the exception.If the passed in   is not !@, store a copy in the passed in pointer, unless the pointer is E.2s are registered as boxed in the GLib type system.JThis must not use the value of its parameter so that it is safe to pass Q.The error to catchThe computation to run,Handler to invoke if an exception is raisedThe computation to run+Handler to invoke if an exception is raisedNoneX GH T  LKJ.'!"#%$&)*+-0/21436587:9<;>=A@?BCDEFIMNOPQRU]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      $%!"#&'*456:;<789=>?ECD@ABFGHIJOMNKLPQRSTUVWXYZ[\]^_`abinrstuvwxyz{|}~~INU*0/21436587:9<;>=BCDE#+A@?F)%$      $%!"#&'*in GH LKJ T !"MP&QR.'-O NoneVif(Set a property of type .Construct a property of type .$Get the value of a property of type .Set a property of type .Construct a property of type .$Get the value of a property of type .QQ/Noneh]^_`abcdefghijklmnopqrstuvwxyz{|}~lk  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ()m     ()lkm01201301456701801901:01;0<=0<>0?@56A01B0CD5EF5EG5EH5EI5EJ0KL0KM0KN0KO01P5EQ0RS0RT0RU0RV0WX0WY5EZ0[\01]01^0_`0ab0ac0 d0ef0gh0ij0kl0_m0no0pq0pr0s,0s,0st0st0su0su0sv0sv0sw0sw0sx0sx0sy0sy0sz0sz0{|0{}0{~0W0W0W0W00?0?00C0C0C01010101000[56                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 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 xyyz{||}}~''      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRSTUVWXYZ[\\]^_`abcddefghijklmnnopqrstuuvwxyz{|}~          &     0{   0_    !"0#$%&'()*+,-./01234 5 6 789:;<=haskell-gi-base-0.24.4-inplaceData.GI.Base.ShortPreludeData.GI.Base.CallStackData.GI.Base.Internal.CTypesData.GI.Base.OverloadingData.GI.Base.BasicTypesData.GI.Base.GTypeData.GI.Base.GHashTableData.GI.Base.GArrayData.GI.Base.SignalsData.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.GObjectData.GI.Base.ConstructibleData.GI.Base.GErrorData.GI.Base.PropertiesData.MapMapData.ByteString ByteString Foreign.PtrnullPtrGError SignalInfoAttrInfo Control.MonadmaybeForeign.Concurrent newForeignPtrForeign.ForeignPtrnewForeignPtr_newGValueGI.GObject.Objects.ObjectobjectSetProperty objectNotify Foreign.CCIntGI.GLib quarkToString Data.GI.BasebaseGHC.Base++map$ghc-prim GHC.Classes==fail>>=>>returnGHC.Real fromIntegral realToFracGHC.EnumEnumEqMonadGHC.ShowShow GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64MaybeIOGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtrSymbolGHC.Stack.Types CallStackNothingJustGHC.ForeignPtr ForeignPtrControl.Monad.IO.ClassliftIOMonadIO>=>Data.TraversablemapM GHC.Stack callStackControl.Exception.Base onExceptionForeign.C.StringCStringunsafeForeignPtrToPtr GHC.ExceptionprettyCallStack Data.FoldablemapM_lengthForeign.C.TypesCUIntCLongCULongCFloatCDoubleCIntPtrCUIntPtrForeign.StorablepokepeeksizeOfcastPtrToFunPtrcastFunPtrToPtrplusPtr Data.Functor<$>fromEnumtoEnumGHC.CharchrshowListshow showsPrec.ordwhen=<<GHC.Err undefinederror HasCallStack/=bytestring-0.10.8.2Data.ByteString.InternalC_gintGQuark cgvalueSizegerror_domain_offsetgerror_code_offsetgerror_message_offsetHasParentTypesGDestroyNotify PtrWrapped unwrapPtrGSListGList GHashTable GByteArray GPtrArrayGArrayIsGFlag GParamSpecGVariantUnexpectedNullPointerReturnnullPtrErrorMsgGType gtypeToCGTypeCGType BoxedFlags BoxedEnumGObjectGBoxed TypedObjectglibType CallocPtrboxedPtrCallocBoxedPtr boxedPtrCopy boxedPtrFreeManagedPtrNewtype toManagedPtr ManagedPtrmanagedForeignPtrmanagedPtrAllocCallStackmanagedPtrIsDisowned g_slist_free g_list_free gtypeName noGParamSpec$fEqManagedPtr$fManagedPtrNewtypea&$fExceptionUnexpectedNullPointerReturn!$fShowUnexpectedNullPointerReturn $fEqGType $fShowGType 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$fHasAttrattroSignalHandlerId SignalProxyHaskellCallbackType connectSignalSignalConnectModeSignalConnectBeforeSignalConnectAfteronsafeFreeFunPtrPtrsafeFreeFunPtr 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$fEqGVariantSinglet$fShowGVariantSinglet$fEqGVariantHandle$fOrdGVariantHandle$fShowGVariantHandle$fOrdGVariantObjectPath$fEqGVariantObjectPath$fShowGVariantObjectPath$fOrdGVariantSignature$fEqGVariantSignature$fShowGVariantSignature$fEqGVariantDictEntry$fShowGVariantDictEntryIsGValuetoGValue fromGValueGValueConstructnoGValue newGValue wrapGValuePtrnewGValueFromPtr buildGValue disownGValue gvalueType 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:=:=>:~:~>:&=OnAttrConstructCAttrSetC AttrOpTagAttrGetAttrSet AttrConstruct AttrClear AttrOpAllowedAttrAllowedOpsAttrBaseTypeConstraint AttrGetTypeAttrSetTypeConstraintAttrTransferTypeConstraintAttrTransferType AttrLabel AttrOriginattrGetattrSet attrClear attrConstruct attrTransferAttrLabelProxysetgetclear$fIsLabelxAttrLabelProxy $fEqAttrOpTag$fOrdAttrOpTag$fEnumAttrOpTag$fBoundedAttrOpTag$fShowAttrOpTaggQuarkFromStringCStringPropertyInfo$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$fEqGParamFlagSignalCodeGenErrorGObjectNotifySignalInfo:::PropertyNotifyafterconnectSignalFunPtrdisconnectSignalHandler$fIsLabelslotSignalProxy#$fSignalInfoGObjectNotifySignalInfoDerivedGObjectGObjectParentTypeGObjectPrivateDataobjectTypeNameobjectClassInitobjectInstanceInit GObjectClassconstructGObjectnew'gtypeFromClassgtypeFromInstance registerGTypegobjectGetPrivateDatagobjectGetUserDatagobjectSetUserDatagobjectModifyUserDatagobjectSetPrivateDatagobjectModifyPrivateDatagobjectInstallPropertygobjectInstallCIntPropertygobjectInstallCStringProperty Constructible$fConstructibleatag GErrorClassgerrorClassDomain GErrorMessage GErrorCode GErrorDomain gerrorNew gerrorDomain gerrorCode gerrorMessagecatchGErrorJustcatchGErrorJustDomainhandleGErrorJusthandleGErrorJustDomainpropagateGError checkGErrormaybePokeGError$fGBoxedGError$fTypedObjectGError$fHasParentTypesGError$fExceptionGError $fShowGErrorsetObjectPropertyStringconstructObjectPropertyStringgetObjectPropertyStringsetObjectPropertyPtrconstructObjectPropertyPtrgetObjectPropertyPtrsetObjectPropertyIntconstructObjectPropertyIntgetObjectPropertyIntsetObjectPropertyUIntconstructObjectPropertyUIntgetObjectPropertyUIntsetObjectPropertyLongconstructObjectPropertyLonggetObjectPropertyLongsetObjectPropertyULongconstructObjectPropertyULonggetObjectPropertyULongsetObjectPropertyInt32constructObjectPropertyInt32getObjectPropertyInt32setObjectPropertyUInt32constructObjectPropertyUInt32getObjectPropertyUInt32setObjectPropertyInt64constructObjectPropertyInt64getObjectPropertyInt64setObjectPropertyUInt64constructObjectPropertyUInt64getObjectPropertyUInt64setObjectPropertyFloatconstructObjectPropertyFloatgetObjectPropertyFloatsetObjectPropertyDoubleconstructObjectPropertyDoublegetObjectPropertyDoublesetObjectPropertyBoolconstructObjectPropertyBoolgetObjectPropertyBoolsetObjectPropertyGTypeconstructObjectPropertyGTypegetObjectPropertyGTypesetObjectPropertyObjectconstructObjectPropertyObjectgetObjectPropertyObjectsetObjectPropertyBoxedconstructObjectPropertyBoxedgetObjectPropertyBoxedsetObjectPropertyStringArray"constructObjectPropertyStringArraygetObjectPropertyStringArraysetObjectPropertyEnumconstructObjectPropertyEnumgetObjectPropertyEnumsetObjectPropertyFlagsconstructObjectPropertyFlagsgetObjectPropertyFlagssetObjectPropertyClosureconstructObjectPropertyClosuregetObjectPropertyClosuresetObjectPropertyVariantconstructObjectPropertyVariantgetObjectPropertyVariantsetObjectPropertyByteArray constructObjectPropertyByteArraygetObjectPropertyByteArraysetObjectPropertyPtrGListconstructObjectPropertyPtrGListgetObjectPropertyPtrGListsetObjectPropertyHashconstructObjectPropertyHashgetObjectPropertyHashsetObjectPropertyCallbackconstructObjectPropertyCallbackgetObjectPropertyCallbacksetObjectPropertyGErrorconstructObjectPropertyGErrorgetObjectPropertyGErrorsetObjectPropertyGValueconstructObjectPropertyGValuegetObjectPropertyGValue g_array_newIsElemCheckForAncestorType FindElementStorabledbg_g_object_disownownedFinalizerprintAllocDebug FinalizerPtrnotOwnedWarningnullPtrWarning dbgDealloc text-1.2.3.0Data.Text.InternalTextcontainers-0.5.11.0Data.Map.Internal GHC.Stable StablePtr AttrOpText CheckNotElemConstructNotProvidedErrorSetNotProvidedErrorGetNotProvidedErrorClearNotProvidedErrorOpNotProvidedErrorAttrOpIsAllowedTypeOriginInfoGObjectConstructor defaultFlags pspecQuark objectFromPtr wrapGetSetgParamSpecSetQDatagParamSpecGetQDataGObjectNotifyCallback proxyDetailconnectGObjectNotifydoConstructGObject privateKeyinstanceSetUserDatainstanceSetPrivateDatagErrorQuarkFromDomain