{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Interfaces.Accessible
(
Accessible(..) ,
IsAccessible ,
toAccessible ,
#if defined(ENABLE_OVERLOADING)
ResolveAccessibleMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AccessibleGetAccessibleParentMethodInfo ,
#endif
accessibleGetAccessibleParent ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetAccessibleRoleMethodInfo ,
#endif
accessibleGetAccessibleRole ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetAtContextMethodInfo ,
#endif
accessibleGetAtContext ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetBoundsMethodInfo ,
#endif
accessibleGetBounds ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetFirstAccessibleChildMethodInfo,
#endif
accessibleGetFirstAccessibleChild ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetNextAccessibleSiblingMethodInfo,
#endif
accessibleGetNextAccessibleSibling ,
#if defined(ENABLE_OVERLOADING)
AccessibleGetPlatformStateMethodInfo ,
#endif
accessibleGetPlatformState ,
#if defined(ENABLE_OVERLOADING)
AccessibleResetPropertyMethodInfo ,
#endif
accessibleResetProperty ,
#if defined(ENABLE_OVERLOADING)
AccessibleResetRelationMethodInfo ,
#endif
accessibleResetRelation ,
#if defined(ENABLE_OVERLOADING)
AccessibleResetStateMethodInfo ,
#endif
accessibleResetState ,
#if defined(ENABLE_OVERLOADING)
AccessibleSetAccessibleParentMethodInfo ,
#endif
accessibleSetAccessibleParent ,
#if defined(ENABLE_OVERLOADING)
AccessibleUpdateNextAccessibleSiblingMethodInfo,
#endif
accessibleUpdateNextAccessibleSibling ,
#if defined(ENABLE_OVERLOADING)
AccessibleUpdatePropertyMethodInfo ,
#endif
accessibleUpdateProperty ,
#if defined(ENABLE_OVERLOADING)
AccessibleUpdateRelationMethodInfo ,
#endif
accessibleUpdateRelation ,
#if defined(ENABLE_OVERLOADING)
AccessibleUpdateStateMethodInfo ,
#endif
accessibleUpdateState ,
#if defined(ENABLE_OVERLOADING)
AccessibleAccessibleRolePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
accessibleAccessibleRole ,
#endif
constructAccessibleAccessibleRole ,
getAccessibleAccessibleRole ,
setAccessibleAccessibleRole ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
newtype Accessible = Accessible (SP.ManagedPtr Accessible)
deriving (Accessible -> Accessible -> Bool
(Accessible -> Accessible -> Bool)
-> (Accessible -> Accessible -> Bool) -> Eq Accessible
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Accessible -> Accessible -> Bool
== :: Accessible -> Accessible -> Bool
$c/= :: Accessible -> Accessible -> Bool
/= :: Accessible -> Accessible -> Bool
Eq)
instance SP.ManagedPtrNewtype Accessible where
toManagedPtr :: Accessible -> ManagedPtr Accessible
toManagedPtr (Accessible ManagedPtr Accessible
p) = ManagedPtr Accessible
p
foreign import ccall "gtk_accessible_get_type"
c_gtk_accessible_get_type :: IO B.Types.GType
instance B.Types.TypedObject Accessible where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_get_type
instance B.Types.GObject Accessible
class (SP.GObject o, O.IsDescendantOf Accessible o) => IsAccessible o
instance (SP.GObject o, O.IsDescendantOf Accessible o) => IsAccessible o
instance O.HasParentTypes Accessible
type instance O.ParentTypes Accessible = '[GObject.Object.Object]
toAccessible :: (MIO.MonadIO m, IsAccessible o) => o -> m Accessible
toAccessible :: forall (m :: * -> *) o.
(MonadIO m, IsAccessible o) =>
o -> m Accessible
toAccessible = IO Accessible -> m Accessible
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Accessible -> m Accessible)
-> (o -> IO Accessible) -> o -> m Accessible
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Accessible -> Accessible) -> o -> IO Accessible
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Accessible -> Accessible
Accessible
instance B.GValue.IsGValue (Maybe Accessible) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_accessible_get_type
gvalueSet_ :: Ptr GValue -> Maybe Accessible -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Accessible
P.Nothing = Ptr GValue -> Ptr Accessible -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Accessible
forall a. Ptr a
FP.nullPtr :: FP.Ptr Accessible)
gvalueSet_ Ptr GValue
gv (P.Just Accessible
obj) = Accessible -> (Ptr Accessible -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Accessible
obj (Ptr GValue -> Ptr Accessible -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Accessible)
gvalueGet_ Ptr GValue
gv = do
Ptr Accessible
ptr <- Ptr GValue -> IO (Ptr Accessible)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Accessible)
if Ptr Accessible
ptr Ptr Accessible -> Ptr Accessible -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Accessible
forall a. Ptr a
FP.nullPtr
then Accessible -> Maybe Accessible
forall a. a -> Maybe a
P.Just (Accessible -> Maybe Accessible)
-> IO Accessible -> IO (Maybe Accessible)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Accessible -> Accessible)
-> Ptr Accessible -> IO Accessible
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Accessible -> Accessible
Accessible Ptr Accessible
ptr
else Maybe Accessible -> IO (Maybe Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Accessible
forall a. Maybe a
P.Nothing
getAccessibleAccessibleRole :: (MonadIO m, IsAccessible o) => o -> m Gtk.Enums.AccessibleRole
getAccessibleAccessibleRole :: forall (m :: * -> *) o.
(MonadIO m, IsAccessible o) =>
o -> m AccessibleRole
getAccessibleAccessibleRole o
obj = IO AccessibleRole -> m AccessibleRole
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO AccessibleRole -> m AccessibleRole)
-> IO AccessibleRole -> m AccessibleRole
forall a b. (a -> b) -> a -> b
$ o -> String -> IO AccessibleRole
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"accessible-role"
setAccessibleAccessibleRole :: (MonadIO m, IsAccessible o) => o -> Gtk.Enums.AccessibleRole -> m ()
setAccessibleAccessibleRole :: forall (m :: * -> *) o.
(MonadIO m, IsAccessible o) =>
o -> AccessibleRole -> m ()
setAccessibleAccessibleRole o
obj AccessibleRole
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> AccessibleRole -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"accessible-role" AccessibleRole
val
constructAccessibleAccessibleRole :: (IsAccessible o, MIO.MonadIO m) => Gtk.Enums.AccessibleRole -> m (GValueConstruct o)
constructAccessibleAccessibleRole :: forall o (m :: * -> *).
(IsAccessible o, MonadIO m) =>
AccessibleRole -> m (GValueConstruct o)
constructAccessibleAccessibleRole AccessibleRole
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> AccessibleRole -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"accessible-role" AccessibleRole
val
#if defined(ENABLE_OVERLOADING)
data AccessibleAccessibleRolePropertyInfo
instance AttrInfo AccessibleAccessibleRolePropertyInfo where
type AttrAllowedOps AccessibleAccessibleRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint AccessibleAccessibleRolePropertyInfo = IsAccessible
type AttrSetTypeConstraint AccessibleAccessibleRolePropertyInfo = (~) Gtk.Enums.AccessibleRole
type AttrTransferTypeConstraint AccessibleAccessibleRolePropertyInfo = (~) Gtk.Enums.AccessibleRole
type AttrTransferType AccessibleAccessibleRolePropertyInfo = Gtk.Enums.AccessibleRole
type AttrGetType AccessibleAccessibleRolePropertyInfo = Gtk.Enums.AccessibleRole
type AttrLabel AccessibleAccessibleRolePropertyInfo = "accessible-role"
type AttrOrigin AccessibleAccessibleRolePropertyInfo = Accessible
attrGet = getAccessibleAccessibleRole
attrSet = setAccessibleAccessibleRole
attrTransfer _ v = do
return v
attrConstruct = constructAccessibleAccessibleRole
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleRole"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#g:attr:accessibleRole"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Accessible
type instance O.AttributeList Accessible = AccessibleAttributeList
type AccessibleAttributeList = ('[ '("accessibleRole", AccessibleAccessibleRolePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
accessibleAccessibleRole :: AttrLabelProxy "accessibleRole"
accessibleAccessibleRole = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAccessibleMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveAccessibleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveAccessibleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveAccessibleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveAccessibleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveAccessibleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveAccessibleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveAccessibleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveAccessibleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveAccessibleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveAccessibleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveAccessibleMethod "resetProperty" o = AccessibleResetPropertyMethodInfo
ResolveAccessibleMethod "resetRelation" o = AccessibleResetRelationMethodInfo
ResolveAccessibleMethod "resetState" o = AccessibleResetStateMethodInfo
ResolveAccessibleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveAccessibleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveAccessibleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveAccessibleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveAccessibleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveAccessibleMethod "updateNextAccessibleSibling" o = AccessibleUpdateNextAccessibleSiblingMethodInfo
ResolveAccessibleMethod "updateProperty" o = AccessibleUpdatePropertyMethodInfo
ResolveAccessibleMethod "updateRelation" o = AccessibleUpdateRelationMethodInfo
ResolveAccessibleMethod "updateState" o = AccessibleUpdateStateMethodInfo
ResolveAccessibleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveAccessibleMethod "getAccessibleParent" o = AccessibleGetAccessibleParentMethodInfo
ResolveAccessibleMethod "getAccessibleRole" o = AccessibleGetAccessibleRoleMethodInfo
ResolveAccessibleMethod "getAtContext" o = AccessibleGetAtContextMethodInfo
ResolveAccessibleMethod "getBounds" o = AccessibleGetBoundsMethodInfo
ResolveAccessibleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveAccessibleMethod "getFirstAccessibleChild" o = AccessibleGetFirstAccessibleChildMethodInfo
ResolveAccessibleMethod "getNextAccessibleSibling" o = AccessibleGetNextAccessibleSiblingMethodInfo
ResolveAccessibleMethod "getPlatformState" o = AccessibleGetPlatformStateMethodInfo
ResolveAccessibleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveAccessibleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveAccessibleMethod "setAccessibleParent" o = AccessibleSetAccessibleParentMethodInfo
ResolveAccessibleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveAccessibleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveAccessibleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveAccessibleMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAccessibleMethod t Accessible, O.OverloadedMethod info Accessible p) => OL.IsLabel t (Accessible -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveAccessibleMethod t Accessible, O.OverloadedMethod info Accessible p, R.HasField t Accessible p) => R.HasField t Accessible p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAccessibleMethod t Accessible, O.OverloadedMethodInfo info Accessible) => OL.IsLabel t (O.MethodProxy info Accessible) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "gtk_accessible_get_accessible_parent" gtk_accessible_get_accessible_parent ::
Ptr Accessible ->
IO (Ptr Accessible)
accessibleGetAccessibleParent ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m (Maybe Accessible)
accessibleGetAccessibleParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m (Maybe Accessible)
accessibleGetAccessibleParent a
self = IO (Maybe Accessible) -> m (Maybe Accessible)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Accessible) -> m (Maybe Accessible))
-> IO (Maybe Accessible) -> m (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Accessible
result <- Ptr Accessible -> IO (Ptr Accessible)
gtk_accessible_get_accessible_parent Ptr Accessible
self'
Maybe Accessible
maybeResult <- Ptr Accessible
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Accessible
result ((Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible))
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ \Ptr Accessible
result' -> do
Accessible
result'' <- ((ManagedPtr Accessible -> Accessible)
-> Ptr Accessible -> IO Accessible
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Accessible -> Accessible
Accessible) Ptr Accessible
result'
Accessible -> IO Accessible
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Accessible
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Accessible -> IO (Maybe Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Accessible
maybeResult
#if defined(ENABLE_OVERLOADING)
data AccessibleGetAccessibleParentMethodInfo
instance (signature ~ (m (Maybe Accessible)), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetAccessibleParentMethodInfo a signature where
overloadedMethod = accessibleGetAccessibleParent
instance O.OverloadedMethodInfo AccessibleGetAccessibleParentMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetAccessibleParent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetAccessibleParent"
})
#endif
foreign import ccall "gtk_accessible_get_accessible_role" gtk_accessible_get_accessible_role ::
Ptr Accessible ->
IO CUInt
accessibleGetAccessibleRole ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m Gtk.Enums.AccessibleRole
accessibleGetAccessibleRole :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m AccessibleRole
accessibleGetAccessibleRole a
self = IO AccessibleRole -> m AccessibleRole
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AccessibleRole -> m AccessibleRole)
-> IO AccessibleRole -> m AccessibleRole
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CUInt
result <- Ptr Accessible -> IO CUInt
gtk_accessible_get_accessible_role Ptr Accessible
self'
let result' :: AccessibleRole
result' = (Int -> AccessibleRole
forall a. Enum a => Int -> a
toEnum (Int -> AccessibleRole)
-> (CUInt -> Int) -> CUInt -> AccessibleRole
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
AccessibleRole -> IO AccessibleRole
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AccessibleRole
result'
#if defined(ENABLE_OVERLOADING)
data AccessibleGetAccessibleRoleMethodInfo
instance (signature ~ (m Gtk.Enums.AccessibleRole), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetAccessibleRoleMethodInfo a signature where
overloadedMethod = accessibleGetAccessibleRole
instance O.OverloadedMethodInfo AccessibleGetAccessibleRoleMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetAccessibleRole",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetAccessibleRole"
})
#endif
foreign import ccall "gtk_accessible_get_at_context" gtk_accessible_get_at_context ::
Ptr Accessible ->
IO (Ptr Gtk.ATContext.ATContext)
accessibleGetAtContext ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m Gtk.ATContext.ATContext
accessibleGetAtContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m ATContext
accessibleGetAtContext a
self = IO ATContext -> m ATContext
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ATContext -> m ATContext) -> IO ATContext -> m ATContext
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr ATContext
result <- Ptr Accessible -> IO (Ptr ATContext)
gtk_accessible_get_at_context Ptr Accessible
self'
Text -> Ptr ATContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"accessibleGetAtContext" Ptr ATContext
result
ATContext
result' <- ((ManagedPtr ATContext -> ATContext)
-> Ptr ATContext -> IO ATContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ATContext -> ATContext
Gtk.ATContext.ATContext) Ptr ATContext
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
ATContext -> IO ATContext
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ATContext
result'
#if defined(ENABLE_OVERLOADING)
data AccessibleGetAtContextMethodInfo
instance (signature ~ (m Gtk.ATContext.ATContext), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetAtContextMethodInfo a signature where
overloadedMethod = accessibleGetAtContext
instance O.OverloadedMethodInfo AccessibleGetAtContextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetAtContext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetAtContext"
})
#endif
foreign import ccall "gtk_accessible_get_bounds" gtk_accessible_get_bounds ::
Ptr Accessible ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int32 ->
IO CInt
accessibleGetBounds ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m ((Bool, Int32, Int32, Int32, Int32))
accessibleGetBounds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m (Bool, Int32, Int32, Int32, Int32)
accessibleGetBounds a
self = IO (Bool, Int32, Int32, Int32, Int32)
-> m (Bool, Int32, Int32, Int32, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32, Int32, Int32, Int32)
-> m (Bool, Int32, Int32, Int32, Int32))
-> IO (Bool, Int32, Int32, Int32, Int32)
-> m (Bool, Int32, Int32, Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Int32
x <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
y <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr Accessible
-> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO CInt
gtk_accessible_get_bounds Ptr Accessible
self' Ptr Int32
x Ptr Int32
y Ptr Int32
width Ptr Int32
height
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
x' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
x
Int32
y' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
y
Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
x
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
y
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
(Bool, Int32, Int32, Int32, Int32)
-> IO (Bool, Int32, Int32, Int32, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
x', Int32
y', Int32
width', Int32
height')
#if defined(ENABLE_OVERLOADING)
data AccessibleGetBoundsMethodInfo
instance (signature ~ (m ((Bool, Int32, Int32, Int32, Int32))), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetBoundsMethodInfo a signature where
overloadedMethod = accessibleGetBounds
instance O.OverloadedMethodInfo AccessibleGetBoundsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetBounds",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetBounds"
})
#endif
foreign import ccall "gtk_accessible_get_first_accessible_child" gtk_accessible_get_first_accessible_child ::
Ptr Accessible ->
IO (Ptr Accessible)
accessibleGetFirstAccessibleChild ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m (Maybe Accessible)
accessibleGetFirstAccessibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m (Maybe Accessible)
accessibleGetFirstAccessibleChild a
self = IO (Maybe Accessible) -> m (Maybe Accessible)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Accessible) -> m (Maybe Accessible))
-> IO (Maybe Accessible) -> m (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Accessible
result <- Ptr Accessible -> IO (Ptr Accessible)
gtk_accessible_get_first_accessible_child Ptr Accessible
self'
Maybe Accessible
maybeResult <- Ptr Accessible
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Accessible
result ((Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible))
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ \Ptr Accessible
result' -> do
Accessible
result'' <- ((ManagedPtr Accessible -> Accessible)
-> Ptr Accessible -> IO Accessible
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Accessible -> Accessible
Accessible) Ptr Accessible
result'
Accessible -> IO Accessible
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Accessible
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Accessible -> IO (Maybe Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Accessible
maybeResult
#if defined(ENABLE_OVERLOADING)
data AccessibleGetFirstAccessibleChildMethodInfo
instance (signature ~ (m (Maybe Accessible)), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetFirstAccessibleChildMethodInfo a signature where
overloadedMethod = accessibleGetFirstAccessibleChild
instance O.OverloadedMethodInfo AccessibleGetFirstAccessibleChildMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetFirstAccessibleChild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetFirstAccessibleChild"
})
#endif
foreign import ccall "gtk_accessible_get_next_accessible_sibling" gtk_accessible_get_next_accessible_sibling ::
Ptr Accessible ->
IO (Ptr Accessible)
accessibleGetNextAccessibleSibling ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> m (Maybe Accessible)
accessibleGetNextAccessibleSibling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> m (Maybe Accessible)
accessibleGetNextAccessibleSibling a
self = IO (Maybe Accessible) -> m (Maybe Accessible)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Accessible) -> m (Maybe Accessible))
-> IO (Maybe Accessible) -> m (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Accessible
result <- Ptr Accessible -> IO (Ptr Accessible)
gtk_accessible_get_next_accessible_sibling Ptr Accessible
self'
Maybe Accessible
maybeResult <- Ptr Accessible
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Accessible
result ((Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible))
-> (Ptr Accessible -> IO Accessible) -> IO (Maybe Accessible)
forall a b. (a -> b) -> a -> b
$ \Ptr Accessible
result' -> do
Accessible
result'' <- ((ManagedPtr Accessible -> Accessible)
-> Ptr Accessible -> IO Accessible
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Accessible -> Accessible
Accessible) Ptr Accessible
result'
Accessible -> IO Accessible
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Accessible
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe Accessible -> IO (Maybe Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Accessible
maybeResult
#if defined(ENABLE_OVERLOADING)
data AccessibleGetNextAccessibleSiblingMethodInfo
instance (signature ~ (m (Maybe Accessible)), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetNextAccessibleSiblingMethodInfo a signature where
overloadedMethod = accessibleGetNextAccessibleSibling
instance O.OverloadedMethodInfo AccessibleGetNextAccessibleSiblingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetNextAccessibleSibling",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetNextAccessibleSibling"
})
#endif
foreign import ccall "gtk_accessible_get_platform_state" gtk_accessible_get_platform_state ::
Ptr Accessible ->
CUInt ->
IO CInt
accessibleGetPlatformState ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> Gtk.Enums.AccessiblePlatformState
-> m Bool
accessibleGetPlatformState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> AccessiblePlatformState -> m Bool
accessibleGetPlatformState a
self AccessiblePlatformState
state = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessiblePlatformState -> Int)
-> AccessiblePlatformState
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessiblePlatformState -> Int
forall a. Enum a => a -> Int
fromEnum) AccessiblePlatformState
state
CInt
result <- Ptr Accessible -> CUInt -> IO CInt
gtk_accessible_get_platform_state Ptr Accessible
self' CUInt
state'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data AccessibleGetPlatformStateMethodInfo
instance (signature ~ (Gtk.Enums.AccessiblePlatformState -> m Bool), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleGetPlatformStateMethodInfo a signature where
overloadedMethod = accessibleGetPlatformState
instance O.OverloadedMethodInfo AccessibleGetPlatformStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleGetPlatformState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleGetPlatformState"
})
#endif
foreign import ccall "gtk_accessible_reset_property" gtk_accessible_reset_property ::
Ptr Accessible ->
CUInt ->
IO ()
accessibleResetProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> Gtk.Enums.AccessibleProperty
-> m ()
accessibleResetProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> AccessibleProperty -> m ()
accessibleResetProperty a
self AccessibleProperty
property = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let property' :: CUInt
property' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleProperty -> Int) -> AccessibleProperty -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleProperty -> Int
forall a. Enum a => a -> Int
fromEnum) AccessibleProperty
property
Ptr Accessible -> CUInt -> IO ()
gtk_accessible_reset_property Ptr Accessible
self' CUInt
property'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleResetPropertyMethodInfo
instance (signature ~ (Gtk.Enums.AccessibleProperty -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleResetPropertyMethodInfo a signature where
overloadedMethod = accessibleResetProperty
instance O.OverloadedMethodInfo AccessibleResetPropertyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleResetProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleResetProperty"
})
#endif
foreign import ccall "gtk_accessible_reset_relation" gtk_accessible_reset_relation ::
Ptr Accessible ->
CUInt ->
IO ()
accessibleResetRelation ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> Gtk.Enums.AccessibleRelation
-> m ()
accessibleResetRelation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> AccessibleRelation -> m ()
accessibleResetRelation a
self AccessibleRelation
relation = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let relation' :: CUInt
relation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleRelation -> Int) -> AccessibleRelation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleRelation -> Int
forall a. Enum a => a -> Int
fromEnum) AccessibleRelation
relation
Ptr Accessible -> CUInt -> IO ()
gtk_accessible_reset_relation Ptr Accessible
self' CUInt
relation'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleResetRelationMethodInfo
instance (signature ~ (Gtk.Enums.AccessibleRelation -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleResetRelationMethodInfo a signature where
overloadedMethod = accessibleResetRelation
instance O.OverloadedMethodInfo AccessibleResetRelationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleResetRelation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleResetRelation"
})
#endif
foreign import ccall "gtk_accessible_reset_state" gtk_accessible_reset_state ::
Ptr Accessible ->
CUInt ->
IO ()
accessibleResetState ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> Gtk.Enums.AccessibleState
-> m ()
accessibleResetState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> AccessibleState -> m ()
accessibleResetState a
self AccessibleState
state = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleState -> Int) -> AccessibleState -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleState -> Int
forall a. Enum a => a -> Int
fromEnum) AccessibleState
state
Ptr Accessible -> CUInt -> IO ()
gtk_accessible_reset_state Ptr Accessible
self' CUInt
state'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleResetStateMethodInfo
instance (signature ~ (Gtk.Enums.AccessibleState -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleResetStateMethodInfo a signature where
overloadedMethod = accessibleResetState
instance O.OverloadedMethodInfo AccessibleResetStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleResetState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleResetState"
})
#endif
foreign import ccall "gtk_accessible_set_accessible_parent" gtk_accessible_set_accessible_parent ::
Ptr Accessible ->
Ptr Accessible ->
Ptr Accessible ->
IO ()
accessibleSetAccessibleParent ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a, IsAccessible b, IsAccessible c) =>
a
-> Maybe (b)
-> Maybe (c)
-> m ()
accessibleSetAccessibleParent :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsAccessible a, IsAccessible b,
IsAccessible c) =>
a -> Maybe b -> Maybe c -> m ()
accessibleSetAccessibleParent a
self Maybe b
parent Maybe c
nextSibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Accessible
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Accessible
jParent' <- b -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
jParent'
Ptr Accessible
maybeNextSibling <- case Maybe c
nextSibling of
Maybe c
Nothing -> Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
forall a. Ptr a
nullPtr
Just c
jNextSibling -> do
Ptr Accessible
jNextSibling' <- c -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jNextSibling
Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
jNextSibling'
Ptr Accessible -> Ptr Accessible -> Ptr Accessible -> IO ()
gtk_accessible_set_accessible_parent Ptr Accessible
self' Ptr Accessible
maybeParent Ptr Accessible
maybeNextSibling
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
nextSibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleSetAccessibleParentMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsAccessible a, IsAccessible b, IsAccessible c) => O.OverloadedMethod AccessibleSetAccessibleParentMethodInfo a signature where
overloadedMethod = accessibleSetAccessibleParent
instance O.OverloadedMethodInfo AccessibleSetAccessibleParentMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleSetAccessibleParent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleSetAccessibleParent"
})
#endif
foreign import ccall "gtk_accessible_update_next_accessible_sibling" gtk_accessible_update_next_accessible_sibling ::
Ptr Accessible ->
Ptr Accessible ->
IO ()
accessibleUpdateNextAccessibleSibling ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a, IsAccessible b) =>
a
-> Maybe (b)
-> m ()
accessibleUpdateNextAccessibleSibling :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAccessible a, IsAccessible b) =>
a -> Maybe b -> m ()
accessibleUpdateNextAccessibleSibling a
self Maybe b
newSibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr Accessible
maybeNewSibling <- case Maybe b
newSibling of
Maybe b
Nothing -> Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
forall a. Ptr a
nullPtr
Just b
jNewSibling -> do
Ptr Accessible
jNewSibling' <- b -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jNewSibling
Ptr Accessible -> IO (Ptr Accessible)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Accessible
jNewSibling'
Ptr Accessible -> Ptr Accessible -> IO ()
gtk_accessible_update_next_accessible_sibling Ptr Accessible
self' Ptr Accessible
maybeNewSibling
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
newSibling b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleUpdateNextAccessibleSiblingMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsAccessible a, IsAccessible b) => O.OverloadedMethod AccessibleUpdateNextAccessibleSiblingMethodInfo a signature where
overloadedMethod = accessibleUpdateNextAccessibleSibling
instance O.OverloadedMethodInfo AccessibleUpdateNextAccessibleSiblingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleUpdateNextAccessibleSibling",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleUpdateNextAccessibleSibling"
})
#endif
foreign import ccall "gtk_accessible_update_property_value" gtk_accessible_update_property_value ::
Ptr Accessible ->
Int32 ->
Ptr CUInt ->
Ptr B.GValue.GValue ->
IO ()
accessibleUpdateProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> [Gtk.Enums.AccessibleProperty]
-> [GValue]
-> m ()
accessibleUpdateProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> [AccessibleProperty] -> [GValue] -> m ()
accessibleUpdateProperty a
self [AccessibleProperty]
properties [GValue]
values = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nProperties :: Int32
nProperties = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
let properties_expected_length_ :: Int32
properties_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [AccessibleProperty] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [AccessibleProperty]
properties
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
properties_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nProperties) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
String -> IO ()
forall a. HasCallStack => String -> a
error String
"Gtk.accessibleUpdateProperty : length of 'properties' does not agree with that of 'values'."
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let properties' :: [CUInt]
properties' = (AccessibleProperty -> CUInt) -> [AccessibleProperty] -> [CUInt]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleProperty -> Int) -> AccessibleProperty -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleProperty -> Int
forall a. Enum a => a -> Int
fromEnum) [AccessibleProperty]
properties
Ptr CUInt
properties'' <- [CUInt] -> IO (Ptr CUInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CUInt]
properties'
Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
Ptr Accessible -> Int32 -> Ptr CUInt -> Ptr GValue -> IO ()
gtk_accessible_update_property_value Ptr Accessible
self' Int32
nProperties Ptr CUInt
properties'' Ptr GValue
values'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
(GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
properties''
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleUpdatePropertyMethodInfo
instance (signature ~ ([Gtk.Enums.AccessibleProperty] -> [GValue] -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleUpdatePropertyMethodInfo a signature where
overloadedMethod = accessibleUpdateProperty
instance O.OverloadedMethodInfo AccessibleUpdatePropertyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleUpdateProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleUpdateProperty"
})
#endif
foreign import ccall "gtk_accessible_update_relation_value" gtk_accessible_update_relation_value ::
Ptr Accessible ->
Int32 ->
Ptr CUInt ->
Ptr B.GValue.GValue ->
IO ()
accessibleUpdateRelation ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> [Gtk.Enums.AccessibleRelation]
-> [GValue]
-> m ()
accessibleUpdateRelation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> [AccessibleRelation] -> [GValue] -> m ()
accessibleUpdateRelation a
self [AccessibleRelation]
relations [GValue]
values = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nRelations :: Int32
nRelations = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
let relations_expected_length_ :: Int32
relations_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [AccessibleRelation] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [AccessibleRelation]
relations
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
relations_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nRelations) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
String -> IO ()
forall a. HasCallStack => String -> a
error String
"Gtk.accessibleUpdateRelation : length of 'relations' does not agree with that of 'values'."
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let relations' :: [CUInt]
relations' = (AccessibleRelation -> CUInt) -> [AccessibleRelation] -> [CUInt]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleRelation -> Int) -> AccessibleRelation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleRelation -> Int
forall a. Enum a => a -> Int
fromEnum) [AccessibleRelation]
relations
Ptr CUInt
relations'' <- [CUInt] -> IO (Ptr CUInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CUInt]
relations'
Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
Ptr Accessible -> Int32 -> Ptr CUInt -> Ptr GValue -> IO ()
gtk_accessible_update_relation_value Ptr Accessible
self' Int32
nRelations Ptr CUInt
relations'' Ptr GValue
values'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
(GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
relations''
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleUpdateRelationMethodInfo
instance (signature ~ ([Gtk.Enums.AccessibleRelation] -> [GValue] -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleUpdateRelationMethodInfo a signature where
overloadedMethod = accessibleUpdateRelation
instance O.OverloadedMethodInfo AccessibleUpdateRelationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleUpdateRelation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleUpdateRelation"
})
#endif
foreign import ccall "gtk_accessible_update_state_value" gtk_accessible_update_state_value ::
Ptr Accessible ->
Int32 ->
Ptr CUInt ->
Ptr B.GValue.GValue ->
IO ()
accessibleUpdateState ::
(B.CallStack.HasCallStack, MonadIO m, IsAccessible a) =>
a
-> [Gtk.Enums.AccessibleState]
-> [GValue]
-> m ()
accessibleUpdateState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAccessible a) =>
a -> [AccessibleState] -> [GValue] -> m ()
accessibleUpdateState a
self [AccessibleState]
states [GValue]
values = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nStates :: Int32
nStates = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
let states_expected_length_ :: Int32
states_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [AccessibleState] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [AccessibleState]
states
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
states_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nStates) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
String -> IO ()
forall a. HasCallStack => String -> a
error String
"Gtk.accessibleUpdateState : length of 'states' does not agree with that of 'values'."
Ptr Accessible
self' <- a -> IO (Ptr Accessible)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
let states' :: [CUInt]
states' = (AccessibleState -> CUInt) -> [AccessibleState] -> [CUInt]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleState -> Int) -> AccessibleState -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleState -> Int
forall a. Enum a => a -> Int
fromEnum) [AccessibleState]
states
Ptr CUInt
states'' <- [CUInt] -> IO (Ptr CUInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CUInt]
states'
Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
Ptr Accessible -> Int32 -> Ptr CUInt -> Ptr GValue -> IO ()
gtk_accessible_update_state_value Ptr Accessible
self' Int32
nStates Ptr CUInt
states'' Ptr GValue
values'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
(GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
states''
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AccessibleUpdateStateMethodInfo
instance (signature ~ ([Gtk.Enums.AccessibleState] -> [GValue] -> m ()), MonadIO m, IsAccessible a) => O.OverloadedMethod AccessibleUpdateStateMethodInfo a signature where
overloadedMethod = accessibleUpdateState
instance O.OverloadedMethodInfo AccessibleUpdateStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Accessible.accessibleUpdateState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Interfaces-Accessible.html#v:accessibleUpdateState"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Accessible = AccessibleSignalList
type AccessibleSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif