gi-atk 2.0.15 → 2.0.17

raw patch · 90 files changed

+27201/−10 lines, 90 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/Atk.hs +60/−0
• GI/Atk/Callbacks.hs +580/−0
• GI/Atk/Constants.hs +108/−0
• GI/Atk/Enums.hs +2197/−0
• GI/Atk/Enums.hs-boot +60/−0
• GI/Atk/Flags.hs +77/−0
• GI/Atk/Flags.hs-boot +28/−0
• GI/Atk/Functions.hs +529/−0
• GI/Atk/Interfaces.hs +69/−0
• GI/Atk/Interfaces/Action.hs +481/−0
• GI/Atk/Interfaces/Action.hs-boot +48/−0
• GI/Atk/Interfaces/Component.hs +1035/−0
• GI/Atk/Interfaces/Component.hs-boot +77/−0
• GI/Atk/Interfaces/Document.hs +911/−0
• GI/Atk/Interfaces/Document.hs-boot +65/−0
• GI/Atk/Interfaces/EditableText.hs +445/−0
• GI/Atk/Interfaces/EditableText.hs-boot +48/−0
• GI/Atk/Interfaces/HyperlinkImpl.hs +161/−0
• GI/Atk/Interfaces/HyperlinkImpl.hs-boot +30/−0
• GI/Atk/Interfaces/Hypertext.hs +370/−0
• GI/Atk/Interfaces/Hypertext.hs-boot +41/−0
• GI/Atk/Interfaces/Image.hs +351/−0
• GI/Atk/Interfaces/Image.hs-boot +42/−0
• GI/Atk/Interfaces/ImplementorIface.hs +84/−0
• GI/Atk/Interfaces/ImplementorIface.hs-boot +27/−0
• GI/Atk/Interfaces/Selection.hs +570/−0
• GI/Atk/Interfaces/Selection.hs-boot +53/−0
• GI/Atk/Interfaces/StreamableContent.hs +307/−0
• GI/Atk/Interfaces/StreamableContent.hs-boot +39/−0
• GI/Atk/Interfaces/Table.hs +2227/−0
• GI/Atk/Interfaces/Table.hs-boot +137/−0
• GI/Atk/Interfaces/TableCell.hs +512/−0
• GI/Atk/Interfaces/TableCell.hs-boot +50/−0
• GI/Atk/Interfaces/Text.hs +2062/−0
• GI/Atk/Interfaces/Text.hs-boot +113/−0
• GI/Atk/Interfaces/Value.hs +885/−0
• GI/Atk/Interfaces/Value.hs-boot +62/−0
• GI/Atk/Interfaces/Window.hs +970/−0
• GI/Atk/Interfaces/Window.hs-boot +56/−0
• GI/Atk/Objects.hs +67/−0
• GI/Atk/Objects/GObjectAccessible.hs +235/−0
• GI/Atk/Objects/GObjectAccessible.hs-boot +32/−0
• GI/Atk/Objects/Hyperlink.hs +791/−0
• GI/Atk/Objects/Hyperlink.hs-boot +68/−0
• GI/Atk/Objects/Misc.hs +261/−0
• GI/Atk/Objects/Misc.hs-boot +35/−0
• GI/Atk/Objects/NoOpObject.hs +312/−0
• GI/Atk/Objects/NoOpObject.hs-boot +29/−0
• GI/Atk/Objects/NoOpObjectFactory.hs +163/−0
• GI/Atk/Objects/NoOpObjectFactory.hs-boot +29/−0
• GI/Atk/Objects/Object.hs +2902/−0
• GI/Atk/Objects/Object.hs-boot +161/−0
• GI/Atk/Objects/ObjectFactory.hs +273/−0
• GI/Atk/Objects/ObjectFactory.hs-boot +38/−0
• GI/Atk/Objects/Plug.hs +248/−0
• GI/Atk/Objects/Plug.hs-boot +32/−0
• GI/Atk/Objects/Registry.hs +285/−0
• GI/Atk/Objects/Registry.hs-boot +38/−0
• GI/Atk/Objects/Relation.hs +512/−0
• GI/Atk/Objects/Relation.hs-boot +47/−0
• GI/Atk/Objects/RelationSet.hs +570/−0
• GI/Atk/Objects/RelationSet.hs-boot +53/−0
• GI/Atk/Objects/Socket.hs +318/−0
• GI/Atk/Objects/Socket.hs-boot +35/−0
• GI/Atk/Objects/StateSet.hs +665/−0
• GI/Atk/Objects/StateSet.hs-boot +59/−0
• GI/Atk/Objects/Util.hs +124/−0
• GI/Atk/Objects/Util.hs-boot +29/−0
• GI/Atk/Structs.hs +55/−0
• GI/Atk/Structs/Attribute.hs +281/−0
• GI/Atk/Structs/Attribute.hs-boot +26/−0
• GI/Atk/Structs/Implementor.hs +129/−0
• GI/Atk/Structs/Implementor.hs-boot +29/−0
• GI/Atk/Structs/KeyEventStruct.hs +501/−0
• GI/Atk/Structs/KeyEventStruct.hs-boot +26/−0
• GI/Atk/Structs/PropertyValues.hs +250/−0
• GI/Atk/Structs/PropertyValues.hs-boot +26/−0
• GI/Atk/Structs/Range.hs +361/−0
• GI/Atk/Structs/Range.hs-boot +41/−0
• GI/Atk/Structs/Rectangle.hs +313/−0
• GI/Atk/Structs/Rectangle.hs-boot +26/−0
• GI/Atk/Structs/TextRange.hs +317/−0
• GI/Atk/Structs/TextRange.hs-boot +26/−0
• GI/Atk/Structs/TextRectangle.hs +311/−0
• GI/Atk/Structs/TextRectangle.hs-boot +26/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-atk.cabal +55/−8
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 2.0.17+++ Update to haskell-gi(-base) 0.22++### 2.0.16+++ Update stack version to 12.10+ ### 2.0.15  + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading).

@@ -0,0 +1,60 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk+    (     module GI.Atk.Callbacks                 ,+    module GI.Atk.Constants                 ,+    module GI.Atk.Enums                     ,+    module GI.Atk.Flags                     ,+    module GI.Atk.Functions                 ,+    module GI.Atk.Interfaces                ,+    module GI.Atk.Objects                   ,+    module GI.Atk.Structs                   ,++++    module Data.GI.Base                     ,+++    ) where++import GI.Atk.Callbacks+import GI.Atk.Constants+import GI.Atk.Enums+import GI.Atk.Flags+import GI.Atk.Functions+import GI.Atk.Interfaces+import GI.Atk.Objects+import GI.Atk.Structs++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++import Data.GI.Base+

@@ -0,0 +1,580 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Callbacks+    ( ++ -- * Signals+-- ** EventListener #signal:EventListener#++    C_EventListener                         ,+    EventListener                           ,+    dynamic_EventListener                   ,+    genClosure_EventListener                ,+    mk_EventListener                        ,+    noEventListener                         ,+    wrap_EventListener                      ,+++-- ** EventListenerInit #signal:EventListenerInit#++    C_EventListenerInit                     ,+    EventListenerInit                       ,+    dynamic_EventListenerInit               ,+    genClosure_EventListenerInit            ,+    mk_EventListenerInit                    ,+    noEventListenerInit                     ,+    wrap_EventListenerInit                  ,+++-- ** FocusHandler #signal:FocusHandler#++    C_FocusHandler                          ,+    FocusHandler                            ,+    dynamic_FocusHandler                    ,+    genClosure_FocusHandler                 ,+    mk_FocusHandler                         ,+    noFocusHandler                          ,+    wrap_FocusHandler                       ,+++-- ** Function #signal:Function#++    C_Function                              ,+    Function                                ,+    Function_WithClosures                   ,+    drop_closures_Function                  ,+    dynamic_Function                        ,+    genClosure_Function                     ,+    mk_Function                             ,+    noFunction                              ,+    noFunction_WithClosures                 ,+    wrap_Function                           ,+++-- ** KeySnoopFunc #signal:KeySnoopFunc#++    C_KeySnoopFunc                          ,+    KeySnoopFunc                            ,+    KeySnoopFunc_WithClosures               ,+    drop_closures_KeySnoopFunc              ,+    dynamic_KeySnoopFunc                    ,+    genClosure_KeySnoopFunc                 ,+    mk_KeySnoopFunc                         ,+    noKeySnoopFunc                          ,+    noKeySnoopFunc_WithClosures             ,+    wrap_KeySnoopFunc                       ,+++-- ** PropertyChangeHandler #signal:PropertyChangeHandler#++    C_PropertyChangeHandler                 ,+    PropertyChangeHandler                   ,+    dynamic_PropertyChangeHandler           ,+    genClosure_PropertyChangeHandler        ,+    mk_PropertyChangeHandler                ,+    noPropertyChangeHandler                 ,+    wrap_PropertyChangeHandler              ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object+import {-# SOURCE #-} qualified GI.Atk.Structs.KeyEventStruct as Atk.KeyEventStruct+import {-# SOURCE #-} qualified GI.Atk.Structs.PropertyValues as Atk.PropertyValues++-- callback PropertyChangeHandler+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "obj", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "atkobject which property changes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vals", argType = TInterface (Name {namespace = "Atk", name = "PropertyValues"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Nothing, deprecationMessage = Just "Since 2.12."}), callableDocumentation = Documentation {rawDocText = Just "An AtkPropertyChangeHandler is a function which is executed when an\nAtkObject's property changes value. It is specified in a call to\natk_object_connect_property_change_handler().", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_PropertyChangeHandler =+    Ptr Atk.Object.Object ->+    Ptr Atk.PropertyValues.PropertyValues ->+    IO ()++-- Args : [Arg {argCName = "obj", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "atkobject which property changes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vals", argType = TInterface (Name {namespace = "Atk", name = "PropertyValues"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_PropertyChangeHandler :: FunPtr C_PropertyChangeHandler -> C_PropertyChangeHandler++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_PropertyChangeHandler ::+    (B.CallStack.HasCallStack, MonadIO m, Atk.Object.IsObject a) =>+    FunPtr C_PropertyChangeHandler+    -> a+    {- ^ /@obj@/: atkobject which property changes -}+    -> Atk.PropertyValues.PropertyValues+    {- ^ /@vals@/: values changed -}+    -> m ()+dynamic_PropertyChangeHandler __funPtr obj vals = liftIO $ do+    obj' <- unsafeManagedPtrCastPtr obj+    vals' <- unsafeManagedPtrGetPtr vals+    (__dynamic_C_PropertyChangeHandler __funPtr) obj' vals'+    touchManagedPtr obj+    touchManagedPtr vals+    return ()++-- | Generate a function pointer callable from C code, from a `C_PropertyChangeHandler`.+foreign import ccall "wrapper"+    mk_PropertyChangeHandler :: C_PropertyChangeHandler -> IO (FunPtr C_PropertyChangeHandler)++{-# DEPRECATED PropertyChangeHandler ["Since 2.12."] #-}+{- |+An AtkPropertyChangeHandler is a function which is executed when an+AtkObject\'s property changes value. It is specified in a call to+@/atk_object_connect_property_change_handler()/@.+-}+type PropertyChangeHandler =+    Atk.Object.Object+    {- ^ /@obj@/: atkobject which property changes -}+    -> Atk.PropertyValues.PropertyValues+    {- ^ /@vals@/: values changed -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PropertyChangeHandler`@.+noPropertyChangeHandler :: Maybe PropertyChangeHandler+noPropertyChangeHandler = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_PropertyChangeHandler :: MonadIO m => PropertyChangeHandler -> m (GClosure C_PropertyChangeHandler)+genClosure_PropertyChangeHandler cb = liftIO $ do+    let cb' = wrap_PropertyChangeHandler Nothing cb+    mk_PropertyChangeHandler cb' >>= B.GClosure.newGClosure+++-- | Wrap a `PropertyChangeHandler` into a `C_PropertyChangeHandler`.+wrap_PropertyChangeHandler ::+    Maybe (Ptr (FunPtr C_PropertyChangeHandler)) ->+    PropertyChangeHandler ->+    C_PropertyChangeHandler+wrap_PropertyChangeHandler funptrptr _cb obj vals = do+    obj' <- (newObject Atk.Object.Object) obj+    vals' <- (newPtr Atk.PropertyValues.PropertyValues) vals+    _cb  obj' vals'+    maybeReleaseFunPtr funptrptr+++-- callback KeySnoopFunc+--          -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "TRUE (nonzero) if the event emission should be stopped and the event\ndiscarded without being passed to the normal GUI recipient; FALSE (zero) if the\nevent dispatch to the client application should proceed as normal.\n\nsee atk_add_key_event_listener.", sinceVersion = Nothing}, args = [Arg {argCName = "event", argType = TInterface (Name {namespace = "Atk", name = "KeyEventStruct"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an AtkKeyEventStruct containing information about the key event for which\nnotification is being given.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a block of data which will be passed to the event listener, on notification.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "An #AtkKeySnoopFunc is a type of callback which is called whenever a key event occurs,\nif registered via atk_add_key_event_listener.  It allows for pre-emptive\ninterception of key events via the return code as described below.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_KeySnoopFunc =+    Ptr Atk.KeyEventStruct.KeyEventStruct ->+    Ptr () ->+    IO Int32++-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Atk", name = "KeyEventStruct"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an AtkKeyEventStruct containing information about the key event for which\nnotification is being given.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a block of data which will be passed to the event listener, on notification.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_KeySnoopFunc :: FunPtr C_KeySnoopFunc -> C_KeySnoopFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_KeySnoopFunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_KeySnoopFunc+    -> Atk.KeyEventStruct.KeyEventStruct+    {- ^ /@event@/: an AtkKeyEventStruct containing information about the key event for which+notification is being given. -}+    -> Ptr ()+    {- ^ /@userData@/: a block of data which will be passed to the event listener, on notification. -}+    -> m Int32+    {- ^ __Returns:__ TRUE (nonzero) if the event emission should be stopped and the event+discarded without being passed to the normal GUI recipient; FALSE (zero) if the+event dispatch to the client application should proceed as normal.++see atk_add_key_event_listener. -}+dynamic_KeySnoopFunc __funPtr event userData = liftIO $ do+    event' <- unsafeManagedPtrGetPtr event+    result <- (__dynamic_C_KeySnoopFunc __funPtr) event' userData+    touchManagedPtr event+    return result++-- | Generate a function pointer callable from C code, from a `C_KeySnoopFunc`.+foreign import ccall "wrapper"+    mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)++{- |+An 'GI.Atk.Callbacks.KeySnoopFunc' is a type of callback which is called whenever a key event occurs,+if registered via atk_add_key_event_listener.  It allows for pre-emptive+interception of key events via the return code as described below.+-}+type KeySnoopFunc =+    Atk.KeyEventStruct.KeyEventStruct+    {- ^ /@event@/: an AtkKeyEventStruct containing information about the key event for which+notification is being given. -}+    -> IO Int32+    {- ^ __Returns:__ TRUE (nonzero) if the event emission should be stopped and the event+discarded without being passed to the normal GUI recipient; FALSE (zero) if the+event dispatch to the client application should proceed as normal.++see atk_add_key_event_listener. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `KeySnoopFunc`@.+noKeySnoopFunc :: Maybe KeySnoopFunc+noKeySnoopFunc = Nothing++{- |+An 'GI.Atk.Callbacks.KeySnoopFunc' is a type of callback which is called whenever a key event occurs,+if registered via atk_add_key_event_listener.  It allows for pre-emptive+interception of key events via the return code as described below.+-}+type KeySnoopFunc_WithClosures =+    Atk.KeyEventStruct.KeyEventStruct+    {- ^ /@event@/: an AtkKeyEventStruct containing information about the key event for which+notification is being given. -}+    -> Ptr ()+    {- ^ /@userData@/: a block of data which will be passed to the event listener, on notification. -}+    -> IO Int32+    {- ^ __Returns:__ TRUE (nonzero) if the event emission should be stopped and the event+discarded without being passed to the normal GUI recipient; FALSE (zero) if the+event dispatch to the client application should proceed as normal.++see atk_add_key_event_listener. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `KeySnoopFunc_WithClosures`@.+noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures+noKeySnoopFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures+drop_closures_KeySnoopFunc _f event _ = _f event++-- | Wrap the callback into a `GClosure`.+genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)+genClosure_KeySnoopFunc cb = liftIO $ do+    let cb' = drop_closures_KeySnoopFunc cb+    let cb'' = wrap_KeySnoopFunc Nothing cb'+    mk_KeySnoopFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `KeySnoopFunc` into a `C_KeySnoopFunc`.+wrap_KeySnoopFunc ::+    Maybe (Ptr (FunPtr C_KeySnoopFunc)) ->+    KeySnoopFunc_WithClosures ->+    C_KeySnoopFunc+wrap_KeySnoopFunc funptrptr _cb event userData = do+    event' <- (newPtr Atk.KeyEventStruct.KeyEventStruct) event+    result <- _cb  event' userData+    maybeReleaseFunPtr funptrptr+    return result+++-- callback Function+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "not used", sinceVersion = Nothing}, args = [Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "custom data defined by the user", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 0, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "An AtkFunction is a function definition used for padding which has\nbeen added to class and interface structures to allow for expansion\nin the future.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_Function =+    Ptr () ->+    IO CInt++-- Args : [Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "custom data defined by the user", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 0, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_Function :: FunPtr C_Function -> C_Function++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_Function ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_Function+    -> Ptr ()+    {- ^ /@userData@/: custom data defined by the user -}+    -> m Bool+    {- ^ __Returns:__ not used -}+dynamic_Function __funPtr userData = liftIO $ do+    result <- (__dynamic_C_Function __funPtr) userData+    let result' = (/= 0) result+    return result'++-- | Generate a function pointer callable from C code, from a `C_Function`.+foreign import ccall "wrapper"+    mk_Function :: C_Function -> IO (FunPtr C_Function)++{- |+An AtkFunction is a function definition used for padding which has+been added to class and interface structures to allow for expansion+in the future.+-}+type Function =+    IO Bool+    {- ^ __Returns:__ not used -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `Function`@.+noFunction :: Maybe Function+noFunction = Nothing++{- |+An AtkFunction is a function definition used for padding which has+been added to class and interface structures to allow for expansion+in the future.+-}+type Function_WithClosures =+    Ptr ()+    {- ^ /@userData@/: custom data defined by the user -}+    -> IO Bool+    {- ^ __Returns:__ not used -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `Function_WithClosures`@.+noFunction_WithClosures :: Maybe Function_WithClosures+noFunction_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_Function :: Function -> Function_WithClosures+drop_closures_Function _f _ = _f ++-- | Wrap the callback into a `GClosure`.+genClosure_Function :: MonadIO m => Function -> m (GClosure C_Function)+genClosure_Function cb = liftIO $ do+    let cb' = drop_closures_Function cb+    let cb'' = wrap_Function Nothing cb'+    mk_Function cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `Function` into a `C_Function`.+wrap_Function ::+    Maybe (Ptr (FunPtr C_Function)) ->+    Function_WithClosures ->+    C_Function+wrap_Function funptrptr _cb userData = do+    result <- _cb  userData+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback FocusHandler+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkObject that receives/lose the focus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_in", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TRUE if the object receives the focus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "2.9.4", deprecationMessage = Just "Deprecated with atk_component_add_focus_handler()\nand atk_component_remove_focus_handler(). See those\nmethods for more information."}), callableDocumentation = Documentation {rawDocText = Just "The type of callback function used for\natk_component_add_focus_handler() and\natk_component_remove_focus_handler()", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_FocusHandler =+    Ptr Atk.Object.Object ->+    CInt ->+    IO ()++-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkObject that receives/lose the focus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_in", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TRUE if the object receives the focus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_FocusHandler :: FunPtr C_FocusHandler -> C_FocusHandler++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_FocusHandler ::+    (B.CallStack.HasCallStack, MonadIO m, Atk.Object.IsObject a) =>+    FunPtr C_FocusHandler+    -> a+    {- ^ /@object@/: the 'GI.Atk.Objects.Object.Object' that receives\/lose the focus -}+    -> Bool+    {- ^ /@focusIn@/: TRUE if the object receives the focus -}+    -> m ()+dynamic_FocusHandler __funPtr object focusIn = liftIO $ do+    object' <- unsafeManagedPtrCastPtr object+    let focusIn' = (fromIntegral . fromEnum) focusIn+    (__dynamic_C_FocusHandler __funPtr) object' focusIn'+    touchManagedPtr object+    return ()++-- | Generate a function pointer callable from C code, from a `C_FocusHandler`.+foreign import ccall "wrapper"+    mk_FocusHandler :: C_FocusHandler -> IO (FunPtr C_FocusHandler)++{-# DEPRECATED FocusHandler ["(Since version 2.9.4)","Deprecated with @/atk_component_add_focus_handler()/@","and 'GI.Atk.Interfaces.Component.componentRemoveFocusHandler'. See those","methods for more information."] #-}+{- |+The type of callback function used for+@/atk_component_add_focus_handler()/@ and+'GI.Atk.Interfaces.Component.componentRemoveFocusHandler'+-}+type FocusHandler =+    Atk.Object.Object+    {- ^ /@object@/: the 'GI.Atk.Objects.Object.Object' that receives\/lose the focus -}+    -> Bool+    {- ^ /@focusIn@/: TRUE if the object receives the focus -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `FocusHandler`@.+noFocusHandler :: Maybe FocusHandler+noFocusHandler = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_FocusHandler :: MonadIO m => FocusHandler -> m (GClosure C_FocusHandler)+genClosure_FocusHandler cb = liftIO $ do+    let cb' = wrap_FocusHandler Nothing cb+    mk_FocusHandler cb' >>= B.GClosure.newGClosure+++-- | Wrap a `FocusHandler` into a `C_FocusHandler`.+wrap_FocusHandler ::+    Maybe (Ptr (FunPtr C_FocusHandler)) ->+    FocusHandler ->+    C_FocusHandler+wrap_FocusHandler funptrptr _cb object focusIn = do+    object' <- (newObject Atk.Object.Object) object+    let focusIn' = (/= 0) focusIn+    _cb  object' focusIn'+    maybeReleaseFunPtr funptrptr+++-- callback EventListenerInit+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "An #AtkEventListenerInit function is a special function that is\ncalled in order to initialize the per-object event registration system\nused by #AtkEventListener, if any preparation is required.\n\nsee atk_focus_tracker_init.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_EventListenerInit =+    IO ()++-- Args : []+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_EventListenerInit :: FunPtr C_EventListenerInit -> C_EventListenerInit++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_EventListenerInit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_EventListenerInit+    -> m ()+dynamic_EventListenerInit __funPtr = liftIO $ do+    (__dynamic_C_EventListenerInit __funPtr)+    return ()++-- | Generate a function pointer callable from C code, from a `C_EventListenerInit`.+foreign import ccall "wrapper"+    mk_EventListenerInit :: C_EventListenerInit -> IO (FunPtr C_EventListenerInit)++{- |+An 'GI.Atk.Callbacks.EventListenerInit' function is a special function that is+called in order to initialize the per-object event registration system+used by 'GI.Atk.Callbacks.EventListener', if any preparation is required.++see atk_focus_tracker_init.+-}+type EventListenerInit =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `EventListenerInit`@.+noEventListenerInit :: Maybe EventListenerInit+noEventListenerInit = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_EventListenerInit :: MonadIO m => EventListenerInit -> m (GClosure C_EventListenerInit)+genClosure_EventListenerInit cb = liftIO $ do+    let cb' = wrap_EventListenerInit Nothing cb+    mk_EventListenerInit cb' >>= B.GClosure.newGClosure+++-- | Wrap a `EventListenerInit` into a `C_EventListenerInit`.+wrap_EventListenerInit ::+    Maybe (Ptr (FunPtr C_EventListenerInit)) ->+    EventListenerInit ->+    C_EventListenerInit+wrap_EventListenerInit funptrptr _cb = do+    _cb +    maybeReleaseFunPtr funptrptr+++-- callback EventListener+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "obj", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #AtkObject instance for whom the callback will be called when\nthe specified event (e.g. 'focus:') takes place.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A function which is called when an object emits a matching event,\nas used in #atk_add_focus_tracker.\nCurrently the only events for which object-specific handlers are\nsupported are events of type \"focus:\".  Most clients of ATK will prefer to\nattach signal handlers for the various ATK signals instead.\n\nsee atk_add_focus_tracker.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_EventListener =+    Ptr Atk.Object.Object ->+    IO ()++-- Args : [Arg {argCName = "obj", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #AtkObject instance for whom the callback will be called when\nthe specified event (e.g. 'focus:') takes place.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_EventListener :: FunPtr C_EventListener -> C_EventListener++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_EventListener ::+    (B.CallStack.HasCallStack, MonadIO m, Atk.Object.IsObject a) =>+    FunPtr C_EventListener+    -> a+    {- ^ /@obj@/: An 'GI.Atk.Objects.Object.Object' instance for whom the callback will be called when+the specified event (e.g. \'focus:\') takes place. -}+    -> m ()+dynamic_EventListener __funPtr obj = liftIO $ do+    obj' <- unsafeManagedPtrCastPtr obj+    (__dynamic_C_EventListener __funPtr) obj'+    touchManagedPtr obj+    return ()++-- | Generate a function pointer callable from C code, from a `C_EventListener`.+foreign import ccall "wrapper"+    mk_EventListener :: C_EventListener -> IO (FunPtr C_EventListener)++{- |+A function which is called when an object emits a matching event,+as used in @/atk_add_focus_tracker/@.+Currently the only events for which object-specific handlers are+supported are events of type \"focus:\".  Most clients of ATK will prefer to+attach signal handlers for the various ATK signals instead.++see atk_add_focus_tracker.+-}+type EventListener =+    Atk.Object.Object+    {- ^ /@obj@/: An 'GI.Atk.Objects.Object.Object' instance for whom the callback will be called when+the specified event (e.g. \'focus:\') takes place. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `EventListener`@.+noEventListener :: Maybe EventListener+noEventListener = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_EventListener :: MonadIO m => EventListener -> m (GClosure C_EventListener)+genClosure_EventListener cb = liftIO $ do+    let cb' = wrap_EventListener Nothing cb+    mk_EventListener cb' >>= B.GClosure.newGClosure+++-- | Wrap a `EventListener` into a `C_EventListener`.+wrap_EventListener ::+    Maybe (Ptr (FunPtr C_EventListener)) ->+    EventListener ->+    C_EventListener+wrap_EventListener funptrptr _cb obj = do+    obj' <- (newObject Atk.Object.Object) obj+    _cb  obj'+    maybeReleaseFunPtr funptrptr+++

@@ -0,0 +1,108 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Constants+    ( +    pattern VERSION_MIN_REQUIRED            ,+    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,+    pattern INTERFACE_AGE                   ,+    pattern BINARY_AGE                      ,++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++{- |+A macro that should be defined by the user prior to including+the atk\/atk.h header.+The definition should be one of the predefined ATK version+macros: @/ATK_VERSION_2_12/@, @/ATK_VERSION_2_14/@,...++This macro defines the earliest version of ATK that the package is+required to be able to compile against.++If the compiler is configured to warn about the use of deprecated+functions, then using functions that were deprecated in version+'GI.Atk.Constants.VERSION_MIN_REQUIRED' or earlier will cause warnings (but+using functions deprecated in later releases will not).++/Since: 2.14/+-}+pattern VERSION_MIN_REQUIRED = 2 :: Int32++{- |+Like 'GI.Atk.Functions.getMinorVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.++/Since: 2.7.4/+-}+pattern MINOR_VERSION = 32 :: Int32++{- |+Like 'GI.Atk.Functions.getMicroVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.++/Since: 2.7.4/+-}+pattern MICRO_VERSION = 0 :: Int32++{- |+Like 'GI.Atk.Functions.getMajorVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.++/Since: 2.7.4/+-}+pattern MAJOR_VERSION = 2 :: Int32++{- |+Like 'GI.Atk.Functions.getInterfaceAge', but from the headers used at+application compile time, rather than from the library linked+against at application run time.++/Since: 2.7.4/+-}+pattern INTERFACE_AGE = 1 :: Int32++{- |+Like 'GI.Atk.Functions.getBinaryAge', but from the headers used at+application compile time, rather than from the library linked+against at application run time.++/Since: 2.7.4/+-}+pattern BINARY_AGE = 23210 :: Int32++

@@ -0,0 +1,2197 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Enums+    ( ++ -- * Enumerations+-- ** CoordType #enum:CoordType#++    CoordType(..)                           ,+++-- ** KeyEventType #enum:KeyEventType#++    KeyEventType(..)                        ,+++-- ** Layer #enum:Layer#++    Layer(..)                               ,+++-- ** RelationType #enum:RelationType#++    RelationType(..)                        ,+++-- ** Role #enum:Role#++    Role(..)                                ,+++-- ** ScrollType #enum:ScrollType#++    ScrollType(..)                          ,+++-- ** StateType #enum:StateType#++    StateType(..)                           ,+++-- ** TextAttribute #enum:TextAttribute#++    TextAttribute(..)                       ,+++-- ** TextBoundary #enum:TextBoundary#++    TextBoundary(..)                        ,+++-- ** TextClipType #enum:TextClipType#++    TextClipType(..)                        ,+++-- ** TextGranularity #enum:TextGranularity#++    TextGranularity(..)                     ,+++-- ** ValueType #enum:ValueType#++    ValueType(..)                           ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- Enum ValueType+{- |+Default types for a given value. Those are defined in order to+easily get localized strings to describe a given value or a given+subrange, using 'GI.Atk.Functions.valueTypeGetLocalizedName'.+-}+data ValueType = +      ValueTypeVeryWeak+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeWeak+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeAcceptable+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeStrong+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeVeryStrong+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeVeryLow+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeLow+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeMedium+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeHigh+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeVeryHigh+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeVeryBad+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeBad+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeGood+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeVeryGood+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeBest+    {- ^+    /No description available in the introspection data./+    -}+    | ValueTypeLastDefined+    {- ^+    /No description available in the introspection data./+    -}+    | AnotherValueType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ValueType where+    fromEnum ValueTypeVeryWeak = 0+    fromEnum ValueTypeWeak = 1+    fromEnum ValueTypeAcceptable = 2+    fromEnum ValueTypeStrong = 3+    fromEnum ValueTypeVeryStrong = 4+    fromEnum ValueTypeVeryLow = 5+    fromEnum ValueTypeLow = 6+    fromEnum ValueTypeMedium = 7+    fromEnum ValueTypeHigh = 8+    fromEnum ValueTypeVeryHigh = 9+    fromEnum ValueTypeVeryBad = 10+    fromEnum ValueTypeBad = 11+    fromEnum ValueTypeGood = 12+    fromEnum ValueTypeVeryGood = 13+    fromEnum ValueTypeBest = 14+    fromEnum ValueTypeLastDefined = 15+    fromEnum (AnotherValueType k) = k++    toEnum 0 = ValueTypeVeryWeak+    toEnum 1 = ValueTypeWeak+    toEnum 2 = ValueTypeAcceptable+    toEnum 3 = ValueTypeStrong+    toEnum 4 = ValueTypeVeryStrong+    toEnum 5 = ValueTypeVeryLow+    toEnum 6 = ValueTypeLow+    toEnum 7 = ValueTypeMedium+    toEnum 8 = ValueTypeHigh+    toEnum 9 = ValueTypeVeryHigh+    toEnum 10 = ValueTypeVeryBad+    toEnum 11 = ValueTypeBad+    toEnum 12 = ValueTypeGood+    toEnum 13 = ValueTypeVeryGood+    toEnum 14 = ValueTypeBest+    toEnum 15 = ValueTypeLastDefined+    toEnum k = AnotherValueType k++instance P.Ord ValueType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_value_type_get_type" c_atk_value_type_get_type :: +    IO GType++instance BoxedEnum ValueType where+    boxedEnumType _ = c_atk_value_type_get_type++-- Enum TextGranularity+{- |+Text granularity types used for specifying the granularity of the region of+text we are interested in.+-}+data TextGranularity = +      TextGranularityChar+    {- ^+    Granularity is defined by the boundaries between characters+    (including non-printing characters)+    -}+    | TextGranularityWord+    {- ^+    Granularity is defined by the boundaries of a word,+    starting at the beginning of the current word and finishing at the beginning of+    the following one, if present.+    -}+    | TextGranularitySentence+    {- ^+    Granularity is defined by the boundaries of a sentence,+    starting at the beginning of the current sentence and finishing at the beginning of+    the following one, if present.+    -}+    | TextGranularityLine+    {- ^+    Granularity is defined by the boundaries of a line,+    starting at the beginning of the current line and finishing at the beginning of+    the following one, if present.+    -}+    | TextGranularityParagraph+    {- ^+    Granularity is defined by the boundaries of a paragraph,+    starting at the beginning of the current paragraph and finishing at the beginning of+    the following one, if present.+    -}+    | AnotherTextGranularity Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TextGranularity where+    fromEnum TextGranularityChar = 0+    fromEnum TextGranularityWord = 1+    fromEnum TextGranularitySentence = 2+    fromEnum TextGranularityLine = 3+    fromEnum TextGranularityParagraph = 4+    fromEnum (AnotherTextGranularity k) = k++    toEnum 0 = TextGranularityChar+    toEnum 1 = TextGranularityWord+    toEnum 2 = TextGranularitySentence+    toEnum 3 = TextGranularityLine+    toEnum 4 = TextGranularityParagraph+    toEnum k = AnotherTextGranularity k++instance P.Ord TextGranularity where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_text_granularity_get_type" c_atk_text_granularity_get_type :: +    IO GType++instance BoxedEnum TextGranularity where+    boxedEnumType _ = c_atk_text_granularity_get_type++-- Enum TextClipType+{- |+Describes the type of clipping required.+-}+data TextClipType = +      TextClipTypeNone+    {- ^+    No clipping to be done+    -}+    | TextClipTypeMin+    {- ^+    Text clipped by min coordinate is omitted+    -}+    | TextClipTypeMax+    {- ^+    Text clipped by max coordinate is omitted+    -}+    | TextClipTypeBoth+    {- ^+    Only text fully within mix\/max bound is retained+    -}+    | AnotherTextClipType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TextClipType where+    fromEnum TextClipTypeNone = 0+    fromEnum TextClipTypeMin = 1+    fromEnum TextClipTypeMax = 2+    fromEnum TextClipTypeBoth = 3+    fromEnum (AnotherTextClipType k) = k++    toEnum 0 = TextClipTypeNone+    toEnum 1 = TextClipTypeMin+    toEnum 2 = TextClipTypeMax+    toEnum 3 = TextClipTypeBoth+    toEnum k = AnotherTextClipType k++instance P.Ord TextClipType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_text_clip_type_get_type" c_atk_text_clip_type_get_type :: +    IO GType++instance BoxedEnum TextClipType where+    boxedEnumType _ = c_atk_text_clip_type_get_type++-- Enum TextBoundary+{- |+Text boundary types used for specifying boundaries for regions of text.+This enumeration is deprecated since 2.9.4 and should not be used. Use+AtkTextGranularity with @/atk_text_get_string_at_offset/@ instead.+-}+data TextBoundary = +      TextBoundaryChar+    {- ^+    Boundary is the boundary between characters+    (including non-printing characters)+    -}+    | TextBoundaryWordStart+    {- ^+    Boundary is the start (i.e. first character) of a word.+    -}+    | TextBoundaryWordEnd+    {- ^+    Boundary is the end (i.e. last+    character) of a word.+    -}+    | TextBoundarySentenceStart+    {- ^+    Boundary is the first character in a sentence.+    -}+    | TextBoundarySentenceEnd+    {- ^+    Boundary is the last (terminal)+    character in a sentence; in languages which use \"sentence stop\"+    punctuation such as English, the boundary is thus the \'.\', \'?\', or+    similar terminal punctuation character.+    -}+    | TextBoundaryLineStart+    {- ^+    Boundary is the initial character of the content or a+    character immediately following a newline, linefeed, or return character.+    -}+    | TextBoundaryLineEnd+    {- ^+    Boundary is the linefeed, or return+    character.+    -}+    | AnotherTextBoundary Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TextBoundary where+    fromEnum TextBoundaryChar = 0+    fromEnum TextBoundaryWordStart = 1+    fromEnum TextBoundaryWordEnd = 2+    fromEnum TextBoundarySentenceStart = 3+    fromEnum TextBoundarySentenceEnd = 4+    fromEnum TextBoundaryLineStart = 5+    fromEnum TextBoundaryLineEnd = 6+    fromEnum (AnotherTextBoundary k) = k++    toEnum 0 = TextBoundaryChar+    toEnum 1 = TextBoundaryWordStart+    toEnum 2 = TextBoundaryWordEnd+    toEnum 3 = TextBoundarySentenceStart+    toEnum 4 = TextBoundarySentenceEnd+    toEnum 5 = TextBoundaryLineStart+    toEnum 6 = TextBoundaryLineEnd+    toEnum k = AnotherTextBoundary k++instance P.Ord TextBoundary where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_text_boundary_get_type" c_atk_text_boundary_get_type :: +    IO GType++instance BoxedEnum TextBoundary where+    boxedEnumType _ = c_atk_text_boundary_get_type++-- Enum TextAttribute+{- |+Describes the text attributes supported+-}+data TextAttribute = +      TextAttributeInvalid+    {- ^+    Invalid attribute, like bad spelling or grammar.+    -}+    | TextAttributeLeftMargin+    {- ^+    The pixel width of the left margin+    -}+    | TextAttributeRightMargin+    {- ^+    The pixel width of the right margin+    -}+    | TextAttributeIndent+    {- ^+    The number of pixels that the text is indented+    -}+    | TextAttributeInvisible+    {- ^+    Either \"true\" or \"false\" indicating whether text is visible or not+    -}+    | TextAttributeEditable+    {- ^+    Either \"true\" or \"false\" indicating whether text is editable or not+    -}+    | TextAttributePixelsAboveLines+    {- ^+    Pixels of blank space to leave above each newline-terminated line.+    -}+    | TextAttributePixelsBelowLines+    {- ^+    Pixels of blank space to leave below each newline-terminated line.+    -}+    | TextAttributePixelsInsideWrap+    {- ^+    Pixels of blank space to leave between wrapped lines inside the same newline-terminated line (paragraph).+    -}+    | TextAttributeBgFullHeight+    {- ^+    \"true\" or \"false\" whether to make the background color for each character the height of the highest font used on the current line, or the height of the font used for the current character.+    -}+    | TextAttributeRise+    {- ^+    Number of pixels that the characters are risen above the baseline+    -}+    | TextAttributeUnderline+    {- ^+    \"none\", \"single\", \"double\", \"low\", or \"error\"+    -}+    | TextAttributeStrikethrough+    {- ^+    \"true\" or \"false\" whether the text is strikethrough+    -}+    | TextAttributeSize+    {- ^+    The size of the characters in points. eg: 10+    -}+    | TextAttributeScale+    {- ^+    The scale of the characters. The value is a string representation of a double+    -}+    | TextAttributeWeight+    {- ^+    The weight of the characters.+    -}+    | TextAttributeLanguage+    {- ^+    The language used+    -}+    | TextAttributeFamilyName+    {- ^+    The font family name+    -}+    | TextAttributeBgColor+    {- ^+    The background color. The value is an RGB value of the format \"@/u/@,@/u/@,@/u/@\"+    -}+    | TextAttributeFgColor+    {- ^+    The foreground color. The value is an RGB value of the format \"@/u/@,@/u/@,@/u/@\"+    -}+    | TextAttributeBgStipple+    {- ^+    \"true\" if a @/GdkBitmap/@ is set for stippling the background color.+    -}+    | TextAttributeFgStipple+    {- ^+    \"true\" if a @/GdkBitmap/@ is set for stippling the foreground color.+    -}+    | TextAttributeWrapMode+    {- ^+    The wrap mode of the text, if any. Values are \"none\", \"char\", \"word\", or \"word_char\".+    -}+    | TextAttributeDirection+    {- ^+    The direction of the text, if set. Values are \"none\", \"ltr\" or \"rtl\"+    -}+    | TextAttributeJustification+    {- ^+    The justification of the text, if set. Values are \"left\", \"right\", \"center\" or \"fill\"+    -}+    | TextAttributeStretch+    {- ^+    The stretch of the text, if set. Values are \"ultra_condensed\", \"extra_condensed\", \"condensed\", \"semi_condensed\", \"normal\", \"semi_expanded\", \"expanded\", \"extra_expanded\" or \"ultra_expanded\"+    -}+    | TextAttributeVariant+    {- ^+    The capitalization variant of the text, if set. Values are \"normal\" or \"small_caps\"+    -}+    | TextAttributeStyle+    {- ^+    The slant style of the text, if set. Values are \"normal\", \"oblique\" or \"italic\"+    -}+    | TextAttributeLastDefined+    {- ^+    not a valid text attribute, used for finding end of enumeration+    -}+    | AnotherTextAttribute Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TextAttribute where+    fromEnum TextAttributeInvalid = 0+    fromEnum TextAttributeLeftMargin = 1+    fromEnum TextAttributeRightMargin = 2+    fromEnum TextAttributeIndent = 3+    fromEnum TextAttributeInvisible = 4+    fromEnum TextAttributeEditable = 5+    fromEnum TextAttributePixelsAboveLines = 6+    fromEnum TextAttributePixelsBelowLines = 7+    fromEnum TextAttributePixelsInsideWrap = 8+    fromEnum TextAttributeBgFullHeight = 9+    fromEnum TextAttributeRise = 10+    fromEnum TextAttributeUnderline = 11+    fromEnum TextAttributeStrikethrough = 12+    fromEnum TextAttributeSize = 13+    fromEnum TextAttributeScale = 14+    fromEnum TextAttributeWeight = 15+    fromEnum TextAttributeLanguage = 16+    fromEnum TextAttributeFamilyName = 17+    fromEnum TextAttributeBgColor = 18+    fromEnum TextAttributeFgColor = 19+    fromEnum TextAttributeBgStipple = 20+    fromEnum TextAttributeFgStipple = 21+    fromEnum TextAttributeWrapMode = 22+    fromEnum TextAttributeDirection = 23+    fromEnum TextAttributeJustification = 24+    fromEnum TextAttributeStretch = 25+    fromEnum TextAttributeVariant = 26+    fromEnum TextAttributeStyle = 27+    fromEnum TextAttributeLastDefined = 28+    fromEnum (AnotherTextAttribute k) = k++    toEnum 0 = TextAttributeInvalid+    toEnum 1 = TextAttributeLeftMargin+    toEnum 2 = TextAttributeRightMargin+    toEnum 3 = TextAttributeIndent+    toEnum 4 = TextAttributeInvisible+    toEnum 5 = TextAttributeEditable+    toEnum 6 = TextAttributePixelsAboveLines+    toEnum 7 = TextAttributePixelsBelowLines+    toEnum 8 = TextAttributePixelsInsideWrap+    toEnum 9 = TextAttributeBgFullHeight+    toEnum 10 = TextAttributeRise+    toEnum 11 = TextAttributeUnderline+    toEnum 12 = TextAttributeStrikethrough+    toEnum 13 = TextAttributeSize+    toEnum 14 = TextAttributeScale+    toEnum 15 = TextAttributeWeight+    toEnum 16 = TextAttributeLanguage+    toEnum 17 = TextAttributeFamilyName+    toEnum 18 = TextAttributeBgColor+    toEnum 19 = TextAttributeFgColor+    toEnum 20 = TextAttributeBgStipple+    toEnum 21 = TextAttributeFgStipple+    toEnum 22 = TextAttributeWrapMode+    toEnum 23 = TextAttributeDirection+    toEnum 24 = TextAttributeJustification+    toEnum 25 = TextAttributeStretch+    toEnum 26 = TextAttributeVariant+    toEnum 27 = TextAttributeStyle+    toEnum 28 = TextAttributeLastDefined+    toEnum k = AnotherTextAttribute k++instance P.Ord TextAttribute where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_text_attribute_get_type" c_atk_text_attribute_get_type :: +    IO GType++instance BoxedEnum TextAttribute where+    boxedEnumType _ = c_atk_text_attribute_get_type++-- Enum StateType+{- |+The possible types of states of an object+-}+data StateType = +      StateTypeInvalid+    {- ^+    Indicates an invalid state - probably an error condition.+    -}+    | StateTypeActive+    {- ^+    Indicates a window is currently the active window, or an object is the active subelement within a container or table. ATK_STATE_ACTIVE should not be used for objects which have ATK_STATE_FOCUSABLE or ATK_STATE_SELECTABLE: Those objects should use ATK_STATE_FOCUSED and ATK_STATE_SELECTED respectively. ATK_STATE_ACTIVE is a means to indicate that an object which is not focusable and not selectable is the currently-active item within its parent container.+    -}+    | StateTypeArmed+    {- ^+    Indicates that the object is \'armed\', i.e. will be activated by if a pointer button-release event occurs within its bounds.  Buttons often enter this state when a pointer click occurs within their bounds, as a precursor to activation. ATK_STATE_ARMED has been deprecated since ATK-2.16 and should not be used in newly-written code.+    -}+    | StateTypeBusy+    {- ^+    Indicates the current object is busy, i.e. onscreen representation is in the process of changing, or the object is temporarily unavailable for interaction due to activity already in progress.  This state may be used by implementors of Document to indicate that content loading is underway.  It also may indicate other \'pending\' conditions; clients may wish to interrogate this object when the ATK_STATE_BUSY flag is removed.+    -}+    | StateTypeChecked+    {- ^+    Indicates this object is currently checked, for instance a checkbox is \'non-empty\'.+    -}+    | StateTypeDefunct+    {- ^+    Indicates that this object no longer has a valid backing widget (for instance, if its peer object has been destroyed)+    -}+    | StateTypeEditable+    {- ^+    Indicates that this object can contain text, and that the+    user can change the textual contents of this object by editing those contents+    directly. For an object which is expected to be editable due to its type, but+    which cannot be edited due to the application or platform preventing the user+    from doing so, that object\'s 'GI.Atk.Objects.StateSet.StateSet' should lack ATK_STATE_EDITABLE and+    should contain ATK_STATE_READ_ONLY.+    -}+    | StateTypeEnabled+    {- ^+    Indicates that this object is enabled, i.e. that it currently reflects some application state. Objects that are \"greyed out\" may lack this state, and may lack the STATE_SENSITIVE if direct user interaction cannot cause them to acquire STATE_ENABLED. See also: ATK_STATE_SENSITIVE+    -}+    | StateTypeExpandable+    {- ^+    Indicates this object allows progressive disclosure of its children+    -}+    | StateTypeExpanded+    {- ^+    Indicates this object its expanded - see ATK_STATE_EXPANDABLE above+    -}+    | StateTypeFocusable+    {- ^+    Indicates this object can accept keyboard focus, which means all events resulting from typing on the keyboard will normally be passed to it when it has focus+    -}+    | StateTypeFocused+    {- ^+    Indicates this object currently has the keyboard focus+    -}+    | StateTypeHorizontal+    {- ^+    Indicates the orientation of this object is horizontal; used, for instance, by objects of ATK_ROLE_SCROLL_BAR.  For objects where vertical\/horizontal orientation is especially meaningful.+    -}+    | StateTypeIconified+    {- ^+    Indicates this object is minimized and is represented only by an icon+    -}+    | StateTypeModal+    {- ^+    Indicates something must be done with this object before the user can interact with an object in a different window+    -}+    | StateTypeMultiLine+    {- ^+    Indicates this (text) object can contain multiple lines of text+    -}+    | StateTypeMultiselectable+    {- ^+    Indicates this object allows more than one of its children to be selected at the same time, or in the case of text objects, that the object supports non-contiguous text selections.+    -}+    | StateTypeOpaque+    {- ^+    Indicates this object paints every pixel within its rectangular region.+    -}+    | StateTypePressed+    {- ^+    Indicates this object is currently pressed.+    -}+    | StateTypeResizable+    {- ^+    Indicates the size of this object is not fixed+    -}+    | StateTypeSelectable+    {- ^+    Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that can be selected+    -}+    | StateTypeSelected+    {- ^+    Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that has been selected+    -}+    | StateTypeSensitive+    {- ^+    Indicates this object is sensitive, e.g. to user interaction.+    STATE_SENSITIVE usually accompanies STATE_ENABLED for user-actionable controls,+    but may be found in the absence of STATE_ENABLED if the current visible state of the+    control is \"disconnected\" from the application state.  In such cases, direct user interaction+    can often result in the object gaining STATE_SENSITIVE, for instance if a user makes+    an explicit selection using an object whose current state is ambiguous or undefined.+    /@see@/ STATE_ENABLED, STATE_INDETERMINATE.+    -}+    | StateTypeShowing+    {- ^+    Indicates this object, the object\'s parent, the object\'s parent\'s parent, and so on,+    are all \'shown\' to the end-user, i.e. subject to \"exposure\" if blocking or obscuring objects do not interpose+    between this object and the top of the window stack.+    -}+    | StateTypeSingleLine+    {- ^+    Indicates this (text) object can contain only a single line of text+    -}+    | StateTypeStale+    {- ^+    Indicates that the information returned for this object may no longer be+    synchronized with the application state.  This is implied if the object has STATE_TRANSIENT,+    and can also occur towards the end of the object peer\'s lifecycle. It can also be used to indicate that+    the index associated with this object has changed since the user accessed the object (in lieu of+    \"index-in-parent-changed\" events).+    -}+    | StateTypeTransient+    {- ^+    Indicates this object is transient, i.e. a snapshot which may not emit events when its+    state changes.  Data from objects with ATK_STATE_TRANSIENT should not be cached, since there may be no+    notification given when the cached data becomes obsolete.+    -}+    | StateTypeVertical+    {- ^+    Indicates the orientation of this object is vertical+    -}+    | StateTypeVisible+    {- ^+    Indicates this object is visible, e.g. has been explicitly marked for exposure to the user.+    -}+    | StateTypeManagesDescendants+    {- ^+    Indicates that \"active-descendant-changed\" event+    is sent when children become \'active\' (i.e. are selected or navigated to onscreen).+    Used to prevent need to enumerate all children in very large containers, like tables.+    The presence of STATE_MANAGES_DESCENDANTS is an indication to the client.+    that the children should not, and need not, be enumerated by the client.+    Objects implementing this state are expected to provide relevant state+    notifications to listening clients, for instance notifications of visibility+    changes and activation of their contained child objects, without the client+    having previously requested references to those children.+    -}+    | StateTypeIndeterminate+    {- ^+    Indicates that the value, or some other quantifiable+    property, of this AtkObject cannot be fully determined. In the case of a large+    data set in which the total number of items in that set is unknown (e.g. 1 of+    999+), implementors should expose the currently-known set size (999) along+    with this state. In the case of a check box, this state should be used to+    indicate that the check box is a tri-state check box which is currently+    neither checked nor unchecked.+    -}+    | StateTypeTruncated+    {- ^+    Indicates that an object is truncated, e.g. a text value in a speradsheet cell.+    -}+    | StateTypeRequired+    {- ^+    Indicates that explicit user interaction with an object is required by the user interface, e.g. a required field in a \"web-form\" interface.+    -}+    | StateTypeInvalidEntry+    {- ^+    Indicates that the object has encountered an error condition due to failure of input validation. For instance, a form control may acquire this state in response to invalid or malformed user input.+    -}+    | StateTypeSupportsAutocompletion+    {- ^+    Indicates that the object in question implements some form of ¨typeahead¨ or+    pre-selection behavior whereby entering the first character of one or more sub-elements+    causes those elements to scroll into view or become selected.  Subsequent character input+    may narrow the selection further as long as one or more sub-elements match the string.+    This state is normally only useful and encountered on objects that implement Selection.+    In some cases the typeahead behavior may result in full or partial ¨completion¨ of+    the data in the input field, in which case these input events may trigger text-changed+    events from the AtkText interface.  This state supplants /@aTKROLEAUTOCOMPLETE@/.+    -}+    | StateTypeSelectableText+    {- ^+    Indicates that the object in question supports text selection. It should only be exposed on objects which implement the Text interface, in order to distinguish this state from /@aTKSTATESELECTABLE@/, which infers that the object in question is a selectable child of an object which implements Selection. While similar, text selection and subelement selection are distinct operations.+    -}+    | StateTypeDefault+    {- ^+    Indicates that the object is the \"default\" active component, i.e. the object which is activated by an end-user press of the \"Enter\" or \"Return\" key.  Typically a \"close\" or \"submit\" button.+    -}+    | StateTypeAnimated+    {- ^+    Indicates that the object changes its appearance dynamically as an inherent part of its presentation.  This state may come and go if an object is only temporarily animated on the way to a \'final\' onscreen presentation.+    /@note@/ some applications, notably content viewers, may not be able to detect+    all kinds of animated content.  Therefore the absence of this state should not+    be taken as definitive evidence that the object\'s visual representation is+    static; this state is advisory.+    -}+    | StateTypeVisited+    {- ^+    Indicates that the object (typically a hyperlink) has already been \'activated\', and\/or its backing data has already been downloaded, rendered, or otherwise \"visited\".+    -}+    | StateTypeCheckable+    {- ^+    Indicates this object has the potential to be+     checked, such as a checkbox or toggle-able table cell. /@since@/:+     ATK-2.12+    -}+    | StateTypeHasPopup+    {- ^+    Indicates that the object has a popup context+    menu or sub-level menu which may or may not be showing. This means+    that activation renders conditional content.  Note that ordinary+    tooltips are not considered popups in this context. /@since@/: ATK-2.12+    -}+    | StateTypeHasTooltip+    {- ^+    Indicates this object has a tooltip. /@since@/: ATK-2.16+    -}+    | StateTypeReadOnly+    {- ^+    Indicates that a widget which is ENABLED and SENSITIVE+    has a value which can be read, but not modified, by the user. Note that this+    state should only be applied to widget types whose value is normally directly+    user modifiable, such as check boxes, radio buttons, spin buttons, text input+    fields, and combo boxes, as a means to convey that the expected interaction+    with that widget is not possible. When the expected interaction with a+    widget does not include modification by the user, as is the case with+    labels and containers, ATK_STATE_READ_ONLY should not be applied. See also+    ATK_STATE_EDITABLE. /@since@/: ATK-2-16+    -}+    | StateTypeLastDefined+    {- ^+    Not a valid state, used for finding end of enumeration+    -}+    | AnotherStateType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum StateType where+    fromEnum StateTypeInvalid = 0+    fromEnum StateTypeActive = 1+    fromEnum StateTypeArmed = 2+    fromEnum StateTypeBusy = 3+    fromEnum StateTypeChecked = 4+    fromEnum StateTypeDefunct = 5+    fromEnum StateTypeEditable = 6+    fromEnum StateTypeEnabled = 7+    fromEnum StateTypeExpandable = 8+    fromEnum StateTypeExpanded = 9+    fromEnum StateTypeFocusable = 10+    fromEnum StateTypeFocused = 11+    fromEnum StateTypeHorizontal = 12+    fromEnum StateTypeIconified = 13+    fromEnum StateTypeModal = 14+    fromEnum StateTypeMultiLine = 15+    fromEnum StateTypeMultiselectable = 16+    fromEnum StateTypeOpaque = 17+    fromEnum StateTypePressed = 18+    fromEnum StateTypeResizable = 19+    fromEnum StateTypeSelectable = 20+    fromEnum StateTypeSelected = 21+    fromEnum StateTypeSensitive = 22+    fromEnum StateTypeShowing = 23+    fromEnum StateTypeSingleLine = 24+    fromEnum StateTypeStale = 25+    fromEnum StateTypeTransient = 26+    fromEnum StateTypeVertical = 27+    fromEnum StateTypeVisible = 28+    fromEnum StateTypeManagesDescendants = 29+    fromEnum StateTypeIndeterminate = 30+    fromEnum StateTypeTruncated = 31+    fromEnum StateTypeRequired = 32+    fromEnum StateTypeInvalidEntry = 33+    fromEnum StateTypeSupportsAutocompletion = 34+    fromEnum StateTypeSelectableText = 35+    fromEnum StateTypeDefault = 36+    fromEnum StateTypeAnimated = 37+    fromEnum StateTypeVisited = 38+    fromEnum StateTypeCheckable = 39+    fromEnum StateTypeHasPopup = 40+    fromEnum StateTypeHasTooltip = 41+    fromEnum StateTypeReadOnly = 42+    fromEnum StateTypeLastDefined = 43+    fromEnum (AnotherStateType k) = k++    toEnum 0 = StateTypeInvalid+    toEnum 1 = StateTypeActive+    toEnum 2 = StateTypeArmed+    toEnum 3 = StateTypeBusy+    toEnum 4 = StateTypeChecked+    toEnum 5 = StateTypeDefunct+    toEnum 6 = StateTypeEditable+    toEnum 7 = StateTypeEnabled+    toEnum 8 = StateTypeExpandable+    toEnum 9 = StateTypeExpanded+    toEnum 10 = StateTypeFocusable+    toEnum 11 = StateTypeFocused+    toEnum 12 = StateTypeHorizontal+    toEnum 13 = StateTypeIconified+    toEnum 14 = StateTypeModal+    toEnum 15 = StateTypeMultiLine+    toEnum 16 = StateTypeMultiselectable+    toEnum 17 = StateTypeOpaque+    toEnum 18 = StateTypePressed+    toEnum 19 = StateTypeResizable+    toEnum 20 = StateTypeSelectable+    toEnum 21 = StateTypeSelected+    toEnum 22 = StateTypeSensitive+    toEnum 23 = StateTypeShowing+    toEnum 24 = StateTypeSingleLine+    toEnum 25 = StateTypeStale+    toEnum 26 = StateTypeTransient+    toEnum 27 = StateTypeVertical+    toEnum 28 = StateTypeVisible+    toEnum 29 = StateTypeManagesDescendants+    toEnum 30 = StateTypeIndeterminate+    toEnum 31 = StateTypeTruncated+    toEnum 32 = StateTypeRequired+    toEnum 33 = StateTypeInvalidEntry+    toEnum 34 = StateTypeSupportsAutocompletion+    toEnum 35 = StateTypeSelectableText+    toEnum 36 = StateTypeDefault+    toEnum 37 = StateTypeAnimated+    toEnum 38 = StateTypeVisited+    toEnum 39 = StateTypeCheckable+    toEnum 40 = StateTypeHasPopup+    toEnum 41 = StateTypeHasTooltip+    toEnum 42 = StateTypeReadOnly+    toEnum 43 = StateTypeLastDefined+    toEnum k = AnotherStateType k++instance P.Ord StateType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_state_type_get_type" c_atk_state_type_get_type :: +    IO GType++instance BoxedEnum StateType where+    boxedEnumType _ = c_atk_state_type_get_type++-- Enum ScrollType+{- |+Specifies where an object should be placed on the screen when using scroll_to.++/Since: 2.30/+-}+data ScrollType = +      ScrollTypeTopLeft+    {- ^+    Scroll the object vertically and horizontally to the top+    left corner of the window.+    -}+    | ScrollTypeBottomRight+    {- ^+    Scroll the object vertically and horizontally to the+    bottom right corner of the window.+    -}+    | ScrollTypeTopEdge+    {- ^+    Scroll the object vertically to the top edge of the+     window.+    -}+    | ScrollTypeBottomEdge+    {- ^+    Scroll the object vertically to the bottom edge of+    the window.+    -}+    | ScrollTypeLeftEdge+    {- ^+    Scroll the object vertically and horizontally to the+    left edge of the window.+    -}+    | ScrollTypeRightEdge+    {- ^+    Scroll the object vertically and horizontally to the+    right edge of the window.+    -}+    | ScrollTypeAnywhere+    {- ^+    Scroll the object vertically and horizontally so that+    as much as possible of the object becomes visible. The exact placement is+    determined by the application.+    -}+    | AnotherScrollType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ScrollType where+    fromEnum ScrollTypeTopLeft = 0+    fromEnum ScrollTypeBottomRight = 1+    fromEnum ScrollTypeTopEdge = 2+    fromEnum ScrollTypeBottomEdge = 3+    fromEnum ScrollTypeLeftEdge = 4+    fromEnum ScrollTypeRightEdge = 5+    fromEnum ScrollTypeAnywhere = 6+    fromEnum (AnotherScrollType k) = k++    toEnum 0 = ScrollTypeTopLeft+    toEnum 1 = ScrollTypeBottomRight+    toEnum 2 = ScrollTypeTopEdge+    toEnum 3 = ScrollTypeBottomEdge+    toEnum 4 = ScrollTypeLeftEdge+    toEnum 5 = ScrollTypeRightEdge+    toEnum 6 = ScrollTypeAnywhere+    toEnum k = AnotherScrollType k++instance P.Ord ScrollType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_scroll_type_get_type" c_atk_scroll_type_get_type :: +    IO GType++instance BoxedEnum ScrollType where+    boxedEnumType _ = c_atk_scroll_type_get_type++-- Enum Role+{- |+Describes the role of an object++These are the built-in enumerated roles that UI components can have in+ATK.  Other roles may be added at runtime, so an AtkRole >=+ATK_ROLE_LAST_DEFINED is not necessarily an error.+-}+data Role = +      RoleInvalid+    {- ^+    Invalid role+    -}+    | RoleAcceleratorLabel+    {- ^+    A label which represents an accelerator+    -}+    | RoleAlert+    {- ^+    An object which is an alert to the user. Assistive Technologies typically respond to ATK_ROLE_ALERT by reading the entire onscreen contents of containers advertising this role.  Should be used for warning dialogs, etc.+    -}+    | RoleAnimation+    {- ^+    An object which is an animated image+    -}+    | RoleArrow+    {- ^+    An arrow in one of the four cardinal directions+    -}+    | RoleCalendar+    {- ^+    An object that displays a calendar and allows the user to select a date+    -}+    | RoleCanvas+    {- ^+    An object that can be drawn into and is used to trap events+    -}+    | RoleCheckBox+    {- ^+    A choice that can be checked or unchecked and provides a separate indicator for the current state+    -}+    | RoleCheckMenuItem+    {- ^+    A menu item with a check box+    -}+    | RoleColorChooser+    {- ^+    A specialized dialog that lets the user choose a color+    -}+    | RoleColumnHeader+    {- ^+    The header for a column of data+    -}+    | RoleComboBox+    {- ^+    A collapsible list of choices the user can select from+    -}+    | RoleDateEditor+    {- ^+    An object whose purpose is to allow a user to edit a date+    -}+    | RoleDesktopIcon+    {- ^+    An inconifed internal frame within a DESKTOP_PANE+    -}+    | RoleDesktopFrame+    {- ^+    A pane that supports internal frames and iconified versions of those internal frames+    -}+    | RoleDial+    {- ^+    An object whose purpose is to allow a user to set a value+    -}+    | RoleDialog+    {- ^+    A top level window with title bar and a border+    -}+    | RoleDirectoryPane+    {- ^+    A pane that allows the user to navigate through and select the contents of a directory+    -}+    | RoleDrawingArea+    {- ^+    An object used for drawing custom user interface elements+    -}+    | RoleFileChooser+    {- ^+    A specialized dialog that lets the user choose a file+    -}+    | RoleFiller+    {- ^+    A object that fills up space in a user interface+    -}+    | RoleFontChooser+    {- ^+    A specialized dialog that lets the user choose a font+    -}+    | RoleFrame+    {- ^+    A top level window with a title bar, border, menubar, etc.+    -}+    | RoleGlassPane+    {- ^+    A pane that is guaranteed to be painted on top of all panes beneath it+    -}+    | RoleHtmlContainer+    {- ^+    A document container for HTML, whose children represent the document content+    -}+    | RoleIcon+    {- ^+    A small fixed size picture, typically used to decorate components+    -}+    | RoleImage+    {- ^+    An object whose primary purpose is to display an image+    -}+    | RoleInternalFrame+    {- ^+    A frame-like object that is clipped by a desktop pane+    -}+    | RoleLabel+    {- ^+    An object used to present an icon or short string in an interface+    -}+    | RoleLayeredPane+    {- ^+    A specialized pane that allows its children to be drawn in layers, providing a form of stacking order+    -}+    | RoleList+    {- ^+    An object that presents a list of objects to the user and allows the user to select one or more of them+    -}+    | RoleListItem+    {- ^+    An object that represents an element of a list+    -}+    | RoleMenu+    {- ^+    An object usually found inside a menu bar that contains a list of actions the user can choose from+    -}+    | RoleMenuBar+    {- ^+    An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from+    -}+    | RoleMenuItem+    {- ^+    An object usually contained in a menu that presents an action the user can choose+    -}+    | RoleOptionPane+    {- ^+    A specialized pane whose primary use is inside a DIALOG+    -}+    | RolePageTab+    {- ^+    An object that is a child of a page tab list+    -}+    | RolePageTabList+    {- ^+    An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object+    -}+    | RolePanel+    {- ^+    A generic container that is often used to group objects+    -}+    | RolePasswordText+    {- ^+    A text object uses for passwords, or other places where the text content is not shown visibly to the user+    -}+    | RolePopupMenu+    {- ^+    A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices+    -}+    | RoleProgressBar+    {- ^+    An object used to indicate how much of a task has been completed+    -}+    | RolePushButton+    {- ^+    An object the user can manipulate to tell the application to do something+    -}+    | RoleRadioButton+    {- ^+    A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked+    -}+    | RoleRadioMenuItem+    {- ^+    A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected+    -}+    | RoleRootPane+    {- ^+    A specialized pane that has a glass pane and a layered pane as its children+    -}+    | RoleRowHeader+    {- ^+    The header for a row of data+    -}+    | RoleScrollBar+    {- ^+    An object usually used to allow a user to incrementally view a large amount of data.+    -}+    | RoleScrollPane+    {- ^+    An object that allows a user to incrementally view a large amount of information+    -}+    | RoleSeparator+    {- ^+    An object usually contained in a menu to provide a visible and logical separation of the contents in a menu+    -}+    | RoleSlider+    {- ^+    An object that allows the user to select from a bounded range+    -}+    | RoleSplitPane+    {- ^+    A specialized panel that presents two other panels at the same time+    -}+    | RoleSpinButton+    {- ^+    An object used to get an integer or floating point number from the user+    -}+    | RoleStatusbar+    {- ^+    An object which reports messages of minor importance to the user+    -}+    | RoleTable+    {- ^+    An object used to represent information in terms of rows and columns+    -}+    | RoleTableCell+    {- ^+    A cell in a table+    -}+    | RoleTableColumnHeader+    {- ^+    The header for a column of a table+    -}+    | RoleTableRowHeader+    {- ^+    The header for a row of a table+    -}+    | RoleTearOffMenuItem+    {- ^+    A menu item used to tear off and reattach its menu+    -}+    | RoleTerminal+    {- ^+    An object that represents an accessible terminal.  /@since@/: ATK-0.6+    -}+    | RoleText+    {- ^+    An interactive widget that supports multiple lines of text and+    optionally accepts user input, but whose purpose is not to solicit user input.+    Thus ATK_ROLE_TEXT is appropriate for the text view in a plain text editor+    but inappropriate for an input field in a dialog box or web form. For widgets+    whose purpose is to solicit input from the user, see ATK_ROLE_ENTRY and+    ATK_ROLE_PASSWORD_TEXT. For generic objects which display a brief amount of+    textual information, see ATK_ROLE_STATIC.+    -}+    | RoleToggleButton+    {- ^+    A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state+    -}+    | RoleToolBar+    {- ^+    A bar or palette usually composed of push buttons or toggle buttons+    -}+    | RoleToolTip+    {- ^+    An object that provides information about another object+    -}+    | RoleTree+    {- ^+    An object used to represent hierarchical information to the user+    -}+    | RoleTreeTable+    {- ^+    An object capable of expanding and collapsing rows as well as showing multiple columns of data.   /@since@/: ATK-0.7+    -}+    | RoleUnknown+    {- ^+    The object contains some Accessible information, but its role is not known+    -}+    | RoleViewport+    {- ^+    An object usually used in a scroll pane+    -}+    | RoleWindow+    {- ^+    A top level window with no title or border.+    -}+    | RoleHeader+    {- ^+    An object that serves as a document header. /@since@/: ATK-1.1.1+    -}+    | RoleFooter+    {- ^+    An object that serves as a document footer.  /@since@/: ATK-1.1.1+    -}+    | RoleParagraph+    {- ^+    An object which is contains a paragraph of text content.   /@since@/: ATK-1.1.1+    -}+    | RoleRuler+    {- ^+    An object which describes margins and tab stops, etc. for text objects which it controls (should have CONTROLLER_FOR relation to such).   /@since@/: ATK-1.1.1+    -}+    | RoleApplication+    {- ^+    The object is an application object, which may contain /@aTKROLEFRAME@/ objects or other types of accessibles.  The root accessible of any application\'s ATK hierarchy should have ATK_ROLE_APPLICATION.   /@since@/: ATK-1.1.4+    -}+    | RoleAutocomplete+    {- ^+    The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry.   /@since@/: ATK-1.3+    -}+    | RoleEditBar+    {- ^+    The object is an editable text object in a toolbar.  /@since@/: ATK-1.5+    -}+    | RoleEmbedded+    {- ^+    The object is an embedded container within a document or panel.  This role is a grouping \"hint\" indicating that the contained objects share a context.  /@since@/: ATK-1.7.2+    -}+    | RoleEntry+    {- ^+    The object is a component whose textual content may be entered or modified by the user, provided /@aTKSTATEEDITABLE@/ is present.   /@since@/: ATK-1.11+    -}+    | RoleChart+    {- ^+    The object is a graphical depiction of quantitative data. It may contain multiple subelements whose attributes and\/or description may be queried to obtain both the quantitative data and information about how the data is being presented. The LABELLED_BY relation is particularly important in interpreting objects of this type, as is the accessible-description property.  /@since@/: ATK-1.11+    -}+    | RoleCaption+    {- ^+    The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image.  /@since@/: ATK-1.11+    -}+    | RoleDocumentFrame+    {- ^+    The object is a visual frame or container which contains a view of document content. Document frames may occur within another Document instance, in which case the second document may be said to be embedded in the containing instance. HTML frames are often ROLE_DOCUMENT_FRAME. Either this object, or a singleton descendant, should implement the Document interface.  /@since@/: ATK-1.11+    -}+    | RoleHeading+    {- ^+    The object serves as a heading for content which follows it in a document. The \'heading level\' of the heading, if availabe, may be obtained by querying the object\'s attributes.+    -}+    | RolePage+    {- ^+    The object is a containing instance which encapsulates a page of information. /@aTKROLEPAGE@/ is used in documents and content which support a paginated navigation model.  /@since@/: ATK-1.11+    -}+    | RoleSection+    {- ^+    The object is a containing instance of document content which constitutes a particular \'logical\' section of the document. The type of content within a section, and the nature of the section division itself, may be obtained by querying the object\'s attributes. Sections may be nested. /@since@/: ATK-1.11+    -}+    | RoleRedundantObject+    {- ^+    The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.  Objects of this role should normally be ignored by clients. /@since@/: ATK-1.11+    -}+    | RoleForm+    {- ^+    The object is a container for form controls, for instance as part of a+    web form or user-input form within a document.  This role is primarily a tag\/convenience for+    clients when navigating complex documents, it is not expected that ordinary GUI containers will+    always have ATK_ROLE_FORM. /@since@/: ATK-1.12.0+    -}+    | RoleLink+    {- ^+    The object is a hypertext anchor, i.e. a \"link\" in a+    hypertext document.  Such objects are distinct from \'inline\'+    content which may also use the Hypertext\/Hyperlink interfaces+    to indicate the range\/location within a text object where+    an inline or embedded object lies.  /@since@/: ATK-1.12.1+    -}+    | RoleInputMethodWindow+    {- ^+    The object is a window or similar viewport+    which is used to allow composition or input of a \'complex character\',+    in other words it is an \"input method window.\" /@since@/: ATK-1.12.1+    -}+    | RoleTableRow+    {- ^+    A row in a table.  /@since@/: ATK-2.1.0+    -}+    | RoleTreeItem+    {- ^+    An object that represents an element of a tree.  /@since@/: ATK-2.1.0+    -}+    | RoleDocumentSpreadsheet+    {- ^+    A document frame which contains a spreadsheet.  /@since@/: ATK-2.1.0+    -}+    | RoleDocumentPresentation+    {- ^+    A document frame which contains a presentation or slide content.  /@since@/: ATK-2.1.0+    -}+    | RoleDocumentText+    {- ^+    A document frame which contains textual content, such as found in a word processing application.  /@since@/: ATK-2.1.0+    -}+    | RoleDocumentWeb+    {- ^+    A document frame which contains HTML or other markup suitable for display in a web browser.  /@since@/: ATK-2.1.0+    -}+    | RoleDocumentEmail+    {- ^+    A document frame which contains email content to be displayed or composed either in plain text or HTML.  /@since@/: ATK-2.1.0+    -}+    | RoleComment+    {- ^+    An object found within a document and designed to present a comment, note, or other annotation. In some cases, this object might not be visible until activated.  /@since@/: ATK-2.1.0+    -}+    | RoleListBox+    {- ^+    A non-collapsible list of choices the user can select from. /@since@/: ATK-2.1.0+    -}+    | RoleGrouping+    {- ^+    A group of related widgets. This group typically has a label. /@since@/: ATK-2.1.0+    -}+    | RoleImageMap+    {- ^+    An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document. /@since@/: ATK-2.1.0+    -}+    | RoleNotification+    {- ^+    A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.  /@since@/: ATK-2.1.0+    -}+    | RoleInfoBar+    {- ^+    An object designed to present a message to the user within an existing window. /@since@/: ATK-2.1.0+    -}+    | RoleLevelBar+    {- ^+    A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.  /@since@/: ATK-2.7.3+    -}+    | RoleTitleBar+    {- ^+    A bar that serves as the title of a window or a+    dialog. /@since@/: ATK-2.12+    -}+    | RoleBlockQuote+    {- ^+    An object which contains a text section+    that is quoted from another source. /@since@/: ATK-2.12+    -}+    | RoleAudio+    {- ^+    An object which represents an audio element. /@since@/: ATK-2.12+    -}+    | RoleVideo+    {- ^+    An object which represents a video element. /@since@/: ATK-2.12+    -}+    | RoleDefinition+    {- ^+    A definition of a term or concept. /@since@/: ATK-2.12+    -}+    | RoleArticle+    {- ^+    A section of a page that consists of a+    composition that forms an independent part of a document, page, or+    site. Examples: A blog entry, a news story, a forum post. /@since@/:+    ATK-2.12+    -}+    | RoleLandmark+    {- ^+    A region of a web page intended as a+    navigational landmark. This is designed to allow Assistive+    Technologies to provide quick navigation among key regions within a+    document. /@since@/: ATK-2.12+    -}+    | RoleLog+    {- ^+    A text widget or container holding log content, such+    as chat history and error logs. In this role there is a+    relationship between the arrival of new items in the log and the+    reading order. The log contains a meaningful sequence and new+    information is added only to the end of the log, not at arbitrary+    points. /@since@/: ATK-2.12+    -}+    | RoleMarquee+    {- ^+    A container where non-essential information+    changes frequently. Common usages of marquee include stock tickers+    and ad banners. The primary difference between a marquee and a log+    is that logs usually have a meaningful order or sequence of+    important content changes. /@since@/: ATK-2.12+    -}+    | RoleMath+    {- ^+    A text widget or container that holds a mathematical+    expression. /@since@/: ATK-2.12+    -}+    | RoleRating+    {- ^+    A widget whose purpose is to display a rating,+    such as the number of stars associated with a song in a media+    player. Objects of this role should also implement+    AtkValue. /@since@/: ATK-2.12+    -}+    | RoleTimer+    {- ^+    An object containing a numerical counter which+    indicates an amount of elapsed time from a start point, or the time+    remaining until an end point. /@since@/: ATK-2.12+    -}+    | RoleDescriptionList+    {- ^+    An object that represents a list of+    term-value groups. A term-value group represents a individual+    description and consist of one or more names+    (ATK_ROLE_DESCRIPTION_TERM) followed by one or more values+    (ATK_ROLE_DESCRIPTION_VALUE). For each list, there should not be+    more than one group with the same term name. /@since@/: ATK-2.12+    -}+    | RoleDescriptionTerm+    {- ^+    An object that represents a term or phrase+    with a corresponding definition. /@since@/: ATK-2.12+    -}+    | RoleDescriptionValue+    {- ^+    An object that represents the+    description, definition or value of a term. /@since@/: ATK-2.12+    -}+    | RoleStatic+    {- ^+    A generic non-container object whose purpose is to display a+    brief amount of information to the user and whose role is known by the+    implementor but lacks semantic value for the user. Examples in which+    ATK_ROLE_STATIC is appropriate include the message displayed in a message box+    and an image used as an alternative means to display text. ATK_ROLE_STATIC+    should not be applied to widgets which are traditionally interactive, objects+    which display a significant amount of content, or any object which has an+    accessible relation pointing to another object. Implementors should expose the+    displayed information through the accessible name of the object. If doing so seems+    inappropriate, it may indicate that a different role should be used. For+    labels which describe another widget, see ATK_ROLE_LABEL. For text views, see+    ATK_ROLE_TEXT. For generic containers, see ATK_ROLE_PANEL. For objects whose+    role is not known by the implementor, see ATK_ROLE_UNKNOWN. /@since@/: ATK-2.16.+    -}+    | RoleMathFraction+    {- ^+    An object that represents a mathematical fraction.+    -}+    | RoleMathRoot+    {- ^+    An object that represents a mathematical expression+    displayed with a radical. /@since@/: ATK-2.16.+    -}+    | RoleSubscript+    {- ^+    An object that contains text that is displayed as a+    subscript. /@since@/: ATK-2.16.+    -}+    | RoleSuperscript+    {- ^+    An object that contains text that is displayed as a+    superscript. /@since@/: ATK-2.16.+    -}+    | RoleFootnote+    {- ^+    An object that contains the text of a footnote. /@since@/: ATK-2.26.+    -}+    | RoleLastDefined+    {- ^+    not a valid role, used for finding end of the enumeration+    -}+    | AnotherRole Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Role where+    fromEnum RoleInvalid = 0+    fromEnum RoleAcceleratorLabel = 1+    fromEnum RoleAlert = 2+    fromEnum RoleAnimation = 3+    fromEnum RoleArrow = 4+    fromEnum RoleCalendar = 5+    fromEnum RoleCanvas = 6+    fromEnum RoleCheckBox = 7+    fromEnum RoleCheckMenuItem = 8+    fromEnum RoleColorChooser = 9+    fromEnum RoleColumnHeader = 10+    fromEnum RoleComboBox = 11+    fromEnum RoleDateEditor = 12+    fromEnum RoleDesktopIcon = 13+    fromEnum RoleDesktopFrame = 14+    fromEnum RoleDial = 15+    fromEnum RoleDialog = 16+    fromEnum RoleDirectoryPane = 17+    fromEnum RoleDrawingArea = 18+    fromEnum RoleFileChooser = 19+    fromEnum RoleFiller = 20+    fromEnum RoleFontChooser = 21+    fromEnum RoleFrame = 22+    fromEnum RoleGlassPane = 23+    fromEnum RoleHtmlContainer = 24+    fromEnum RoleIcon = 25+    fromEnum RoleImage = 26+    fromEnum RoleInternalFrame = 27+    fromEnum RoleLabel = 28+    fromEnum RoleLayeredPane = 29+    fromEnum RoleList = 30+    fromEnum RoleListItem = 31+    fromEnum RoleMenu = 32+    fromEnum RoleMenuBar = 33+    fromEnum RoleMenuItem = 34+    fromEnum RoleOptionPane = 35+    fromEnum RolePageTab = 36+    fromEnum RolePageTabList = 37+    fromEnum RolePanel = 38+    fromEnum RolePasswordText = 39+    fromEnum RolePopupMenu = 40+    fromEnum RoleProgressBar = 41+    fromEnum RolePushButton = 42+    fromEnum RoleRadioButton = 43+    fromEnum RoleRadioMenuItem = 44+    fromEnum RoleRootPane = 45+    fromEnum RoleRowHeader = 46+    fromEnum RoleScrollBar = 47+    fromEnum RoleScrollPane = 48+    fromEnum RoleSeparator = 49+    fromEnum RoleSlider = 50+    fromEnum RoleSplitPane = 51+    fromEnum RoleSpinButton = 52+    fromEnum RoleStatusbar = 53+    fromEnum RoleTable = 54+    fromEnum RoleTableCell = 55+    fromEnum RoleTableColumnHeader = 56+    fromEnum RoleTableRowHeader = 57+    fromEnum RoleTearOffMenuItem = 58+    fromEnum RoleTerminal = 59+    fromEnum RoleText = 60+    fromEnum RoleToggleButton = 61+    fromEnum RoleToolBar = 62+    fromEnum RoleToolTip = 63+    fromEnum RoleTree = 64+    fromEnum RoleTreeTable = 65+    fromEnum RoleUnknown = 66+    fromEnum RoleViewport = 67+    fromEnum RoleWindow = 68+    fromEnum RoleHeader = 69+    fromEnum RoleFooter = 70+    fromEnum RoleParagraph = 71+    fromEnum RoleRuler = 72+    fromEnum RoleApplication = 73+    fromEnum RoleAutocomplete = 74+    fromEnum RoleEditBar = 75+    fromEnum RoleEmbedded = 76+    fromEnum RoleEntry = 77+    fromEnum RoleChart = 78+    fromEnum RoleCaption = 79+    fromEnum RoleDocumentFrame = 80+    fromEnum RoleHeading = 81+    fromEnum RolePage = 82+    fromEnum RoleSection = 83+    fromEnum RoleRedundantObject = 84+    fromEnum RoleForm = 85+    fromEnum RoleLink = 86+    fromEnum RoleInputMethodWindow = 87+    fromEnum RoleTableRow = 88+    fromEnum RoleTreeItem = 89+    fromEnum RoleDocumentSpreadsheet = 90+    fromEnum RoleDocumentPresentation = 91+    fromEnum RoleDocumentText = 92+    fromEnum RoleDocumentWeb = 93+    fromEnum RoleDocumentEmail = 94+    fromEnum RoleComment = 95+    fromEnum RoleListBox = 96+    fromEnum RoleGrouping = 97+    fromEnum RoleImageMap = 98+    fromEnum RoleNotification = 99+    fromEnum RoleInfoBar = 100+    fromEnum RoleLevelBar = 101+    fromEnum RoleTitleBar = 102+    fromEnum RoleBlockQuote = 103+    fromEnum RoleAudio = 104+    fromEnum RoleVideo = 105+    fromEnum RoleDefinition = 106+    fromEnum RoleArticle = 107+    fromEnum RoleLandmark = 108+    fromEnum RoleLog = 109+    fromEnum RoleMarquee = 110+    fromEnum RoleMath = 111+    fromEnum RoleRating = 112+    fromEnum RoleTimer = 113+    fromEnum RoleDescriptionList = 114+    fromEnum RoleDescriptionTerm = 115+    fromEnum RoleDescriptionValue = 116+    fromEnum RoleStatic = 117+    fromEnum RoleMathFraction = 118+    fromEnum RoleMathRoot = 119+    fromEnum RoleSubscript = 120+    fromEnum RoleSuperscript = 121+    fromEnum RoleFootnote = 122+    fromEnum RoleLastDefined = 123+    fromEnum (AnotherRole k) = k++    toEnum 0 = RoleInvalid+    toEnum 1 = RoleAcceleratorLabel+    toEnum 2 = RoleAlert+    toEnum 3 = RoleAnimation+    toEnum 4 = RoleArrow+    toEnum 5 = RoleCalendar+    toEnum 6 = RoleCanvas+    toEnum 7 = RoleCheckBox+    toEnum 8 = RoleCheckMenuItem+    toEnum 9 = RoleColorChooser+    toEnum 10 = RoleColumnHeader+    toEnum 11 = RoleComboBox+    toEnum 12 = RoleDateEditor+    toEnum 13 = RoleDesktopIcon+    toEnum 14 = RoleDesktopFrame+    toEnum 15 = RoleDial+    toEnum 16 = RoleDialog+    toEnum 17 = RoleDirectoryPane+    toEnum 18 = RoleDrawingArea+    toEnum 19 = RoleFileChooser+    toEnum 20 = RoleFiller+    toEnum 21 = RoleFontChooser+    toEnum 22 = RoleFrame+    toEnum 23 = RoleGlassPane+    toEnum 24 = RoleHtmlContainer+    toEnum 25 = RoleIcon+    toEnum 26 = RoleImage+    toEnum 27 = RoleInternalFrame+    toEnum 28 = RoleLabel+    toEnum 29 = RoleLayeredPane+    toEnum 30 = RoleList+    toEnum 31 = RoleListItem+    toEnum 32 = RoleMenu+    toEnum 33 = RoleMenuBar+    toEnum 34 = RoleMenuItem+    toEnum 35 = RoleOptionPane+    toEnum 36 = RolePageTab+    toEnum 37 = RolePageTabList+    toEnum 38 = RolePanel+    toEnum 39 = RolePasswordText+    toEnum 40 = RolePopupMenu+    toEnum 41 = RoleProgressBar+    toEnum 42 = RolePushButton+    toEnum 43 = RoleRadioButton+    toEnum 44 = RoleRadioMenuItem+    toEnum 45 = RoleRootPane+    toEnum 46 = RoleRowHeader+    toEnum 47 = RoleScrollBar+    toEnum 48 = RoleScrollPane+    toEnum 49 = RoleSeparator+    toEnum 50 = RoleSlider+    toEnum 51 = RoleSplitPane+    toEnum 52 = RoleSpinButton+    toEnum 53 = RoleStatusbar+    toEnum 54 = RoleTable+    toEnum 55 = RoleTableCell+    toEnum 56 = RoleTableColumnHeader+    toEnum 57 = RoleTableRowHeader+    toEnum 58 = RoleTearOffMenuItem+    toEnum 59 = RoleTerminal+    toEnum 60 = RoleText+    toEnum 61 = RoleToggleButton+    toEnum 62 = RoleToolBar+    toEnum 63 = RoleToolTip+    toEnum 64 = RoleTree+    toEnum 65 = RoleTreeTable+    toEnum 66 = RoleUnknown+    toEnum 67 = RoleViewport+    toEnum 68 = RoleWindow+    toEnum 69 = RoleHeader+    toEnum 70 = RoleFooter+    toEnum 71 = RoleParagraph+    toEnum 72 = RoleRuler+    toEnum 73 = RoleApplication+    toEnum 74 = RoleAutocomplete+    toEnum 75 = RoleEditBar+    toEnum 76 = RoleEmbedded+    toEnum 77 = RoleEntry+    toEnum 78 = RoleChart+    toEnum 79 = RoleCaption+    toEnum 80 = RoleDocumentFrame+    toEnum 81 = RoleHeading+    toEnum 82 = RolePage+    toEnum 83 = RoleSection+    toEnum 84 = RoleRedundantObject+    toEnum 85 = RoleForm+    toEnum 86 = RoleLink+    toEnum 87 = RoleInputMethodWindow+    toEnum 88 = RoleTableRow+    toEnum 89 = RoleTreeItem+    toEnum 90 = RoleDocumentSpreadsheet+    toEnum 91 = RoleDocumentPresentation+    toEnum 92 = RoleDocumentText+    toEnum 93 = RoleDocumentWeb+    toEnum 94 = RoleDocumentEmail+    toEnum 95 = RoleComment+    toEnum 96 = RoleListBox+    toEnum 97 = RoleGrouping+    toEnum 98 = RoleImageMap+    toEnum 99 = RoleNotification+    toEnum 100 = RoleInfoBar+    toEnum 101 = RoleLevelBar+    toEnum 102 = RoleTitleBar+    toEnum 103 = RoleBlockQuote+    toEnum 104 = RoleAudio+    toEnum 105 = RoleVideo+    toEnum 106 = RoleDefinition+    toEnum 107 = RoleArticle+    toEnum 108 = RoleLandmark+    toEnum 109 = RoleLog+    toEnum 110 = RoleMarquee+    toEnum 111 = RoleMath+    toEnum 112 = RoleRating+    toEnum 113 = RoleTimer+    toEnum 114 = RoleDescriptionList+    toEnum 115 = RoleDescriptionTerm+    toEnum 116 = RoleDescriptionValue+    toEnum 117 = RoleStatic+    toEnum 118 = RoleMathFraction+    toEnum 119 = RoleMathRoot+    toEnum 120 = RoleSubscript+    toEnum 121 = RoleSuperscript+    toEnum 122 = RoleFootnote+    toEnum 123 = RoleLastDefined+    toEnum k = AnotherRole k++instance P.Ord Role where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_role_get_type" c_atk_role_get_type :: +    IO GType++instance BoxedEnum Role where+    boxedEnumType _ = c_atk_role_get_type++-- Enum RelationType+{- |+Describes the type of the relation+-}+data RelationType = +      RelationTypeNull+    {- ^+    Not used, represens \"no relationship\" or an error condition.+    -}+    | RelationTypeControlledBy+    {- ^+    Indicates an object controlled by one or more target objects.+    -}+    | RelationTypeControllerFor+    {- ^+    Indicates an object is an controller for one or more target objects.+    -}+    | RelationTypeLabelFor+    {- ^+    Indicates an object is a label for one or more target objects.+    -}+    | RelationTypeLabelledBy+    {- ^+    Indicates an object is labelled by one or more target objects.+    -}+    | RelationTypeMemberOf+    {- ^+    Indicates an object is a member of a group of one or more target objects.+    -}+    | RelationTypeNodeChildOf+    {- ^+    Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell.+    -}+    | RelationTypeFlowsTo+    {- ^+    Indicates that the object has content that flows logically to another+     AtkObject in a sequential way, (for instance text-flow).+    -}+    | RelationTypeFlowsFrom+    {- ^+    Indicates that the object has content that flows logically from+     another AtkObject in a sequential way, (for instance text-flow).+    -}+    | RelationTypeSubwindowOf+    {- ^+    Indicates a subwindow attached to a component but otherwise has no connection in  the UI heirarchy to that component.+    -}+    | RelationTypeEmbeds+    {- ^+    Indicates that the object visually embeds+     another object\'s content, i.e. this object\'s content flows around+     another\'s content.+    -}+    | RelationTypeEmbeddedBy+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeEmbeds', indicates that+     this object\'s content is visualy embedded in another object.+    -}+    | RelationTypePopupFor+    {- ^+    Indicates that an object is a popup for another object.+    -}+    | RelationTypeParentWindowOf+    {- ^+    Indicates that an object is a parent window of another object.+    -}+    | RelationTypeDescribedBy+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeDescriptionFor'. Indicates that one+    or more target objects provide descriptive information about this object. This relation+    type is most appropriate for information that is not essential as its presentation may+    be user-configurable and\/or limited to an on-demand mechanism such as an assistive+    technology command. For brief, essential information such as can be found in a widget\'s+    on-screen label, use 'GI.Atk.Enums.RelationTypeLabelledBy'. For an on-screen error message, use+    'GI.Atk.Enums.RelationTypeErrorMessage'. For lengthy extended descriptive information contained in+    an on-screen object, consider using 'GI.Atk.Enums.RelationTypeDetails' as assistive technologies may+    provide a means for the user to navigate to objects containing detailed descriptions so+    that their content can be more closely reviewed.+    -}+    | RelationTypeDescriptionFor+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeDescribedBy'. Indicates that this+    object provides descriptive information about the target object(s). See also+    'GI.Atk.Enums.RelationTypeDetailsFor' and 'GI.Atk.Enums.RelationTypeErrorFor'.+    -}+    | RelationTypeNodeParentOf+    {- ^+    Indicates an object is a cell in a treetable and is expanded to display other cells in the same column.+    -}+    | RelationTypeDetails+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeDetailsFor'. Indicates that this object+    has a detailed or extended description, the contents of which can be found in the target+    object(s). This relation type is most appropriate for information that is sufficiently+    lengthy as to make navigation to the container of that information desirable. For less+    verbose information suitable for announcement only, see 'GI.Atk.Enums.RelationTypeDescribedBy'. If+    the detailed information describes an error condition, 'GI.Atk.Enums.RelationTypeErrorFor' should be+    used instead. /@since@/: ATK-2.26.+    -}+    | RelationTypeDetailsFor+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeDetails'. Indicates that this object+    provides a detailed or extended description about the target object(s). See also+    'GI.Atk.Enums.RelationTypeDescriptionFor' and 'GI.Atk.Enums.RelationTypeErrorFor'. /@since@/: ATK-2.26.+    -}+    | RelationTypeErrorMessage+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeErrorFor'. Indicates that this object+    has one or more errors, the nature of which is described in the contents of the target+    object(s). Objects that have this relation type should also contain 'GI.Atk.Enums.StateTypeInvalidEntry'+    in their 'GI.Atk.Objects.StateSet.StateSet'. /@since@/: ATK-2.26.+    -}+    | RelationTypeErrorFor+    {- ^+    Reciprocal of 'GI.Atk.Enums.RelationTypeErrorMessage'. Indicates that this object+    contains an error message describing an invalid condition in the target object(s). /@since@/:+    ATK_2.26.+    -}+    | RelationTypeLastDefined+    {- ^+    Not used, this value indicates the end of the enumeration.+    -}+    | AnotherRelationType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum RelationType where+    fromEnum RelationTypeNull = 0+    fromEnum RelationTypeControlledBy = 1+    fromEnum RelationTypeControllerFor = 2+    fromEnum RelationTypeLabelFor = 3+    fromEnum RelationTypeLabelledBy = 4+    fromEnum RelationTypeMemberOf = 5+    fromEnum RelationTypeNodeChildOf = 6+    fromEnum RelationTypeFlowsTo = 7+    fromEnum RelationTypeFlowsFrom = 8+    fromEnum RelationTypeSubwindowOf = 9+    fromEnum RelationTypeEmbeds = 10+    fromEnum RelationTypeEmbeddedBy = 11+    fromEnum RelationTypePopupFor = 12+    fromEnum RelationTypeParentWindowOf = 13+    fromEnum RelationTypeDescribedBy = 14+    fromEnum RelationTypeDescriptionFor = 15+    fromEnum RelationTypeNodeParentOf = 16+    fromEnum RelationTypeDetails = 17+    fromEnum RelationTypeDetailsFor = 18+    fromEnum RelationTypeErrorMessage = 19+    fromEnum RelationTypeErrorFor = 20+    fromEnum RelationTypeLastDefined = 21+    fromEnum (AnotherRelationType k) = k++    toEnum 0 = RelationTypeNull+    toEnum 1 = RelationTypeControlledBy+    toEnum 2 = RelationTypeControllerFor+    toEnum 3 = RelationTypeLabelFor+    toEnum 4 = RelationTypeLabelledBy+    toEnum 5 = RelationTypeMemberOf+    toEnum 6 = RelationTypeNodeChildOf+    toEnum 7 = RelationTypeFlowsTo+    toEnum 8 = RelationTypeFlowsFrom+    toEnum 9 = RelationTypeSubwindowOf+    toEnum 10 = RelationTypeEmbeds+    toEnum 11 = RelationTypeEmbeddedBy+    toEnum 12 = RelationTypePopupFor+    toEnum 13 = RelationTypeParentWindowOf+    toEnum 14 = RelationTypeDescribedBy+    toEnum 15 = RelationTypeDescriptionFor+    toEnum 16 = RelationTypeNodeParentOf+    toEnum 17 = RelationTypeDetails+    toEnum 18 = RelationTypeDetailsFor+    toEnum 19 = RelationTypeErrorMessage+    toEnum 20 = RelationTypeErrorFor+    toEnum 21 = RelationTypeLastDefined+    toEnum k = AnotherRelationType k++instance P.Ord RelationType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_relation_type_get_type" c_atk_relation_type_get_type :: +    IO GType++instance BoxedEnum RelationType where+    boxedEnumType _ = c_atk_relation_type_get_type++-- Enum Layer+{- |+Describes the layer of a component++These enumerated \"layer values\" are used when determining which UI+rendering layer a component is drawn into, which can help in making+determinations of when components occlude one another.+-}+data Layer = +      LayerInvalid+    {- ^+    The object does not have a layer+    -}+    | LayerBackground+    {- ^+    This layer is reserved for the desktop background+    -}+    | LayerCanvas+    {- ^+    This layer is used for Canvas components+    -}+    | LayerWidget+    {- ^+    This layer is normally used for components+    -}+    | LayerMdi+    {- ^+    This layer is used for layered components+    -}+    | LayerPopup+    {- ^+    This layer is used for popup components, such as menus+    -}+    | LayerOverlay+    {- ^+    This layer is reserved for future use.+    -}+    | LayerWindow+    {- ^+    This layer is used for toplevel windows.+    -}+    | AnotherLayer Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Layer where+    fromEnum LayerInvalid = 0+    fromEnum LayerBackground = 1+    fromEnum LayerCanvas = 2+    fromEnum LayerWidget = 3+    fromEnum LayerMdi = 4+    fromEnum LayerPopup = 5+    fromEnum LayerOverlay = 6+    fromEnum LayerWindow = 7+    fromEnum (AnotherLayer k) = k++    toEnum 0 = LayerInvalid+    toEnum 1 = LayerBackground+    toEnum 2 = LayerCanvas+    toEnum 3 = LayerWidget+    toEnum 4 = LayerMdi+    toEnum 5 = LayerPopup+    toEnum 6 = LayerOverlay+    toEnum 7 = LayerWindow+    toEnum k = AnotherLayer k++instance P.Ord Layer where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_layer_get_type" c_atk_layer_get_type :: +    IO GType++instance BoxedEnum Layer where+    boxedEnumType _ = c_atk_layer_get_type++-- Enum KeyEventType+{- |+Specifies the type of a keyboard evemt.+-}+data KeyEventType = +      KeyEventTypePress+    {- ^+    specifies a key press event+    -}+    | KeyEventTypeRelease+    {- ^+    specifies a key release event+    -}+    | KeyEventTypeLastDefined+    {- ^+    Not a valid value; specifies end of enumeration+    -}+    | AnotherKeyEventType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum KeyEventType where+    fromEnum KeyEventTypePress = 0+    fromEnum KeyEventTypeRelease = 1+    fromEnum KeyEventTypeLastDefined = 2+    fromEnum (AnotherKeyEventType k) = k++    toEnum 0 = KeyEventTypePress+    toEnum 1 = KeyEventTypeRelease+    toEnum 2 = KeyEventTypeLastDefined+    toEnum k = AnotherKeyEventType k++instance P.Ord KeyEventType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_key_event_type_get_type" c_atk_key_event_type_get_type :: +    IO GType++instance BoxedEnum KeyEventType where+    boxedEnumType _ = c_atk_key_event_type_get_type++-- Enum CoordType+{- |+Specifies how xy coordinates are to be interpreted. Used by functions such+as 'GI.Atk.Interfaces.Component.componentGetPosition' and 'GI.Atk.Interfaces.Text.textGetCharacterExtents'+-}+data CoordType = +      CoordTypeScreen+    {- ^+    specifies xy coordinates relative to the screen+    -}+    | CoordTypeWindow+    {- ^+    specifies xy coordinates relative to the widget\'s+    top-level window+    -}+    | CoordTypeParent+    {- ^+    specifies xy coordinates relative to the widget\'s+    immediate parent. Since: 2.30+    -}+    | AnotherCoordType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CoordType where+    fromEnum CoordTypeScreen = 0+    fromEnum CoordTypeWindow = 1+    fromEnum CoordTypeParent = 2+    fromEnum (AnotherCoordType k) = k++    toEnum 0 = CoordTypeScreen+    toEnum 1 = CoordTypeWindow+    toEnum 2 = CoordTypeParent+    toEnum k = AnotherCoordType k++instance P.Ord CoordType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_coord_type_get_type" c_atk_coord_type_get_type :: +    IO GType++instance BoxedEnum CoordType where+    boxedEnumType _ = c_atk_coord_type_get_type++

@@ -0,0 +1,60 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Enums where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++data ValueType+instance P.Enum ValueType where+instance BoxedEnum ValueType where+data TextGranularity+instance P.Enum TextGranularity where+instance BoxedEnum TextGranularity where+data TextClipType+instance P.Enum TextClipType where+instance BoxedEnum TextClipType where+data TextBoundary+instance P.Enum TextBoundary where+instance BoxedEnum TextBoundary where+data TextAttribute+instance P.Enum TextAttribute where+instance BoxedEnum TextAttribute where+data StateType+instance P.Enum StateType where+instance BoxedEnum StateType where+data ScrollType+instance P.Enum ScrollType where+instance BoxedEnum ScrollType where+data Role+instance P.Enum Role where+instance BoxedEnum Role where+data RelationType+instance P.Enum RelationType where+instance BoxedEnum RelationType where+data Layer+instance P.Enum Layer where+instance BoxedEnum Layer where+data KeyEventType+instance P.Enum KeyEventType where+instance BoxedEnum KeyEventType where+data CoordType+instance P.Enum CoordType where+instance BoxedEnum CoordType where

@@ -0,0 +1,77 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Flags+    ( ++ -- * Flags+-- ** HyperlinkStateFlags #flag:HyperlinkStateFlags#++    HyperlinkStateFlags(..)                 ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- Flags HyperlinkStateFlags+{- |+Describes the type of link+-}+data HyperlinkStateFlags = +      HyperlinkStateFlagsInline+    {- ^+    Link is inline+    -}+    | AnotherHyperlinkStateFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum HyperlinkStateFlags where+    fromEnum HyperlinkStateFlagsInline = 1+    fromEnum (AnotherHyperlinkStateFlags k) = k++    toEnum 1 = HyperlinkStateFlagsInline+    toEnum k = AnotherHyperlinkStateFlags k++instance P.Ord HyperlinkStateFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "atk_hyperlink_state_flags_get_type" c_atk_hyperlink_state_flags_get_type :: +    IO GType++instance BoxedFlags HyperlinkStateFlags where+    boxedFlagsType _ = c_atk_hyperlink_state_flags_get_type++instance IsGFlag HyperlinkStateFlags++

@@ -0,0 +1,28 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Flags where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++data HyperlinkStateFlags+instance P.Enum HyperlinkStateFlags where+instance BoxedFlags HyperlinkStateFlags where+instance IsGFlag HyperlinkStateFlags

@@ -0,0 +1,529 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Functions+    ( ++ -- * Methods+-- ** focusTrackerNotify #method:focusTrackerNotify#++    focusTrackerNotify                      ,+++-- ** getBinaryAge #method:getBinaryAge#++    getBinaryAge                            ,+++-- ** getDefaultRegistry #method:getDefaultRegistry#++    getDefaultRegistry                      ,+++-- ** getFocusObject #method:getFocusObject#++    getFocusObject                          ,+++-- ** getInterfaceAge #method:getInterfaceAge#++    getInterfaceAge                         ,+++-- ** getMajorVersion #method:getMajorVersion#++    getMajorVersion                         ,+++-- ** getMicroVersion #method:getMicroVersion#++    getMicroVersion                         ,+++-- ** getMinorVersion #method:getMinorVersion#++    getMinorVersion                         ,+++-- ** getRoot #method:getRoot#++    getRoot                                 ,+++-- ** getToolkitName #method:getToolkitName#++    getToolkitName                          ,+++-- ** getToolkitVersion #method:getToolkitVersion#++    getToolkitVersion                       ,+++-- ** getVersion #method:getVersion#++    getVersion                              ,+++-- ** removeFocusTracker #method:removeFocusTracker#++    removeFocusTracker                      ,+++-- ** removeGlobalEventListener #method:removeGlobalEventListener#++    removeGlobalEventListener               ,+++-- ** removeKeyEventListener #method:removeKeyEventListener#++    removeKeyEventListener                  ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object+import {-# SOURCE #-} qualified GI.Atk.Objects.Registry as Atk.Registry++-- function atk_remove_key_event_listener+-- Args : [Arg {argCName = "listener_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the id of the event listener to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_remove_key_event_listener" atk_remove_key_event_listener :: +    Word32 ->                               -- listener_id : TBasicType TUInt+    IO ()++{- |+/@listenerId@/ is the value returned by @/atk_add_key_event_listener/@+when you registered that event listener.++Removes the specified event listener.+-}+removeKeyEventListener ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word32+    {- ^ /@listenerId@/: the id of the event listener to remove -}+    -> m ()+removeKeyEventListener listenerId = liftIO $ do+    atk_remove_key_event_listener listenerId+    return ()+++-- function atk_remove_global_event_listener+-- Args : [Arg {argCName = "listener_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the id of the event listener to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_remove_global_event_listener" atk_remove_global_event_listener :: +    Word32 ->                               -- listener_id : TBasicType TUInt+    IO ()++{- |+/@listenerId@/ is the value returned by @/atk_add_global_event_listener/@+when you registered that event listener.++Toolkit implementor note: ATK provides a default implementation for+this virtual method. ATK implementors are discouraged from+reimplementing this method.++Toolkit implementor note: this method is not intended to be used by+ATK implementors but by ATK consumers.++Removes the specified event listener+-}+removeGlobalEventListener ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word32+    {- ^ /@listenerId@/: the id of the event listener to remove -}+    -> m ()+removeGlobalEventListener listenerId = liftIO $ do+    atk_remove_global_event_listener listenerId+    return ()+++-- function atk_remove_focus_tracker+-- Args : [Arg {argCName = "tracker_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the id of the focus tracker to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_remove_focus_tracker" atk_remove_focus_tracker :: +    Word32 ->                               -- tracker_id : TBasicType TUInt+    IO ()++{-# DEPRECATED removeFocusTracker ["(Since version 2.9.4)","Focus tracking has been dropped as a feature","to be implemented by ATK itself. If you need focus tracking on your","implementation, subscribe to the 'GI.Atk.Objects.Object.Object'::@/state-change/@ \\\"focused\\\" signal.","","Removes the specified focus tracker from the list of functions","to be called when any object receives focus."] #-}+{- |+/No description available in the introspection data./+-}+removeFocusTracker ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word32+    {- ^ /@trackerId@/: the id of the focus tracker to remove -}+    -> m ()+removeFocusTracker trackerId = liftIO $ do+    atk_remove_focus_tracker trackerId+    return ()+++-- function atk_get_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_version" atk_get_version :: +    IO CString++{- |+Gets the current version for ATK.++/Since: 1.20/+-}+getVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m T.Text+    {- ^ __Returns:__ version string for ATK -}+getVersion  = liftIO $ do+    result <- atk_get_version+    checkUnexpectedReturnNULL "getVersion" result+    result' <- cstringToText result+    return result'+++-- function atk_get_toolkit_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_toolkit_version" atk_get_toolkit_version :: +    IO CString++{- |+Gets version string for the GUI toolkit implementing ATK for this application.+-}+getToolkitVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m T.Text+    {- ^ __Returns:__ version string for the GUI toolkit implementing ATK for this application -}+getToolkitVersion  = liftIO $ do+    result <- atk_get_toolkit_version+    checkUnexpectedReturnNULL "getToolkitVersion" result+    result' <- cstringToText result+    return result'+++-- function atk_get_toolkit_name+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_toolkit_name" atk_get_toolkit_name :: +    IO CString++{- |+Gets name string for the GUI toolkit implementing ATK for this application.+-}+getToolkitName ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m T.Text+    {- ^ __Returns:__ name string for the GUI toolkit implementing ATK for this application -}+getToolkitName  = liftIO $ do+    result <- atk_get_toolkit_name+    checkUnexpectedReturnNULL "getToolkitName" result+    result' <- cstringToText result+    return result'+++-- function atk_get_root+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_root" atk_get_root :: +    IO (Ptr Atk.Object.Object)++{- |+Gets the root accessible container for the current application.+-}+getRoot ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Atk.Object.Object+    {- ^ __Returns:__ the root accessible container for the current+application -}+getRoot  = liftIO $ do+    result <- atk_get_root+    checkUnexpectedReturnNULL "getRoot" result+    result' <- (newObject Atk.Object.Object) result+    return result'+++-- function atk_get_minor_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_minor_version" atk_get_minor_version :: +    IO Word32++{- |+Returns the minor version number of the ATK library.  (e.g. in ATK+version 2.7.4 this is 7.)++This function is in the library, so it represents the ATK library+your code is are running against. In contrast, the+'GI.Atk.Constants.MINOR_VERSION' macro represents the minor version of the ATK+headers you have included when compiling your code.++/Since: 2.8/+-}+getMinorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the minor version number of the ATK library -}+getMinorVersion  = liftIO $ do+    result <- atk_get_minor_version+    return result+++-- function atk_get_micro_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_micro_version" atk_get_micro_version :: +    IO Word32++{- |+Returns the micro version number of the ATK library.  (e.g. in ATK+version 2.7.4 this is 4.)++This function is in the library, so it represents the ATK library+your code is are running against. In contrast, the+'GI.Atk.Constants.MICRO_VERSION' macro represents the micro version of the ATK+headers you have included when compiling your code.++/Since: 2.8/+-}+getMicroVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the micro version number of the ATK library -}+getMicroVersion  = liftIO $ do+    result <- atk_get_micro_version+    return result+++-- function atk_get_major_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_major_version" atk_get_major_version :: +    IO Word32++{- |+Returns the major version number of the ATK library.  (e.g. in ATK+version 2.7.4 this is 2.)++This function is in the library, so it represents the ATK library+your code is running against. In contrast, the 'GI.Atk.Constants.MAJOR_VERSION'+macro represents the major version of the ATK headers you have+included when compiling your code.++/Since: 2.8/+-}+getMajorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the major version number of the ATK library -}+getMajorVersion  = liftIO $ do+    result <- atk_get_major_version+    return result+++-- function atk_get_interface_age+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_interface_age" atk_get_interface_age :: +    IO Word32++{- |+Returns the interface age as passed to libtool when building the+ATK library the process is running against.++/Since: 2.8/+-}+getInterfaceAge ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the interface age of the ATK library -}+getInterfaceAge  = liftIO $ do+    result <- atk_get_interface_age+    return result+++-- function atk_get_focus_object+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_focus_object" atk_get_focus_object :: +    IO (Ptr Atk.Object.Object)++{- |+Gets the currently focused object.++/Since: 1.6/+-}+getFocusObject ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Atk.Object.Object+    {- ^ __Returns:__ the currently focused object for the current+application -}+getFocusObject  = liftIO $ do+    result <- atk_get_focus_object+    checkUnexpectedReturnNULL "getFocusObject" result+    result' <- (newObject Atk.Object.Object) result+    return result'+++-- function atk_get_default_registry+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Registry"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_default_registry" atk_get_default_registry :: +    IO (Ptr Atk.Registry.Registry)++{- |+Gets a default implementation of the 'GI.Atk.Objects.ObjectFactory.ObjectFactory'\/type+registry.+Note: For most toolkit maintainers, this will be the correct+registry for registering new 'GI.Atk.Objects.Object.Object' factories. Following+a call to this function, maintainers may call 'GI.Atk.Objects.Registry.registrySetFactoryType'+to associate an 'GI.Atk.Objects.ObjectFactory.ObjectFactory' subclass with the GType of objects+for whom accessibility information will be provided.+-}+getDefaultRegistry ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Atk.Registry.Registry+    {- ^ __Returns:__ a default implementation of the+'GI.Atk.Objects.ObjectFactory.ObjectFactory'\/type registry -}+getDefaultRegistry  = liftIO $ do+    result <- atk_get_default_registry+    checkUnexpectedReturnNULL "getDefaultRegistry" result+    result' <- (wrapObject Atk.Registry.Registry) result+    return result'+++-- function atk_get_binary_age+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_get_binary_age" atk_get_binary_age :: +    IO Word32++{- |+Returns the binary age as passed to libtool when building the ATK+library the process is running against.++/Since: 2.8/+-}+getBinaryAge ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the binary age of the ATK library -}+getBinaryAge  = liftIO $ do+    result <- atk_get_binary_age+    return result+++-- function atk_focus_tracker_notify+-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_focus_tracker_notify" atk_focus_tracker_notify :: +    Ptr Atk.Object.Object ->                -- object : TInterface (Name {namespace = "Atk", name = "Object"})+    IO ()++{-# DEPRECATED focusTrackerNotify ["(Since version 2.9.4)","Focus tracking has been dropped as a feature","to be implemented by ATK itself. As 'GI.Atk.Objects.Object.Object'::@/focus-event/@ was","deprecated in favor of a 'GI.Atk.Objects.Object.Object'::@/state-change/@ signal, in order","to notify a focus change on your implementation, you can use","'GI.Atk.Objects.Object.objectNotifyStateChange' instead."] #-}+{- |+Cause the focus tracker functions which have been specified to be+executed for the object.+-}+focusTrackerNotify ::+    (B.CallStack.HasCallStack, MonadIO m, Atk.Object.IsObject a) =>+    a+    {- ^ /@object@/: an 'GI.Atk.Objects.Object.Object' -}+    -> m ()+focusTrackerNotify object = liftIO $ do+    object' <- unsafeManagedPtrCastPtr object+    atk_focus_tracker_notify object'+    touchManagedPtr object+    return ()+++

@@ -0,0 +1,69 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces+    (     module GI.Atk.Interfaces.Action         ,+    module GI.Atk.Interfaces.Component      ,+    module GI.Atk.Interfaces.Document       ,+    module GI.Atk.Interfaces.EditableText   ,+    module GI.Atk.Interfaces.HyperlinkImpl  ,+    module GI.Atk.Interfaces.Hypertext      ,+    module GI.Atk.Interfaces.Image          ,+    module GI.Atk.Interfaces.ImplementorIface,+    module GI.Atk.Interfaces.Selection      ,+    module GI.Atk.Interfaces.StreamableContent,+    module GI.Atk.Interfaces.Table          ,+    module GI.Atk.Interfaces.TableCell      ,+    module GI.Atk.Interfaces.Text           ,+    module GI.Atk.Interfaces.Value          ,+    module GI.Atk.Interfaces.Window         ,+++    ) where++import GI.Atk.Interfaces.Action+import GI.Atk.Interfaces.Component+import GI.Atk.Interfaces.Document+import GI.Atk.Interfaces.EditableText+import GI.Atk.Interfaces.HyperlinkImpl+import GI.Atk.Interfaces.Hypertext+import GI.Atk.Interfaces.Image+import GI.Atk.Interfaces.ImplementorIface+import GI.Atk.Interfaces.Selection+import GI.Atk.Interfaces.StreamableContent+import GI.Atk.Interfaces.Table+import GI.Atk.Interfaces.TableCell+import GI.Atk.Interfaces.Text+import GI.Atk.Interfaces.Value+import GI.Atk.Interfaces.Window++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++

@@ -0,0 +1,481 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++'GI.Atk.Interfaces.Action.Action' should be implemented by instances of 'GI.Atk.Objects.Object.Object' classes+with which the user can interact directly, i.e. buttons,+checkboxes, scrollbars, e.g. components which are not \"passive\"+providers of UI information.++Exceptions: when the user interaction is already covered by another+appropriate interface such as 'GI.Atk.Interfaces.EditableText.EditableText' (insert\/delete text,+etc.) or 'GI.Atk.Interfaces.Value.Value' (set value) then these actions should not be+exposed by 'GI.Atk.Interfaces.Action.Action' as well.++Though most UI interactions on components should be invocable via+keyboard as well as mouse, there will generally be a close mapping+between \"mouse actions\" that are possible on a component and the+AtkActions.  Where mouse and keyboard actions are redundant in+effect, 'GI.Atk.Interfaces.Action.Action' should expose only one action rather than+exposing redundant actions if possible.  By convention we have been+using \"mouse centric\" terminology for 'GI.Atk.Interfaces.Action.Action' names.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces.Action+    ( ++-- * Exported types+    Action(..)                              ,+    noAction                                ,+    IsAction                                ,+++ -- * Methods+-- ** doAction #method:doAction#++#if ENABLE_OVERLOADING+    ActionDoActionMethodInfo                ,+#endif+    actionDoAction                          ,+++-- ** getDescription #method:getDescription#++#if ENABLE_OVERLOADING+    ActionGetDescriptionMethodInfo          ,+#endif+    actionGetDescription                    ,+++-- ** getKeybinding #method:getKeybinding#++#if ENABLE_OVERLOADING+    ActionGetKeybindingMethodInfo           ,+#endif+    actionGetKeybinding                     ,+++-- ** getLocalizedName #method:getLocalizedName#++#if ENABLE_OVERLOADING+    ActionGetLocalizedNameMethodInfo        ,+#endif+    actionGetLocalizedName                  ,+++-- ** getNActions #method:getNActions#++#if ENABLE_OVERLOADING+    ActionGetNActionsMethodInfo             ,+#endif+    actionGetNActions                       ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    ActionGetNameMethodInfo                 ,+#endif+    actionGetName                           ,+++-- ** setDescription #method:setDescription#++#if ENABLE_OVERLOADING+    ActionSetDescriptionMethodInfo          ,+#endif+    actionSetDescription                    ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- interface Action +-- | Memory-managed wrapper type.+newtype Action = Action (ManagedPtr Action)+-- | A convenience alias for `Nothing` :: `Maybe` `Action`.+noAction :: Maybe Action+noAction = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList Action = ActionSignalList+type ActionSignalList = ('[ ] :: [(Symbol, *)])++#endif++-- | Type class for types which implement `Action`.+class ManagedPtrNewtype a => IsAction a+instance IsAction Action+-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?+instance WrappedPtr Action where+    wrappedPtrCalloc = return nullPtr+    wrappedPtrCopy = return+    wrappedPtrFree = Nothing+++#if ENABLE_OVERLOADING+type family ResolveActionMethod (t :: Symbol) (o :: *) :: * where+    ResolveActionMethod "doAction" o = ActionDoActionMethodInfo+    ResolveActionMethod "getDescription" o = ActionGetDescriptionMethodInfo+    ResolveActionMethod "getKeybinding" o = ActionGetKeybindingMethodInfo+    ResolveActionMethod "getLocalizedName" o = ActionGetLocalizedNameMethodInfo+    ResolveActionMethod "getNActions" o = ActionGetNActionsMethodInfo+    ResolveActionMethod "getName" o = ActionGetNameMethodInfo+    ResolveActionMethod "setDescription" o = ActionSetDescriptionMethodInfo+    ResolveActionMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => OL.IsLabel t (Action -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method Action::do_action+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_do_action" atk_action_do_action :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    IO CInt++{- |+Perform the specified action on the object.+-}+actionDoAction ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> m Bool+    {- ^ __Returns:__ 'True' if success, 'False' otherwise -}+actionDoAction action i = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_do_action action' i+    let result' = (/= 0) result+    touchManagedPtr action+    return result'++#if ENABLE_OVERLOADING+data ActionDoActionMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionDoActionMethodInfo a signature where+    overloadedMethod _ = actionDoAction++#endif++-- method Action::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_get_description" atk_action_get_description :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    IO CString++{- |+Returns a description of the specified action of the object.+-}+actionGetDescription ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a description string, or 'Nothing' if /@action@/ does+not implement this interface. -}+actionGetDescription action i = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_get_description action' i+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr action+    return maybeResult++#if ENABLE_OVERLOADING+data ActionGetDescriptionMethodInfo+instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetDescriptionMethodInfo a signature where+    overloadedMethod _ = actionGetDescription++#endif++-- method Action::get_keybinding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_get_keybinding" atk_action_get_keybinding :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    IO CString++{- |+Gets the keybinding which can be used to activate this action, if one+exists. The string returned should contain localized, human-readable,+key sequences as they would appear when displayed on screen. It must+be in the format \"mnemonic;sequence;shortcut\".++* The mnemonic key activates the object if it is presently enabled onscreen.+This typically corresponds to the underlined letter within the widget.+Example: \"n\" in a traditional \"New...\" menu item or the \"a\" in \"Apply\" for+a button.+* The sequence is the full list of keys which invoke the action even if the+relevant element is not currently shown on screen. For instance, for a menu+item the sequence is the keybindings used to open the parent menus before+invoking. The sequence string is colon-delimited. Example: \"Alt+F:N\" in a+traditional \"New...\" menu item.+* The shortcut, if it exists, will invoke the same action without showing+the component or its enclosing menus or dialogs. Example: \"Ctrl+N\" in a+traditional \"New...\" menu item.+++Example: For a traditional \"New...\" menu item, the expected return value+would be: \"N;Alt+F:N;Ctrl+N\" for the English locale and \"N;Alt+D:N;Strg+N\"+for the German locale. If, hypothetically, this menu item lacked a mnemonic,+it would be represented by \";;Ctrl+N\" and \";;Strg+N\" respectively.+-}+actionGetKeybinding ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the keybinding which can be used to activate+this action, or 'Nothing' if there is no keybinding for this action. -}+actionGetKeybinding action i = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_get_keybinding action' i+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr action+    return maybeResult++#if ENABLE_OVERLOADING+data ActionGetKeybindingMethodInfo+instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetKeybindingMethodInfo a signature where+    overloadedMethod _ = actionGetKeybinding++#endif++-- method Action::get_localized_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_get_localized_name" atk_action_get_localized_name :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    IO CString++{- |+Returns the localized name of the specified action of the object.+-}+actionGetLocalizedName ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a name string, or 'Nothing' if /@action@/ does not+implement this interface. -}+actionGetLocalizedName action i = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_get_localized_name action' i+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr action+    return maybeResult++#if ENABLE_OVERLOADING+data ActionGetLocalizedNameMethodInfo+instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetLocalizedNameMethodInfo a signature where+    overloadedMethod _ = actionGetLocalizedName++#endif++-- method Action::get_n_actions+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_get_n_actions" atk_action_get_n_actions :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    IO Int32++{- |+Gets the number of accessible actions available on the object.+If there are more than one, the first one is considered the+\"default\" action of the object.+-}+actionGetNActions ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> m Int32+    {- ^ __Returns:__ a the number of actions, or 0 if /@action@/ does not+implement this interface. -}+actionGetNActions action = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_get_n_actions action'+    touchManagedPtr action+    return result++#if ENABLE_OVERLOADING+data ActionGetNActionsMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsAction a) => O.MethodInfo ActionGetNActionsMethodInfo a signature where+    overloadedMethod _ = actionGetNActions++#endif++-- method Action::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_get_name" atk_action_get_name :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    IO CString++{- |+Returns a non-localized string naming the specified action of the+object. This name is generally not descriptive of the end result+of the action, but instead names the \'interaction type\' which the+object supports. By convention, the above strings should be used to+represent the actions which correspond to the common point-and-click+interaction techniques of the same name: i.e.+\"click\", \"press\", \"release\", \"drag\", \"drop\", \"popup\", etc.+The \"popup\" action should be used to pop up a context menu for the+object, if one exists.++For technical reasons, some toolkits cannot guarantee that the+reported action is actually \'bound\' to a nontrivial user event;+i.e. the result of some actions via 'GI.Atk.Interfaces.Action.actionDoAction' may be+NIL.+-}+actionGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a name string, or 'Nothing' if /@action@/ does not+implement this interface. -}+actionGetName action i = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    result <- atk_action_get_name action' i+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr action+    return maybeResult++#if ENABLE_OVERLOADING+data ActionGetNameMethodInfo+instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetNameMethodInfo a signature where+    overloadedMethod _ = actionGetName++#endif++-- method Action::set_description+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Atk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkActionIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action index corresponding to the action to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "desc", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the description to be assigned to this action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_action_set_description" atk_action_set_description :: +    Ptr Action ->                           -- action : TInterface (Name {namespace = "Atk", name = "Action"})+    Int32 ->                                -- i : TBasicType TInt+    CString ->                              -- desc : TBasicType TUTF8+    IO CInt++{- |+Sets a description of the specified action of the object.+-}+actionSetDescription ::+    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>+    a+    {- ^ /@action@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkActionIface -}+    -> Int32+    {- ^ /@i@/: the action index corresponding to the action to be performed -}+    -> T.Text+    {- ^ /@desc@/: the description to be assigned to this action -}+    -> m Bool+    {- ^ __Returns:__ a gboolean representing if the description was successfully set; -}+actionSetDescription action i desc = liftIO $ do+    action' <- unsafeManagedPtrCastPtr action+    desc' <- textToCString desc+    result <- atk_action_set_description action' i desc'+    let result' = (/= 0) result+    touchManagedPtr action+    freeMem desc'+    return result'++#if ENABLE_OVERLOADING+data ActionSetDescriptionMethodInfo+instance (signature ~ (Int32 -> T.Text -> m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionSetDescriptionMethodInfo a signature where+    overloadedMethod _ = actionSetDescription++#endif++

@@ -0,0 +1,48 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Interfaces.Action where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Action = Action (ManagedPtr Action)+class ManagedPtrNewtype a => IsAction a+instance WrappedPtr Action where+#if ENABLE_OVERLOADING+data ActionDoActionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionGetDescriptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionGetKeybindingMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionGetLocalizedNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionGetNActionsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ActionSetDescriptionMethodInfo+#endif

@@ -0,0 +1,1035 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++'GI.Atk.Interfaces.Component.Component' should be implemented by most if not all UI elements+with an actual on-screen presence, i.e. components which can be+said to have a screen-coordinate bounding box.  Virtually all+widgets will need to have 'GI.Atk.Interfaces.Component.Component' implementations provided+for their corresponding 'GI.Atk.Objects.Object.Object' class.  In short, only UI+elements which are *not* GUI elements will omit this ATK interface.++A possible exception might be textual information with a+transparent background, in which case text glyph bounding box+information is provided by 'GI.Atk.Interfaces.Text.Text'.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces.Component+    ( ++-- * Exported types+    Component(..)                           ,+    noComponent                             ,+    IsComponent                             ,+    toComponent                             ,+++ -- * Methods+-- ** contains #method:contains#++#if ENABLE_OVERLOADING+    ComponentContainsMethodInfo             ,+#endif+    componentContains                       ,+++-- ** getAlpha #method:getAlpha#++#if ENABLE_OVERLOADING+    ComponentGetAlphaMethodInfo             ,+#endif+    componentGetAlpha                       ,+++-- ** getExtents #method:getExtents#++#if ENABLE_OVERLOADING+    ComponentGetExtentsMethodInfo           ,+#endif+    componentGetExtents                     ,+++-- ** getLayer #method:getLayer#++#if ENABLE_OVERLOADING+    ComponentGetLayerMethodInfo             ,+#endif+    componentGetLayer                       ,+++-- ** getMdiZorder #method:getMdiZorder#++#if ENABLE_OVERLOADING+    ComponentGetMdiZorderMethodInfo         ,+#endif+    componentGetMdiZorder                   ,+++-- ** getPosition #method:getPosition#++#if ENABLE_OVERLOADING+    ComponentGetPositionMethodInfo          ,+#endif+    componentGetPosition                    ,+++-- ** getSize #method:getSize#++#if ENABLE_OVERLOADING+    ComponentGetSizeMethodInfo              ,+#endif+    componentGetSize                        ,+++-- ** grabFocus #method:grabFocus#++#if ENABLE_OVERLOADING+    ComponentGrabFocusMethodInfo            ,+#endif+    componentGrabFocus                      ,+++-- ** refAccessibleAtPoint #method:refAccessibleAtPoint#++#if ENABLE_OVERLOADING+    ComponentRefAccessibleAtPointMethodInfo ,+#endif+    componentRefAccessibleAtPoint           ,+++-- ** removeFocusHandler #method:removeFocusHandler#++#if ENABLE_OVERLOADING+    ComponentRemoveFocusHandlerMethodInfo   ,+#endif+    componentRemoveFocusHandler             ,+++-- ** scrollTo #method:scrollTo#++#if ENABLE_OVERLOADING+    ComponentScrollToMethodInfo             ,+#endif+    componentScrollTo                       ,+++-- ** scrollToPoint #method:scrollToPoint#++#if ENABLE_OVERLOADING+    ComponentScrollToPointMethodInfo        ,+#endif+    componentScrollToPoint                  ,+++-- ** setExtents #method:setExtents#++#if ENABLE_OVERLOADING+    ComponentSetExtentsMethodInfo           ,+#endif+    componentSetExtents                     ,+++-- ** setPosition #method:setPosition#++#if ENABLE_OVERLOADING+    ComponentSetPositionMethodInfo          ,+#endif+    componentSetPosition                    ,+++-- ** setSize #method:setSize#++#if ENABLE_OVERLOADING+    ComponentSetSizeMethodInfo              ,+#endif+    componentSetSize                        ,+++++ -- * Signals+-- ** boundsChanged #signal:boundsChanged#++    C_ComponentBoundsChangedCallback        ,+    ComponentBoundsChangedCallback          ,+#if ENABLE_OVERLOADING+    ComponentBoundsChangedSignalInfo        ,+#endif+    afterComponentBoundsChanged             ,+    genClosure_ComponentBoundsChanged       ,+    mk_ComponentBoundsChangedCallback       ,+    noComponentBoundsChangedCallback        ,+    onComponentBoundsChanged                ,+    wrap_ComponentBoundsChangedCallback     ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums+import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object+import {-# SOURCE #-} qualified GI.Atk.Structs.Rectangle as Atk.Rectangle+import qualified GI.GObject.Objects.Object as GObject.Object++-- interface Component +-- | Memory-managed wrapper type.+newtype Component = Component (ManagedPtr Component)+-- | A convenience alias for `Nothing` :: `Maybe` `Component`.+noComponent :: Maybe Component+noComponent = Nothing++-- signal Component::bounds-changed+{- |+The \'bounds-changed\" signal is emitted when the bposition or+size of the component changes.+-}+type ComponentBoundsChangedCallback =+    Atk.Rectangle.Rectangle+    {- ^ /@arg1@/: The AtkRectangle giving the new position and size. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ComponentBoundsChangedCallback`@.+noComponentBoundsChangedCallback :: Maybe ComponentBoundsChangedCallback+noComponentBoundsChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_ComponentBoundsChangedCallback =+    Ptr () ->                               -- object+    Ptr Atk.Rectangle.Rectangle ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_ComponentBoundsChangedCallback`.+foreign import ccall "wrapper"+    mk_ComponentBoundsChangedCallback :: C_ComponentBoundsChangedCallback -> IO (FunPtr C_ComponentBoundsChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_ComponentBoundsChanged :: MonadIO m => ComponentBoundsChangedCallback -> m (GClosure C_ComponentBoundsChangedCallback)+genClosure_ComponentBoundsChanged cb = liftIO $ do+    let cb' = wrap_ComponentBoundsChangedCallback cb+    mk_ComponentBoundsChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ComponentBoundsChangedCallback` into a `C_ComponentBoundsChangedCallback`.+wrap_ComponentBoundsChangedCallback ::+    ComponentBoundsChangedCallback ->+    C_ComponentBoundsChangedCallback+wrap_ComponentBoundsChangedCallback _cb _ arg1 _ = do+    B.ManagedPtr.withTransient Atk.Rectangle.Rectangle arg1 $ \arg1' -> do+        _cb  arg1'+++{- |+Connect a signal handler for the “@bounds-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' component #boundsChanged callback+@+-}+onComponentBoundsChanged :: (IsComponent a, MonadIO m) => a -> ComponentBoundsChangedCallback -> m SignalHandlerId+onComponentBoundsChanged obj cb = liftIO $ do+    let cb' = wrap_ComponentBoundsChangedCallback cb+    cb'' <- mk_ComponentBoundsChangedCallback cb'+    connectSignalFunPtr obj "bounds-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@bounds-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' component #boundsChanged callback+@+-}+afterComponentBoundsChanged :: (IsComponent a, MonadIO m) => a -> ComponentBoundsChangedCallback -> m SignalHandlerId+afterComponentBoundsChanged obj cb = liftIO $ do+    let cb' = wrap_ComponentBoundsChangedCallback cb+    cb'' <- mk_ComponentBoundsChangedCallback cb'+    connectSignalFunPtr obj "bounds-changed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+data ComponentBoundsChangedSignalInfo+instance SignalInfo ComponentBoundsChangedSignalInfo where+    type HaskellCallbackType ComponentBoundsChangedSignalInfo = ComponentBoundsChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_ComponentBoundsChangedCallback cb+        cb'' <- mk_ComponentBoundsChangedCallback cb'+        connectSignalFunPtr obj "bounds-changed" cb'' connectMode++type instance O.SignalList Component = ComponentSignalList+type ComponentSignalList = ('[ '("boundsChanged", ComponentBoundsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "atk_component_get_type"+    c_atk_component_get_type :: IO GType++instance GObject Component where+    gobjectType = c_atk_component_get_type+    ++-- | Type class for types which can be safely cast to `Component`, for instance with `toComponent`.+class (GObject o, O.IsDescendantOf Component o) => IsComponent o+instance (GObject o, O.IsDescendantOf Component o) => IsComponent o++instance O.HasParentTypes Component+type instance O.ParentTypes Component = '[GObject.Object.Object]++-- | Cast to `Component`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toComponent :: (MonadIO m, IsComponent o) => o -> m Component+toComponent = liftIO . unsafeCastTo Component++#if ENABLE_OVERLOADING+instance O.HasAttributeList Component+type instance O.AttributeList Component = ComponentAttributeList+type ComponentAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveComponentMethod (t :: Symbol) (o :: *) :: * where+    ResolveComponentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveComponentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveComponentMethod "contains" o = ComponentContainsMethodInfo+    ResolveComponentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveComponentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveComponentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveComponentMethod "grabFocus" o = ComponentGrabFocusMethodInfo+    ResolveComponentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveComponentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveComponentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveComponentMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveComponentMethod "refAccessibleAtPoint" o = ComponentRefAccessibleAtPointMethodInfo+    ResolveComponentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveComponentMethod "removeFocusHandler" o = ComponentRemoveFocusHandlerMethodInfo+    ResolveComponentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveComponentMethod "scrollTo" o = ComponentScrollToMethodInfo+    ResolveComponentMethod "scrollToPoint" o = ComponentScrollToPointMethodInfo+    ResolveComponentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveComponentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveComponentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveComponentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveComponentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveComponentMethod "getAlpha" o = ComponentGetAlphaMethodInfo+    ResolveComponentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveComponentMethod "getExtents" o = ComponentGetExtentsMethodInfo+    ResolveComponentMethod "getLayer" o = ComponentGetLayerMethodInfo+    ResolveComponentMethod "getMdiZorder" o = ComponentGetMdiZorderMethodInfo+    ResolveComponentMethod "getPosition" o = ComponentGetPositionMethodInfo+    ResolveComponentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveComponentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveComponentMethod "getSize" o = ComponentGetSizeMethodInfo+    ResolveComponentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveComponentMethod "setExtents" o = ComponentSetExtentsMethodInfo+    ResolveComponentMethod "setPosition" o = ComponentSetPositionMethodInfo+    ResolveComponentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveComponentMethod "setSize" o = ComponentSetSizeMethodInfo+    ResolveComponentMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveComponentMethod t Component, O.MethodInfo info Component p) => OL.IsLabel t (Component -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method Component::contains+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the components top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_contains" atk_component_contains :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO CInt++{- |+Checks whether the specified point is within the extent of the /@component@/.++Toolkit implementor note: ATK provides a default implementation for+this virtual method. In general there are little reason to+re-implement it.+-}+componentContains ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: the 'GI.Atk.Interfaces.Component.Component' -}+    -> Int32+    {- ^ /@x@/: x coordinate -}+    -> Int32+    {- ^ /@y@/: y coordinate -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the components top level window -}+    -> m Bool+    {- ^ __Returns:__ 'True' or 'False' indicating whether the specified point is within+the extent of the /@component@/ or not -}+componentContains component x y coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let coordType' = (fromIntegral . fromEnum) coordType+    result <- atk_component_contains component' x y coordType'+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentContainsMethodInfo+instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentContainsMethodInfo a signature where+    overloadedMethod _ = componentContains++#endif++-- method Component::get_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_alpha" atk_component_get_alpha :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    IO CDouble++{- |+Returns the alpha value (i.e. the opacity) for this+/@component@/, on a scale from 0 (fully transparent) to 1.0+(fully opaque).++/Since: 1.12/+-}+componentGetAlpha ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> m Double+    {- ^ __Returns:__ An alpha value from 0 to 1.0, inclusive. -}+componentGetAlpha component = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    result <- atk_component_get_alpha component'+    let result' = realToFrac result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentGetAlphaMethodInfo+instance (signature ~ (m Double), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetAlphaMethodInfo a signature where+    overloadedMethod _ = componentGetAlpha++#endif++-- method Component::get_extents+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the components top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_extents" atk_component_get_extents :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Ptr Int32 ->                            -- x : TBasicType TInt+    Ptr Int32 ->                            -- y : TBasicType TInt+    Ptr Int32 ->                            -- width : TBasicType TInt+    Ptr Int32 ->                            -- height : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO ()++{- |+Gets the rectangle which gives the extent of the /@component@/.+-}+componentGetExtents ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the components top level window -}+    -> m ((Int32, Int32, Int32, Int32))+componentGetExtents component coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    x <- allocMem :: IO (Ptr Int32)+    y <- allocMem :: IO (Ptr Int32)+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    let coordType' = (fromIntegral . fromEnum) coordType+    atk_component_get_extents component' x y width height coordType'+    x' <- peek x+    y' <- peek y+    width' <- peek width+    height' <- peek height+    touchManagedPtr component+    freeMem x+    freeMem y+    freeMem width+    freeMem height+    return (x', y', width', height')++#if ENABLE_OVERLOADING+data ComponentGetExtentsMethodInfo+instance (signature ~ (Atk.Enums.CoordType -> m ((Int32, Int32, Int32, Int32))), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetExtentsMethodInfo a signature where+    overloadedMethod _ = componentGetExtents++#endif++-- method Component::get_layer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Layer"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_layer" atk_component_get_layer :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    IO CUInt++{- |+Gets the layer of the component.+-}+componentGetLayer ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> m Atk.Enums.Layer+    {- ^ __Returns:__ an 'GI.Atk.Enums.Layer' which is the layer of the component -}+componentGetLayer component = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    result <- atk_component_get_layer component'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentGetLayerMethodInfo+instance (signature ~ (m Atk.Enums.Layer), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetLayerMethodInfo a signature where+    overloadedMethod _ = componentGetLayer++#endif++-- method Component::get_mdi_zorder+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_mdi_zorder" atk_component_get_mdi_zorder :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    IO Int32++{- |+Gets the zorder of the component. The value G_MININT will be returned+if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.+-}+componentGetMdiZorder ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> m Int32+    {- ^ __Returns:__ a gint which is the zorder of the component, i.e. the depth at+which the component is shown in relation to other components in the same+container. -}+componentGetMdiZorder component = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    result <- atk_component_get_mdi_zorder component'+    touchManagedPtr component+    return result++#if ENABLE_OVERLOADING+data ComponentGetMdiZorderMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetMdiZorderMethodInfo a signature where+    overloadedMethod _ = componentGetMdiZorder++#endif++-- method Component::get_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put x coordinate position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put y coordinate position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the components top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_position" atk_component_get_position :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Ptr Int32 ->                            -- x : TBasicType TInt+    Ptr Int32 ->                            -- y : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO ()++{-# DEPRECATED componentGetPosition ["Since 2.12. Use 'GI.Atk.Interfaces.Component.componentGetExtents' instead."] #-}+{- |+Gets the position of /@component@/ in the form of+a point specifying /@component@/\'s top-left corner.+-}+componentGetPosition ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the components top level window -}+    -> m ((Int32, Int32))+componentGetPosition component coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    x <- allocMem :: IO (Ptr Int32)+    y <- allocMem :: IO (Ptr Int32)+    let coordType' = (fromIntegral . fromEnum) coordType+    atk_component_get_position component' x y coordType'+    x' <- peek x+    y' <- peek y+    touchManagedPtr component+    freeMem x+    freeMem y+    return (x', y')++#if ENABLE_OVERLOADING+data ComponentGetPositionMethodInfo+instance (signature ~ (Atk.Enums.CoordType -> m ((Int32, Int32))), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetPositionMethodInfo a signature where+    overloadedMethod _ = componentGetPosition++#endif++-- method Component::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put width of @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of #gint to put height of @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_get_size" atk_component_get_size :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Ptr Int32 ->                            -- width : TBasicType TInt+    Ptr Int32 ->                            -- height : TBasicType TInt+    IO ()++{-# DEPRECATED componentGetSize ["Since 2.12. Use 'GI.Atk.Interfaces.Component.componentGetExtents' instead."] #-}+{- |+Gets the size of the /@component@/ in terms of width and height.+-}+componentGetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> m ((Int32, Int32))+componentGetSize component = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    atk_component_get_size component' width height+    width' <- peek width+    height' <- peek height+    touchManagedPtr component+    freeMem width+    freeMem height+    return (width', height')++#if ENABLE_OVERLOADING+data ComponentGetSizeMethodInfo+instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsComponent a) => O.MethodInfo ComponentGetSizeMethodInfo a signature where+    overloadedMethod _ = componentGetSize++#endif++-- method Component::grab_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_grab_focus" atk_component_grab_focus :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    IO CInt++{- |+Grabs focus for this /@component@/.+-}+componentGrabFocus ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if successful, 'False' otherwise. -}+componentGrabFocus component = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    result <- atk_component_grab_focus component'+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentGrabFocusMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentGrabFocusMethodInfo a signature where+    overloadedMethod _ = componentGrabFocus++#endif++-- method Component::ref_accessible_at_point+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the components top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_ref_accessible_at_point" atk_component_ref_accessible_at_point :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO (Ptr Atk.Object.Object)++{- |+Gets a reference to the accessible child, if one exists, at the+coordinate point specified by /@x@/ and /@y@/.+-}+componentRefAccessibleAtPoint ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: the 'GI.Atk.Interfaces.Component.Component' -}+    -> Int32+    {- ^ /@x@/: x coordinate -}+    -> Int32+    {- ^ /@y@/: y coordinate -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the components top level window -}+    -> m (Maybe Atk.Object.Object)+    {- ^ __Returns:__ a reference to the accessible+child, if one exists -}+componentRefAccessibleAtPoint component x y coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let coordType' = (fromIntegral . fromEnum) coordType+    result <- atk_component_ref_accessible_at_point component' x y coordType'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Atk.Object.Object) result'+        return result''+    touchManagedPtr component+    return maybeResult++#if ENABLE_OVERLOADING+data ComponentRefAccessibleAtPointMethodInfo+instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> m (Maybe Atk.Object.Object)), MonadIO m, IsComponent a) => O.MethodInfo ComponentRefAccessibleAtPointMethodInfo a signature where+    overloadedMethod _ = componentRefAccessibleAtPoint++#endif++-- method Component::remove_focus_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkComponent to remove the focus handler from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the handler id of the focus handler to be removed\nfrom @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_remove_focus_handler" atk_component_remove_focus_handler :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Word32 ->                               -- handler_id : TBasicType TUInt+    IO ()++{-# DEPRECATED componentRemoveFocusHandler ["(Since version 2.9.4)","If you need to track when an object gains or","lose the focus, use the 'GI.Atk.Objects.Object.Object'::@/state-change/@ \\\"focused\\\" notification instead."] #-}+{- |+Remove the handler specified by /@handlerId@/ from the list of+functions to be executed when this object receives focus events+(in or out).+-}+componentRemoveFocusHandler ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: the 'GI.Atk.Interfaces.Component.Component' to remove the focus handler from -}+    -> Word32+    {- ^ /@handlerId@/: the handler id of the focus handler to be removed+from /@component@/ -}+    -> m ()+componentRemoveFocusHandler component handlerId = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    atk_component_remove_focus_handler component' handlerId+    touchManagedPtr component+    return ()++#if ENABLE_OVERLOADING+data ComponentRemoveFocusHandlerMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsComponent a) => O.MethodInfo ComponentRemoveFocusHandlerMethodInfo a signature where+    overloadedMethod _ = componentRemoveFocusHandler++#endif++-- method Component::scroll_to+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Atk", name = "ScrollType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specify where the object should be made visible.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_scroll_to" atk_component_scroll_to :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    CUInt ->                                -- type : TInterface (Name {namespace = "Atk", name = "ScrollType"})+    IO CInt++{- |+Makes /@component@/ visible on the screen by scrolling all necessary parents.++Contrary to atk_component_set_position, this does not actually move+/@component@/ in its parent, this only makes the parents scroll so that the+object shows up on the screen, given its current position within the parents.++/Since: 2.30/+-}+componentScrollTo ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Atk.Enums.ScrollType+    {- ^ /@type@/: specify where the object should be made visible. -}+    -> m Bool+    {- ^ __Returns:__ whether scrolling was successful. -}+componentScrollTo component type_ = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let type_' = (fromIntegral . fromEnum) type_+    result <- atk_component_scroll_to component' type_'+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentScrollToMethodInfo+instance (signature ~ (Atk.Enums.ScrollType -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentScrollToMethodInfo a signature where+    overloadedMethod _ = componentScrollTo++#endif++-- method Component::scroll_to_point+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "coords", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specify whether coordinates are relative to the screen or to the\nparent object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x-position where to scroll to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y-position where to scroll to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_scroll_to_point" atk_component_scroll_to_point :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    CUInt ->                                -- coords : TInterface (Name {namespace = "Atk", name = "CoordType"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    IO CInt++{- |+Makes an object visible on the screen at a given position by scrolling all+necessary parents.++/Since: 2.30/+-}+componentScrollToPoint ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Atk.Enums.CoordType+    {- ^ /@coords@/: specify whether coordinates are relative to the screen or to the+parent object. -}+    -> Int32+    {- ^ /@x@/: x-position where to scroll to -}+    -> Int32+    {- ^ /@y@/: y-position where to scroll to -}+    -> m Bool+    {- ^ __Returns:__ whether scrolling was successful. -}+componentScrollToPoint component coords x y = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let coords' = (fromIntegral . fromEnum) coords+    result <- atk_component_scroll_to_point component' coords' x y+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentScrollToPointMethodInfo+instance (signature ~ (Atk.Enums.CoordType -> Int32 -> Int32 -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentScrollToPointMethodInfo a signature where+    overloadedMethod _ = componentScrollToPoint++#endif++-- method Component::set_extents+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width to set for @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height to set for @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the components top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_set_extents" atk_component_set_extents :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO CInt++{- |+Sets the extents of /@component@/.+-}+componentSetExtents ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Int32+    {- ^ /@x@/: x coordinate -}+    -> Int32+    {- ^ /@y@/: y coordinate -}+    -> Int32+    {- ^ /@width@/: width to set for /@component@/ -}+    -> Int32+    {- ^ /@height@/: height to set for /@component@/ -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the components top level window -}+    -> m Bool+    {- ^ __Returns:__ 'True' or 'False' whether the extents were set or not -}+componentSetExtents component x y width height coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let coordType' = (fromIntegral . fromEnum) coordType+    result <- atk_component_set_extents component' x y width height coordType'+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentSetExtentsMethodInfo+instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> Atk.Enums.CoordType -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentSetExtentsMethodInfo a signature where+    overloadedMethod _ = componentSetExtents++#endif++-- method Component::set_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "coord_type", argType = TInterface (Name {namespace = "Atk", name = "CoordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies whether the coordinates are relative to the screen\nor to the component's top level window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_set_position" atk_component_set_position :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    CUInt ->                                -- coord_type : TInterface (Name {namespace = "Atk", name = "CoordType"})+    IO CInt++{- |+Sets the position of /@component@/.++Contrary to atk_component_scroll_to, this does not trigger any scrolling,+this just moves /@component@/ in its parent.+-}+componentSetPosition ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Int32+    {- ^ /@x@/: x coordinate -}+    -> Int32+    {- ^ /@y@/: y coordinate -}+    -> Atk.Enums.CoordType+    {- ^ /@coordType@/: specifies whether the coordinates are relative to the screen+or to the component\'s top level window -}+    -> m Bool+    {- ^ __Returns:__ 'True' or 'False' whether or not the position was set or not -}+componentSetPosition component x y coordType = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    let coordType' = (fromIntegral . fromEnum) coordType+    result <- atk_component_set_position component' x y coordType'+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentSetPositionMethodInfo+instance (signature ~ (Int32 -> Int32 -> Atk.Enums.CoordType -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentSetPositionMethodInfo a signature where+    overloadedMethod _ = componentSetPosition++#endif++-- method Component::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "component", argType = TInterface (Name {namespace = "Atk", name = "Component"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkComponent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width to set for @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height to set for @component", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_component_set_size" atk_component_set_size :: +    Ptr Component ->                        -- component : TInterface (Name {namespace = "Atk", name = "Component"})+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    IO CInt++{- |+Set the size of the /@component@/ in terms of width and height.+-}+componentSetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsComponent a) =>+    a+    {- ^ /@component@/: an 'GI.Atk.Interfaces.Component.Component' -}+    -> Int32+    {- ^ /@width@/: width to set for /@component@/ -}+    -> Int32+    {- ^ /@height@/: height to set for /@component@/ -}+    -> m Bool+    {- ^ __Returns:__ 'True' or 'False' whether the size was set or not -}+componentSetSize component width height = liftIO $ do+    component' <- unsafeManagedPtrCastPtr component+    result <- atk_component_set_size component' width height+    let result' = (/= 0) result+    touchManagedPtr component+    return result'++#if ENABLE_OVERLOADING+data ComponentSetSizeMethodInfo+instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsComponent a) => O.MethodInfo ComponentSetSizeMethodInfo a signature where+    overloadedMethod _ = componentSetSize++#endif++

@@ -0,0 +1,77 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Interfaces.Component where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Component = Component (ManagedPtr Component)+#if ENABLE_OVERLOADING+data ComponentBoundsChangedSignalInfo+#endif+instance GObject Component where+class (GObject o, O.IsDescendantOf Component o) => IsComponent o+instance (GObject o, O.IsDescendantOf Component o) => IsComponent o+instance O.HasParentTypes Component+#if ENABLE_OVERLOADING+data ComponentContainsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetAlphaMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetExtentsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetLayerMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetMdiZorderMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetPositionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGetSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentGrabFocusMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentRefAccessibleAtPointMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentRemoveFocusHandlerMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentScrollToMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentScrollToPointMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentSetExtentsMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentSetPositionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ComponentSetSizeMethodInfo+#endif

@@ -0,0 +1,911 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++The AtkDocument interface should be supported by any object whose+content is a representation or view of a document.  The AtkDocument+interface should appear on the toplevel container for the document+content; however AtkDocument instances may be nested (i.e. an+AtkDocument may be a descendant of another AtkDocument) in those+cases where one document contains \"embedded content\" which can+reasonably be considered a document in its own right.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces.Document+    ( ++-- * Exported types+    Document(..)                            ,+    noDocument                              ,+    IsDocument                              ,+    toDocument                              ,+++ -- * Methods+-- ** getAttributeValue #method:getAttributeValue#++#if ENABLE_OVERLOADING+    DocumentGetAttributeValueMethodInfo     ,+#endif+    documentGetAttributeValue               ,+++-- ** getAttributes #method:getAttributes#++#if ENABLE_OVERLOADING+    DocumentGetAttributesMethodInfo         ,+#endif+    documentGetAttributes                   ,+++-- ** getCurrentPageNumber #method:getCurrentPageNumber#++#if ENABLE_OVERLOADING+    DocumentGetCurrentPageNumberMethodInfo  ,+#endif+    documentGetCurrentPageNumber            ,+++-- ** getDocument #method:getDocument#++#if ENABLE_OVERLOADING+    DocumentGetDocumentMethodInfo           ,+#endif+    documentGetDocument                     ,+++-- ** getDocumentType #method:getDocumentType#++#if ENABLE_OVERLOADING+    DocumentGetDocumentTypeMethodInfo       ,+#endif+    documentGetDocumentType                 ,+++-- ** getLocale #method:getLocale#++#if ENABLE_OVERLOADING+    DocumentGetLocaleMethodInfo             ,+#endif+    documentGetLocale                       ,+++-- ** getPageCount #method:getPageCount#++#if ENABLE_OVERLOADING+    DocumentGetPageCountMethodInfo          ,+#endif+    documentGetPageCount                    ,+++-- ** setAttributeValue #method:setAttributeValue#++#if ENABLE_OVERLOADING+    DocumentSetAttributeValueMethodInfo     ,+#endif+    documentSetAttributeValue               ,+++++ -- * Signals+-- ** loadComplete #signal:loadComplete#++    C_DocumentLoadCompleteCallback          ,+    DocumentLoadCompleteCallback            ,+#if ENABLE_OVERLOADING+    DocumentLoadCompleteSignalInfo          ,+#endif+    afterDocumentLoadComplete               ,+    genClosure_DocumentLoadComplete         ,+    mk_DocumentLoadCompleteCallback         ,+    noDocumentLoadCompleteCallback          ,+    onDocumentLoadComplete                  ,+    wrap_DocumentLoadCompleteCallback       ,+++-- ** loadStopped #signal:loadStopped#++    C_DocumentLoadStoppedCallback           ,+    DocumentLoadStoppedCallback             ,+#if ENABLE_OVERLOADING+    DocumentLoadStoppedSignalInfo           ,+#endif+    afterDocumentLoadStopped                ,+    genClosure_DocumentLoadStopped          ,+    mk_DocumentLoadStoppedCallback          ,+    noDocumentLoadStoppedCallback           ,+    onDocumentLoadStopped                   ,+    wrap_DocumentLoadStoppedCallback        ,+++-- ** pageChanged #signal:pageChanged#++    C_DocumentPageChangedCallback           ,+    DocumentPageChangedCallback             ,+#if ENABLE_OVERLOADING+    DocumentPageChangedSignalInfo           ,+#endif+    afterDocumentPageChanged                ,+    genClosure_DocumentPageChanged          ,+    mk_DocumentPageChangedCallback          ,+    noDocumentPageChangedCallback           ,+    onDocumentPageChanged                   ,+    wrap_DocumentPageChangedCallback        ,+++-- ** reload #signal:reload#++    C_DocumentReloadCallback                ,+    DocumentReloadCallback                  ,+#if ENABLE_OVERLOADING+    DocumentReloadSignalInfo                ,+#endif+    afterDocumentReload                     ,+    genClosure_DocumentReload               ,+    mk_DocumentReloadCallback               ,+    noDocumentReloadCallback                ,+    onDocumentReload                        ,+    wrap_DocumentReloadCallback             ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GObject.Objects.Object as GObject.Object++-- interface Document +-- | Memory-managed wrapper type.+newtype Document = Document (ManagedPtr Document)+-- | A convenience alias for `Nothing` :: `Maybe` `Document`.+noDocument :: Maybe Document+noDocument = Nothing++-- signal Document::load-complete+{- |+The \'load-complete\' signal is emitted when a pending load of+a static document has completed.  This signal is to be+expected by ATK clients if and when AtkDocument implementors+expose ATK_STATE_BUSY.  If the state of an AtkObject which+implements AtkDocument does not include ATK_STATE_BUSY, it+should be safe for clients to assume that the AtkDocument\'s+static contents are fully loaded into the container.+(Dynamic document contents should be exposed via other+signals.)+-}+type DocumentLoadCompleteCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentLoadCompleteCallback`@.+noDocumentLoadCompleteCallback :: Maybe DocumentLoadCompleteCallback+noDocumentLoadCompleteCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DocumentLoadCompleteCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DocumentLoadCompleteCallback`.+foreign import ccall "wrapper"+    mk_DocumentLoadCompleteCallback :: C_DocumentLoadCompleteCallback -> IO (FunPtr C_DocumentLoadCompleteCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DocumentLoadComplete :: MonadIO m => DocumentLoadCompleteCallback -> m (GClosure C_DocumentLoadCompleteCallback)+genClosure_DocumentLoadComplete cb = liftIO $ do+    let cb' = wrap_DocumentLoadCompleteCallback cb+    mk_DocumentLoadCompleteCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DocumentLoadCompleteCallback` into a `C_DocumentLoadCompleteCallback`.+wrap_DocumentLoadCompleteCallback ::+    DocumentLoadCompleteCallback ->+    C_DocumentLoadCompleteCallback+wrap_DocumentLoadCompleteCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@load-complete@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' document #loadComplete callback+@+-}+onDocumentLoadComplete :: (IsDocument a, MonadIO m) => a -> DocumentLoadCompleteCallback -> m SignalHandlerId+onDocumentLoadComplete obj cb = liftIO $ do+    let cb' = wrap_DocumentLoadCompleteCallback cb+    cb'' <- mk_DocumentLoadCompleteCallback cb'+    connectSignalFunPtr obj "load-complete" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@load-complete@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' document #loadComplete callback+@+-}+afterDocumentLoadComplete :: (IsDocument a, MonadIO m) => a -> DocumentLoadCompleteCallback -> m SignalHandlerId+afterDocumentLoadComplete obj cb = liftIO $ do+    let cb' = wrap_DocumentLoadCompleteCallback cb+    cb'' <- mk_DocumentLoadCompleteCallback cb'+    connectSignalFunPtr obj "load-complete" cb'' SignalConnectAfter+++-- signal Document::load-stopped+{- |+The \'load-stopped\' signal is emitted when a pending load of+document contents is cancelled, paused, or otherwise+interrupted by the user or application logic.  It should not+however be emitted while waiting for a resource (for instance+while blocking on a file or network read) unless a+user-significant timeout has occurred.+-}+type DocumentLoadStoppedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentLoadStoppedCallback`@.+noDocumentLoadStoppedCallback :: Maybe DocumentLoadStoppedCallback+noDocumentLoadStoppedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DocumentLoadStoppedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DocumentLoadStoppedCallback`.+foreign import ccall "wrapper"+    mk_DocumentLoadStoppedCallback :: C_DocumentLoadStoppedCallback -> IO (FunPtr C_DocumentLoadStoppedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DocumentLoadStopped :: MonadIO m => DocumentLoadStoppedCallback -> m (GClosure C_DocumentLoadStoppedCallback)+genClosure_DocumentLoadStopped cb = liftIO $ do+    let cb' = wrap_DocumentLoadStoppedCallback cb+    mk_DocumentLoadStoppedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DocumentLoadStoppedCallback` into a `C_DocumentLoadStoppedCallback`.+wrap_DocumentLoadStoppedCallback ::+    DocumentLoadStoppedCallback ->+    C_DocumentLoadStoppedCallback+wrap_DocumentLoadStoppedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@load-stopped@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' document #loadStopped callback+@+-}+onDocumentLoadStopped :: (IsDocument a, MonadIO m) => a -> DocumentLoadStoppedCallback -> m SignalHandlerId+onDocumentLoadStopped obj cb = liftIO $ do+    let cb' = wrap_DocumentLoadStoppedCallback cb+    cb'' <- mk_DocumentLoadStoppedCallback cb'+    connectSignalFunPtr obj "load-stopped" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@load-stopped@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' document #loadStopped callback+@+-}+afterDocumentLoadStopped :: (IsDocument a, MonadIO m) => a -> DocumentLoadStoppedCallback -> m SignalHandlerId+afterDocumentLoadStopped obj cb = liftIO $ do+    let cb' = wrap_DocumentLoadStoppedCallback cb+    cb'' <- mk_DocumentLoadStoppedCallback cb'+    connectSignalFunPtr obj "load-stopped" cb'' SignalConnectAfter+++-- signal Document::page-changed+{- |+The \'page-changed\' signal is emitted when the current page of+a document changes, e.g. pressing page up\/down in a document+viewer.++/Since: 2.12/+-}+type DocumentPageChangedCallback =+    Int32+    {- ^ /@pageNumber@/: the new page number. If this value is unknown+or not applicable, -1 should be provided. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentPageChangedCallback`@.+noDocumentPageChangedCallback :: Maybe DocumentPageChangedCallback+noDocumentPageChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DocumentPageChangedCallback =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DocumentPageChangedCallback`.+foreign import ccall "wrapper"+    mk_DocumentPageChangedCallback :: C_DocumentPageChangedCallback -> IO (FunPtr C_DocumentPageChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DocumentPageChanged :: MonadIO m => DocumentPageChangedCallback -> m (GClosure C_DocumentPageChangedCallback)+genClosure_DocumentPageChanged cb = liftIO $ do+    let cb' = wrap_DocumentPageChangedCallback cb+    mk_DocumentPageChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DocumentPageChangedCallback` into a `C_DocumentPageChangedCallback`.+wrap_DocumentPageChangedCallback ::+    DocumentPageChangedCallback ->+    C_DocumentPageChangedCallback+wrap_DocumentPageChangedCallback _cb _ pageNumber _ = do+    _cb  pageNumber+++{- |+Connect a signal handler for the “@page-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' document #pageChanged callback+@+-}+onDocumentPageChanged :: (IsDocument a, MonadIO m) => a -> DocumentPageChangedCallback -> m SignalHandlerId+onDocumentPageChanged obj cb = liftIO $ do+    let cb' = wrap_DocumentPageChangedCallback cb+    cb'' <- mk_DocumentPageChangedCallback cb'+    connectSignalFunPtr obj "page-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@page-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' document #pageChanged callback+@+-}+afterDocumentPageChanged :: (IsDocument a, MonadIO m) => a -> DocumentPageChangedCallback -> m SignalHandlerId+afterDocumentPageChanged obj cb = liftIO $ do+    let cb' = wrap_DocumentPageChangedCallback cb+    cb'' <- mk_DocumentPageChangedCallback cb'+    connectSignalFunPtr obj "page-changed" cb'' SignalConnectAfter+++-- signal Document::reload+{- |+The \'reload\' signal is emitted when the contents of a+document is refreshed from its source.  Once \'reload\' has+been emitted, a matching \'load-complete\' or \'load-stopped\'+signal should follow, which clients may await before+interrogating ATK for the latest document content.+-}+type DocumentReloadCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `DocumentReloadCallback`@.+noDocumentReloadCallback :: Maybe DocumentReloadCallback+noDocumentReloadCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_DocumentReloadCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_DocumentReloadCallback`.+foreign import ccall "wrapper"+    mk_DocumentReloadCallback :: C_DocumentReloadCallback -> IO (FunPtr C_DocumentReloadCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_DocumentReload :: MonadIO m => DocumentReloadCallback -> m (GClosure C_DocumentReloadCallback)+genClosure_DocumentReload cb = liftIO $ do+    let cb' = wrap_DocumentReloadCallback cb+    mk_DocumentReloadCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `DocumentReloadCallback` into a `C_DocumentReloadCallback`.+wrap_DocumentReloadCallback ::+    DocumentReloadCallback ->+    C_DocumentReloadCallback+wrap_DocumentReloadCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@reload@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' document #reload callback+@+-}+onDocumentReload :: (IsDocument a, MonadIO m) => a -> DocumentReloadCallback -> m SignalHandlerId+onDocumentReload obj cb = liftIO $ do+    let cb' = wrap_DocumentReloadCallback cb+    cb'' <- mk_DocumentReloadCallback cb'+    connectSignalFunPtr obj "reload" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@reload@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' document #reload callback+@+-}+afterDocumentReload :: (IsDocument a, MonadIO m) => a -> DocumentReloadCallback -> m SignalHandlerId+afterDocumentReload obj cb = liftIO $ do+    let cb' = wrap_DocumentReloadCallback cb+    cb'' <- mk_DocumentReloadCallback cb'+    connectSignalFunPtr obj "reload" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+data DocumentLoadCompleteSignalInfo+instance SignalInfo DocumentLoadCompleteSignalInfo where+    type HaskellCallbackType DocumentLoadCompleteSignalInfo = DocumentLoadCompleteCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DocumentLoadCompleteCallback cb+        cb'' <- mk_DocumentLoadCompleteCallback cb'+        connectSignalFunPtr obj "load-complete" cb'' connectMode++data DocumentLoadStoppedSignalInfo+instance SignalInfo DocumentLoadStoppedSignalInfo where+    type HaskellCallbackType DocumentLoadStoppedSignalInfo = DocumentLoadStoppedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DocumentLoadStoppedCallback cb+        cb'' <- mk_DocumentLoadStoppedCallback cb'+        connectSignalFunPtr obj "load-stopped" cb'' connectMode++data DocumentPageChangedSignalInfo+instance SignalInfo DocumentPageChangedSignalInfo where+    type HaskellCallbackType DocumentPageChangedSignalInfo = DocumentPageChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DocumentPageChangedCallback cb+        cb'' <- mk_DocumentPageChangedCallback cb'+        connectSignalFunPtr obj "page-changed" cb'' connectMode++data DocumentReloadSignalInfo+instance SignalInfo DocumentReloadSignalInfo where+    type HaskellCallbackType DocumentReloadSignalInfo = DocumentReloadCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_DocumentReloadCallback cb+        cb'' <- mk_DocumentReloadCallback cb'+        connectSignalFunPtr obj "reload" cb'' connectMode++type instance O.SignalList Document = DocumentSignalList+type DocumentSignalList = ('[ '("loadComplete", DocumentLoadCompleteSignalInfo), '("loadStopped", DocumentLoadStoppedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageChanged", DocumentPageChangedSignalInfo), '("reload", DocumentReloadSignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "atk_document_get_type"+    c_atk_document_get_type :: IO GType++instance GObject Document where+    gobjectType = c_atk_document_get_type+    ++-- | Type class for types which can be safely cast to `Document`, for instance with `toDocument`.+class (GObject o, O.IsDescendantOf Document o) => IsDocument o+instance (GObject o, O.IsDescendantOf Document o) => IsDocument o++instance O.HasParentTypes Document+type instance O.ParentTypes Document = '[GObject.Object.Object]++-- | Cast to `Document`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toDocument :: (MonadIO m, IsDocument o) => o -> m Document+toDocument = liftIO . unsafeCastTo Document++#if ENABLE_OVERLOADING+instance O.HasAttributeList Document+type instance O.AttributeList Document = DocumentAttributeList+type DocumentAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveDocumentMethod (t :: Symbol) (o :: *) :: * where+    ResolveDocumentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveDocumentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveDocumentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveDocumentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveDocumentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveDocumentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveDocumentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveDocumentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveDocumentMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveDocumentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveDocumentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveDocumentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveDocumentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveDocumentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveDocumentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveDocumentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveDocumentMethod "getAttributeValue" o = DocumentGetAttributeValueMethodInfo+    ResolveDocumentMethod "getAttributes" o = DocumentGetAttributesMethodInfo+    ResolveDocumentMethod "getCurrentPageNumber" o = DocumentGetCurrentPageNumberMethodInfo+    ResolveDocumentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveDocumentMethod "getDocument" o = DocumentGetDocumentMethodInfo+    ResolveDocumentMethod "getDocumentType" o = DocumentGetDocumentTypeMethodInfo+    ResolveDocumentMethod "getLocale" o = DocumentGetLocaleMethodInfo+    ResolveDocumentMethod "getPageCount" o = DocumentGetPageCountMethodInfo+    ResolveDocumentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveDocumentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveDocumentMethod "setAttributeValue" o = DocumentSetAttributeValueMethodInfo+    ResolveDocumentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveDocumentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveDocumentMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveDocumentMethod t Document, O.MethodInfo info Document p) => OL.IsLabel t (Document -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method Document::get_attribute_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string representing the name of the attribute\n           whose value is being queried.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_attribute_value" atk_document_get_attribute_value :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    CString ->                              -- attribute_name : TBasicType TUTF8+    IO CString++{- |+/No description available in the introspection data./++/Since: 1.12/+-}+documentGetAttributeValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> T.Text+    {- ^ /@attributeName@/: a character string representing the name of the attribute+           whose value is being queried. -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a string value associated with the named+   attribute for this document, or NULL if a value for+   @/attribute_name/@ has not been specified for this document. -}+documentGetAttributeValue document attributeName = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    attributeName' <- textToCString attributeName+    result <- atk_document_get_attribute_value document' attributeName'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr document+    freeMem attributeName'+    return maybeResult++#if ENABLE_OVERLOADING+data DocumentGetAttributeValueMethodInfo+instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAttributeValueMethodInfo a signature where+    overloadedMethod _ = documentGetAttributeValue++#endif++-- method Document::get_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGSList (TBasicType TPtr))+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_attributes" atk_document_get_attributes :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO (Ptr (GSList (Ptr ())))++{- |+Gets an AtkAttributeSet which describes document-wide+         attributes as name-value pairs.++/Since: 1.12/+-}+documentGetAttributes ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> m ([Ptr ()])+    {- ^ __Returns:__ An AtkAttributeSet containing the explicitly+         set name-value-pair attributes associated with this document+         as a whole. -}+documentGetAttributes document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_attributes document'+    result' <- unpackGSList result+    touchManagedPtr document+    return result'++#if ENABLE_OVERLOADING+data DocumentGetAttributesMethodInfo+instance (signature ~ (m ([Ptr ()])), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAttributesMethodInfo a signature where+    overloadedMethod _ = documentGetAttributes++#endif++-- method Document::get_current_page_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_current_page_number" atk_document_get_current_page_number :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO Int32++{- |+/No description available in the introspection data./++/Since: 2.12/+-}+documentGetCurrentPageNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: the 'GI.Atk.Interfaces.Document.Document' -}+    -> m Int32+    {- ^ __Returns:__ current page number inside /@document@/. -1 if not+implemented, not know by the implementor or irrelevant. -}+documentGetCurrentPageNumber document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_current_page_number document'+    touchManagedPtr document+    return result++#if ENABLE_OVERLOADING+data DocumentGetCurrentPageNumberMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetCurrentPageNumberMethodInfo a signature where+    overloadedMethod _ = documentGetCurrentPageNumber++#endif++-- method Document::get_document+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TPtr)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_document" atk_document_get_document :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO (Ptr ())++{-# DEPRECATED documentGetDocument ["Since 2.12. /@document@/ is already a representation of","the document. Use it directly, or one of its children, as an","instance of the DOM."] #-}+{- |+Gets a @/gpointer/@ that points to an instance of the DOM.  It is+up to the caller to check atk_document_get_type to determine+how to cast this pointer.+-}+documentGetDocument ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> m (Ptr ())+    {- ^ __Returns:__ a @/gpointer/@ that points to an instance of the DOM. -}+documentGetDocument document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_document document'+    touchManagedPtr document+    return result++#if ENABLE_OVERLOADING+data DocumentGetDocumentMethodInfo+instance (signature ~ (m (Ptr ())), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetDocumentMethodInfo a signature where+    overloadedMethod _ = documentGetDocument++#endif++-- method Document::get_document_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_document_type" atk_document_get_document_type :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO CString++{-# DEPRECATED documentGetDocumentType ["Since 2.12. Please use 'GI.Atk.Interfaces.Document.documentGetAttributes' to","ask for the document type if it applies."] #-}+{- |+Gets a string indicating the document type.+-}+documentGetDocumentType ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> m T.Text+    {- ^ __Returns:__ a string indicating the document type -}+documentGetDocumentType document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_document_type document'+    checkUnexpectedReturnNULL "documentGetDocumentType" result+    result' <- cstringToText result+    touchManagedPtr document+    return result'++#if ENABLE_OVERLOADING+data DocumentGetDocumentTypeMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetDocumentTypeMethodInfo a signature where+    overloadedMethod _ = documentGetDocumentType++#endif++-- method Document::get_locale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_locale" atk_document_get_locale :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO CString++{-# DEPRECATED documentGetLocale ["(Since version 2.7.90)","Please use 'GI.Atk.Objects.Object.objectGetObjectLocale' instead."] #-}+{- |+Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale+         of the content of this document instance.  Individual+         text substrings or images within this document may have+         a different locale, see atk_text_get_attributes and+         atk_image_get_image_locale.+-}+documentGetLocale ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> m T.Text+    {- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES+         locale of the document content as a whole, or NULL if+         the document content does not specify a locale. -}+documentGetLocale document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_locale document'+    checkUnexpectedReturnNULL "documentGetLocale" result+    result' <- cstringToText result+    touchManagedPtr document+    return result'++#if ENABLE_OVERLOADING+data DocumentGetLocaleMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetLocaleMethodInfo a signature where+    overloadedMethod _ = documentGetLocale++#endif++-- method Document::get_page_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #AtkDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_get_page_count" atk_document_get_page_count :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    IO Int32++{- |+/No description available in the introspection data./++/Since: 2.12/+-}+documentGetPageCount ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: the 'GI.Atk.Interfaces.Document.Document' -}+    -> m Int32+    {- ^ __Returns:__ total page count of /@document@/. -1 if not implemented, not+know by the implementor or irrelevant. -}+documentGetPageCount document = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    result <- atk_document_get_page_count document'+    touchManagedPtr document+    return result++#if ENABLE_OVERLOADING+data DocumentGetPageCountMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageCountMethodInfo a signature where+    overloadedMethod _ = documentGetPageCount++#endif++-- method Document::set_attribute_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Atk", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkDocumentIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character string representing the name of the attribute\n           whose value is being set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attribute_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string value to be associated with #attribute_name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_document_set_attribute_value" atk_document_set_attribute_value :: +    Ptr Document ->                         -- document : TInterface (Name {namespace = "Atk", name = "Document"})+    CString ->                              -- attribute_name : TBasicType TUTF8+    CString ->                              -- attribute_value : TBasicType TUTF8+    IO CInt++{- |+/No description available in the introspection data./++/Since: 1.12/+-}+documentSetAttributeValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsDocument a) =>+    a+    {- ^ /@document@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkDocumentIface -}+    -> T.Text+    {- ^ /@attributeName@/: a character string representing the name of the attribute+           whose value is being set. -}+    -> T.Text+    {- ^ /@attributeValue@/: a string value to be associated with @/attribute_name/@. -}+    -> m Bool+    {- ^ __Returns:__ TRUE if @/value/@ is successfully associated with @/attribute_name/@+         for this document, FALSE otherwise (e.g. if the document does not+         allow the attribute to be modified). -}+documentSetAttributeValue document attributeName attributeValue = liftIO $ do+    document' <- unsafeManagedPtrCastPtr document+    attributeName' <- textToCString attributeName+    attributeValue' <- textToCString attributeValue+    result <- atk_document_set_attribute_value document' attributeName' attributeValue'+    let result' = (/= 0) result+    touchManagedPtr document+    freeMem attributeName'+    freeMem attributeValue'+    return result'++#if ENABLE_OVERLOADING+data DocumentSetAttributeValueMethodInfo+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetAttributeValueMethodInfo a signature where+    overloadedMethod _ = documentSetAttributeValue++#endif++

@@ -0,0 +1,65 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Interfaces.Document where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Document = Document (ManagedPtr Document)+#if ENABLE_OVERLOADING+data DocumentLoadCompleteSignalInfo+#endif+#if ENABLE_OVERLOADING+data DocumentLoadStoppedSignalInfo+#endif+#if ENABLE_OVERLOADING+data DocumentPageChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data DocumentReloadSignalInfo+#endif+instance GObject Document where+class (GObject o, O.IsDescendantOf Document o) => IsDocument o+instance (GObject o, O.IsDescendantOf Document o) => IsDocument o+instance O.HasParentTypes Document+#if ENABLE_OVERLOADING+data DocumentGetAttributeValueMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetAttributesMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetCurrentPageNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetDocumentMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetDocumentTypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetLocaleMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentGetPageCountMethodInfo+#endif+#if ENABLE_OVERLOADING+data DocumentSetAttributeValueMethodInfo+#endif

@@ -0,0 +1,445 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++'GI.Atk.Interfaces.EditableText.EditableText' should be implemented by UI components which+contain text which the user can edit, via the 'GI.Atk.Objects.Object.Object'+corresponding to that component (see 'GI.Atk.Objects.Object.Object').++'GI.Atk.Interfaces.EditableText.EditableText' is a subclass of 'GI.Atk.Interfaces.Text.Text', and as such, an object+which implements 'GI.Atk.Interfaces.EditableText.EditableText' is by definition an 'GI.Atk.Interfaces.Text.Text'+implementor as well.++See also: 'GI.Atk.Interfaces.Text.Text'+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces.EditableText+    ( ++-- * Exported types+    EditableText(..)                        ,+    noEditableText                          ,+    IsEditableText                          ,+++ -- * Methods+-- ** copyText #method:copyText#++#if ENABLE_OVERLOADING+    EditableTextCopyTextMethodInfo          ,+#endif+    editableTextCopyText                    ,+++-- ** cutText #method:cutText#++#if ENABLE_OVERLOADING+    EditableTextCutTextMethodInfo           ,+#endif+    editableTextCutText                     ,+++-- ** deleteText #method:deleteText#++#if ENABLE_OVERLOADING+    EditableTextDeleteTextMethodInfo        ,+#endif+    editableTextDeleteText                  ,+++-- ** insertText #method:insertText#++#if ENABLE_OVERLOADING+    EditableTextInsertTextMethodInfo        ,+#endif+    editableTextInsertText                  ,+++-- ** pasteText #method:pasteText#++#if ENABLE_OVERLOADING+    EditableTextPasteTextMethodInfo         ,+#endif+    editableTextPasteText                   ,+++-- ** setRunAttributes #method:setRunAttributes#++#if ENABLE_OVERLOADING+    EditableTextSetRunAttributesMethodInfo  ,+#endif+    editableTextSetRunAttributes            ,+++-- ** setTextContents #method:setTextContents#++#if ENABLE_OVERLOADING+    EditableTextSetTextContentsMethodInfo   ,+#endif+    editableTextSetTextContents             ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- interface EditableText +-- | Memory-managed wrapper type.+newtype EditableText = EditableText (ManagedPtr EditableText)+-- | A convenience alias for `Nothing` :: `Maybe` `EditableText`.+noEditableText :: Maybe EditableText+noEditableText = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList EditableText = EditableTextSignalList+type EditableTextSignalList = ('[ ] :: [(Symbol, *)])++#endif++-- | Type class for types which implement `EditableText`.+class ManagedPtrNewtype a => IsEditableText a+instance IsEditableText EditableText+-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?+instance WrappedPtr EditableText where+    wrappedPtrCalloc = return nullPtr+    wrappedPtrCopy = return+    wrappedPtrFree = Nothing+++#if ENABLE_OVERLOADING+type family ResolveEditableTextMethod (t :: Symbol) (o :: *) :: * where+    ResolveEditableTextMethod "copyText" o = EditableTextCopyTextMethodInfo+    ResolveEditableTextMethod "cutText" o = EditableTextCutTextMethodInfo+    ResolveEditableTextMethod "deleteText" o = EditableTextDeleteTextMethodInfo+    ResolveEditableTextMethod "insertText" o = EditableTextInsertTextMethodInfo+    ResolveEditableTextMethod "pasteText" o = EditableTextPasteTextMethodInfo+    ResolveEditableTextMethod "setRunAttributes" o = EditableTextSetRunAttributesMethodInfo+    ResolveEditableTextMethod "setTextContents" o = EditableTextSetTextContentsMethodInfo+    ResolveEditableTextMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveEditableTextMethod t EditableText, O.MethodInfo info EditableText p) => OL.IsLabel t (EditableText -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method EditableText::copy_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_copy_text" atk_editable_text_copy_text :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    Int32 ->                                -- start_pos : TBasicType TInt+    Int32 ->                                -- end_pos : TBasicType TInt+    IO ()++{- |+Copy text from /@startPos@/ up to, but not including /@endPos@/+to the clipboard.+-}+editableTextCopyText ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> Int32+    {- ^ /@startPos@/: start position -}+    -> Int32+    {- ^ /@endPos@/: end position -}+    -> m ()+editableTextCopyText text startPos endPos = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    atk_editable_text_copy_text text' startPos endPos+    touchManagedPtr text+    return ()++#if ENABLE_OVERLOADING+data EditableTextCopyTextMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextCopyTextMethodInfo a signature where+    overloadedMethod _ = editableTextCopyText++#endif++-- method EditableText::cut_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_cut_text" atk_editable_text_cut_text :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    Int32 ->                                -- start_pos : TBasicType TInt+    Int32 ->                                -- end_pos : TBasicType TInt+    IO ()++{- |+Copy text from /@startPos@/ up to, but not including /@endPos@/+to the clipboard and then delete from the widget.+-}+editableTextCutText ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> Int32+    {- ^ /@startPos@/: start position -}+    -> Int32+    {- ^ /@endPos@/: end position -}+    -> m ()+editableTextCutText text startPos endPos = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    atk_editable_text_cut_text text' startPos endPos+    touchManagedPtr text+    return ()++#if ENABLE_OVERLOADING+data EditableTextCutTextMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextCutTextMethodInfo a signature where+    overloadedMethod _ = editableTextCutText++#endif++-- method EditableText::delete_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_delete_text" atk_editable_text_delete_text :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    Int32 ->                                -- start_pos : TBasicType TInt+    Int32 ->                                -- end_pos : TBasicType TInt+    IO ()++{- |+Delete text /@startPos@/ up to, but not including /@endPos@/.+-}+editableTextDeleteText ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> Int32+    {- ^ /@startPos@/: start position -}+    -> Int32+    {- ^ /@endPos@/: end position -}+    -> m ()+editableTextDeleteText text startPos endPos = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    atk_editable_text_delete_text text' startPos endPos+    touchManagedPtr text+    return ()++#if ENABLE_OVERLOADING+data EditableTextDeleteTextMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextDeleteTextMethodInfo a signature where+    overloadedMethod _ = editableTextDeleteText++#endif++-- method EditableText::insert_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to insert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of text to insert, in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The caller initializes this to\nthe position at which to insert the text. After the call it\npoints at the position after the newly inserted text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_insert_text" atk_editable_text_insert_text :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    CString ->                              -- string : TBasicType TUTF8+    Int32 ->                                -- length : TBasicType TInt+    Int32 ->                                -- position : TBasicType TInt+    IO ()++{- |+Insert text at a given position.+-}+editableTextInsertText ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> T.Text+    {- ^ /@string@/: the text to insert -}+    -> Int32+    {- ^ /@length@/: the length of text to insert, in bytes -}+    -> Int32+    {- ^ /@position@/: The caller initializes this to+the position at which to insert the text. After the call it+points at the position after the newly inserted text. -}+    -> m ()+editableTextInsertText text string length_ position = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    string' <- textToCString string+    atk_editable_text_insert_text text' string' length_ position+    touchManagedPtr text+    freeMem string'+    return ()++#if ENABLE_OVERLOADING+data EditableTextInsertTextMethodInfo+instance (signature ~ (T.Text -> Int32 -> Int32 -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextInsertTextMethodInfo a signature where+    overloadedMethod _ = editableTextInsertText++#endif++-- method EditableText::paste_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position to paste", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_paste_text" atk_editable_text_paste_text :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    Int32 ->                                -- position : TBasicType TInt+    IO ()++{- |+Paste text from clipboard to specified /@position@/.+-}+editableTextPasteText ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> Int32+    {- ^ /@position@/: position to paste -}+    -> m ()+editableTextPasteText text position = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    atk_editable_text_paste_text text' position+    touchManagedPtr text+    return ()++#if ENABLE_OVERLOADING+data EditableTextPasteTextMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextPasteTextMethodInfo a signature where+    overloadedMethod _ = editableTextPasteText++#endif++-- method EditableText::set_run_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attrib_set", argType = TGSList (TBasicType TPtr), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkAttributeSet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of range in which to set attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of range in which to set attributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_set_run_attributes" atk_editable_text_set_run_attributes :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    Ptr (GSList (Ptr ())) ->                -- attrib_set : TGSList (TBasicType TPtr)+    Int32 ->                                -- start_offset : TBasicType TInt+    Int32 ->                                -- end_offset : TBasicType TInt+    IO CInt++{- |+Sets the attributes for a specified range. See the ATK_ATTRIBUTE+macros (such as @/ATK_ATTRIBUTE_LEFT_MARGIN/@) for examples of attributes+that can be set. Note that other attributes that do not have corresponding+ATK_ATTRIBUTE macros may also be set for certain text widgets.+-}+editableTextSetRunAttributes ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> [Ptr ()]+    {- ^ /@attribSet@/: an @/AtkAttributeSet/@ -}+    -> Int32+    {- ^ /@startOffset@/: start of range in which to set attributes -}+    -> Int32+    {- ^ /@endOffset@/: end of range in which to set attributes -}+    -> m Bool+    {- ^ __Returns:__ 'True' if attributes successfully set for the specified+range, otherwise 'False' -}+editableTextSetRunAttributes text attribSet startOffset endOffset = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    attribSet' <- packGSList attribSet+    result <- atk_editable_text_set_run_attributes text' attribSet' startOffset endOffset+    let result' = (/= 0) result+    touchManagedPtr text+    g_slist_free attribSet'+    return result'++#if ENABLE_OVERLOADING+data EditableTextSetRunAttributesMethodInfo+instance (signature ~ ([Ptr ()] -> Int32 -> Int32 -> m Bool), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextSetRunAttributesMethodInfo a signature where+    overloadedMethod _ = editableTextSetRunAttributes++#endif++-- method EditableText::set_text_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "text", argType = TInterface (Name {namespace = "Atk", name = "EditableText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkEditableText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "string to set for text contents of @text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "atk_editable_text_set_text_contents" atk_editable_text_set_text_contents :: +    Ptr EditableText ->                     -- text : TInterface (Name {namespace = "Atk", name = "EditableText"})+    CString ->                              -- string : TBasicType TUTF8+    IO ()++{- |+Set text contents of /@text@/.+-}+editableTextSetTextContents ::+    (B.CallStack.HasCallStack, MonadIO m, IsEditableText a) =>+    a+    {- ^ /@text@/: an 'GI.Atk.Interfaces.EditableText.EditableText' -}+    -> T.Text+    {- ^ /@string@/: string to set for text contents of /@text@/ -}+    -> m ()+editableTextSetTextContents text string = liftIO $ do+    text' <- unsafeManagedPtrCastPtr text+    string' <- textToCString string+    atk_editable_text_set_text_contents text' string'+    touchManagedPtr text+    freeMem string'+    return ()++#if ENABLE_OVERLOADING+data EditableTextSetTextContentsMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsEditableText a) => O.MethodInfo EditableTextSetTextContentsMethodInfo a signature where+    overloadedMethod _ = editableTextSetTextContents++#endif++

@@ -0,0 +1,48 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.Atk.Interfaces.EditableText where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype EditableText = EditableText (ManagedPtr EditableText)+class ManagedPtrNewtype a => IsEditableText a+instance WrappedPtr EditableText where+#if ENABLE_OVERLOADING+data EditableTextCopyTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextCutTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextDeleteTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextInsertTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextPasteTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextSetRunAttributesMethodInfo+#endif+#if ENABLE_OVERLOADING+data EditableTextSetTextContentsMethodInfo+#endif

@@ -0,0 +1,161 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++AtkHyperlinkImpl allows AtkObjects to refer to their associated+AtkHyperlink instance, if one exists.  AtkHyperlinkImpl differs+from AtkHyperlink in that AtkHyperlinkImpl is an interface, whereas+AtkHyperlink is a object type.  The AtkHyperlinkImpl interface+allows a client to query an AtkObject for the availability of an+associated AtkHyperlink instance, and obtain that instance.  It is+thus particularly useful in cases where embedded content or inline+content within a text object is present, since the embedding text+object implements AtkHypertext and the inline\/embedded objects are+exposed as children which implement AtkHyperlinkImpl, in addition+to their being obtainable via AtkHypertext:getLink followed by+AtkHyperlink:getObject.++The AtkHyperlinkImpl interface should be supported by objects+exposed within the hierarchy as children of an AtkHypertext+container which correspond to \"links\" or embedded content within+the text.  HTML anchors are not, for instance, normally exposed+this way, but embedded images and components which appear inline in+the content of a text object are. The AtkHyperlinkIface interface+allows a means of determining which children are hyperlinks in this+sense of the word, and for obtaining their corresponding+AtkHyperlink object, from which the embedding range, URI, etc. can+be obtained.++To some extent this interface exists because, for historical+reasons, AtkHyperlink was defined as an object type, not an+interface.  Thus, in order to interact with AtkObjects via+AtkHyperlink semantics, a new interface was required.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.Atk.Interfaces.HyperlinkImpl+    ( ++-- * Exported types+    HyperlinkImpl(..)                       ,+    noHyperlinkImpl                         ,+    IsHyperlinkImpl                         ,+++ -- * Methods+-- ** getHyperlink #method:getHyperlink#++#if ENABLE_OVERLOADING+    HyperlinkImplGetHyperlinkMethodInfo     ,+#endif+    hyperlinkImplGetHyperlink               ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import {-# SOURCE #-} qualified GI.Atk.Objects.Hyperlink as Atk.Hyperlink++-- interface HyperlinkImpl +-- | Memory-managed wrapper type.+newtype HyperlinkImpl = HyperlinkImpl (ManagedPtr HyperlinkImpl)+-- | A convenience alias for `Nothing` :: `Maybe` `HyperlinkImpl`.+noHyperlinkImpl :: Maybe HyperlinkImpl+noHyperlinkImpl = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList HyperlinkImpl = HyperlinkImplSignalList+type HyperlinkImplSignalList = ('[ ] :: [(Symbol, *)])++#endif++-- | Type class for types which implement `HyperlinkImpl`.+class ManagedPtrNewtype a => IsHyperlinkImpl a+instance IsHyperlinkImpl HyperlinkImpl+-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?+instance WrappedPtr HyperlinkImpl where+    wrappedPtrCalloc = return nullPtr+    wrappedPtrCopy = return+    wrappedPtrFree = Nothing+++#if ENABLE_OVERLOADING+type family ResolveHyperlinkImplMethod (t :: Symbol) (o :: *) :: * where+    ResolveHyperlinkImplMethod "getHyperlink" o = HyperlinkImplGetHyperlinkMethodInfo+    ResolveHyperlinkImplMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveHyperlinkImplMethod t HyperlinkImpl, O.MethodInfo info HyperlinkImpl p) => OL.IsLabel t (HyperlinkImpl -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- method HyperlinkImpl::get_hyperlink+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "impl", argType = TInterface (Name {namespace = "Atk", name = "HyperlinkImpl"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject instance that implements AtkHyperlinkImplIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Hyperlink"}))+-- throws : False+-- Skip return : False++foreign import ccall "atk_hyperlink_impl_get_hyperlink" atk_hyperlink_impl_get_hyperlink :: +    Ptr HyperlinkImpl ->                    -- impl : TInterface (Name {namespace = "Atk", name = "HyperlinkImpl"})+    IO (Ptr Atk.Hyperlink.Hyperlink)++{- |+Gets the hyperlink associated with this object.++/Since: 1.12/+-}+hyperlinkImplGetHyperlink ::+    (B.CallStack.HasCallStack, MonadIO m, IsHyperlinkImpl a) =>+    a+    {- ^ /@impl@/: a 'GI.GObject.Objects.Object.Object' instance that implements AtkHyperlinkImplIface -}+    -> m Atk.Hyperlink.Hyperlink+    {- ^ __Returns:__ an AtkHyperlink object which points to this+implementing AtkObject. -}+hyperlinkImplGetHyperlink impl = liftIO $ do+    impl' <- unsafeManagedPtrCastPtr impl+    result <- atk_hyperlink_impl_get_hyperlink impl'+    checkUnexpectedReturnNULL "hyperlinkImplGetHyperlink" result+    result' <- (wrapObject Atk.Hyperlink.Hyperlink) result+    touchManagedPtr impl+    return result'++#if ENABLE_OVERLOADING+data HyperlinkImplGetHyperlinkMethodInfo+instance (signature ~ (m Atk.Hyperlink.Hyperlink), MonadIO m, IsHyperlinkImpl a) => O.MethodInfo HyperlinkImplGetHyperlinkMethodInfo a signature where+    overloadedMethod _ = hyperlinkImplGetHyperlink++#endif++