{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Objects.Relation
(
Relation(..) ,
IsRelation ,
toRelation ,
#if defined(ENABLE_OVERLOADING)
ResolveRelationMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RelationAddTargetMethodInfo ,
#endif
relationAddTarget ,
#if defined(ENABLE_OVERLOADING)
RelationGetRelationTypeMethodInfo ,
#endif
relationGetRelationType ,
#if defined(ENABLE_OVERLOADING)
RelationGetTargetMethodInfo ,
#endif
relationGetTarget ,
relationNew ,
#if defined(ENABLE_OVERLOADING)
RelationRemoveTargetMethodInfo ,
#endif
relationRemoveTarget ,
#if defined(ENABLE_OVERLOADING)
RelationRelationTypePropertyInfo ,
#endif
constructRelationRelationType ,
getRelationRelationType ,
#if defined(ENABLE_OVERLOADING)
relationRelationType ,
#endif
setRelationRelationType ,
#if defined(ENABLE_OVERLOADING)
RelationTargetPropertyInfo ,
#endif
clearRelationTarget ,
constructRelationTarget ,
getRelationTarget ,
#if defined(ENABLE_OVERLOADING)
relationTarget ,
#endif
setRelationTarget ,
) 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 {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray
newtype Relation = Relation (SP.ManagedPtr Relation)
deriving (Relation -> Relation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Relation -> Relation -> Bool
$c/= :: Relation -> Relation -> Bool
== :: Relation -> Relation -> Bool
$c== :: Relation -> Relation -> Bool
Eq)
instance SP.ManagedPtrNewtype Relation where
toManagedPtr :: Relation -> ManagedPtr Relation
toManagedPtr (Relation ManagedPtr Relation
p) = ManagedPtr Relation
p
foreign import ccall "atk_relation_get_type"
c_atk_relation_get_type :: IO B.Types.GType
instance B.Types.TypedObject Relation where
glibType :: IO GType
glibType = IO GType
c_atk_relation_get_type
instance B.Types.GObject Relation
class (SP.GObject o, O.IsDescendantOf Relation o) => IsRelation o
instance (SP.GObject o, O.IsDescendantOf Relation o) => IsRelation o
instance O.HasParentTypes Relation
type instance O.ParentTypes Relation = '[GObject.Object.Object]
toRelation :: (MIO.MonadIO m, IsRelation o) => o -> m Relation
toRelation :: forall (m :: * -> *) o.
(MonadIO m, IsRelation o) =>
o -> m Relation
toRelation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Relation -> Relation
Relation
instance B.GValue.IsGValue (Maybe Relation) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_relation_get_type
gvalueSet_ :: Ptr GValue -> Maybe Relation -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Relation
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Relation)
gvalueSet_ Ptr GValue
gv (P.Just Relation
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Relation
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Relation)
gvalueGet_ Ptr GValue
gv = do
Ptr Relation
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Relation)
if Ptr Relation
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Relation -> Relation
Relation Ptr Relation
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveRelationMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveRelationMethod "addTarget" o = RelationAddTargetMethodInfo
ResolveRelationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRelationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRelationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRelationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRelationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRelationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRelationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRelationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRelationMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRelationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRelationMethod "removeTarget" o = RelationRemoveTargetMethodInfo
ResolveRelationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRelationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRelationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRelationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRelationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRelationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRelationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRelationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRelationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRelationMethod "getRelationType" o = RelationGetRelationTypeMethodInfo
ResolveRelationMethod "getTarget" o = RelationGetTargetMethodInfo
ResolveRelationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRelationMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRelationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRelationMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRelationMethod t Relation, O.OverloadedMethod info Relation p) => OL.IsLabel t (Relation -> 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 ~ ResolveRelationMethod t Relation, O.OverloadedMethod info Relation p, R.HasField t Relation p) => R.HasField t Relation p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRelationMethod t Relation, O.OverloadedMethodInfo info Relation) => OL.IsLabel t (O.MethodProxy info Relation) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getRelationRelationType :: (MonadIO m, IsRelation o) => o -> m Atk.Enums.RelationType
getRelationRelationType :: forall (m :: * -> *) o.
(MonadIO m, IsRelation o) =>
o -> m RelationType
getRelationRelationType o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"relation-type"
setRelationRelationType :: (MonadIO m, IsRelation o) => o -> Atk.Enums.RelationType -> m ()
setRelationRelationType :: forall (m :: * -> *) o.
(MonadIO m, IsRelation o) =>
o -> RelationType -> m ()
setRelationRelationType o
obj RelationType
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"relation-type" RelationType
val
constructRelationRelationType :: (IsRelation o, MIO.MonadIO m) => Atk.Enums.RelationType -> m (GValueConstruct o)
constructRelationRelationType :: forall o (m :: * -> *).
(IsRelation o, MonadIO m) =>
RelationType -> m (GValueConstruct o)
constructRelationRelationType RelationType
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"relation-type" RelationType
val
#if defined(ENABLE_OVERLOADING)
data RelationRelationTypePropertyInfo
instance AttrInfo RelationRelationTypePropertyInfo where
type AttrAllowedOps RelationRelationTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint RelationRelationTypePropertyInfo = IsRelation
type AttrSetTypeConstraint RelationRelationTypePropertyInfo = (~) Atk.Enums.RelationType
type AttrTransferTypeConstraint RelationRelationTypePropertyInfo = (~) Atk.Enums.RelationType
type AttrTransferType RelationRelationTypePropertyInfo = Atk.Enums.RelationType
type AttrGetType RelationRelationTypePropertyInfo = Atk.Enums.RelationType
type AttrLabel RelationRelationTypePropertyInfo = "relation-type"
type AttrOrigin RelationRelationTypePropertyInfo = Relation
attrGet = getRelationRelationType
attrSet = setRelationRelationType
attrTransfer _ v = do
return v
attrConstruct = constructRelationRelationType
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.relationType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#g:attr:relationType"
})
#endif
getRelationTarget :: (MonadIO m, IsRelation o) => o -> m (Maybe GObject.ValueArray.ValueArray)
getRelationTarget :: forall (m :: * -> *) o.
(MonadIO m, IsRelation o) =>
o -> m (Maybe ValueArray)
getRelationTarget o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"target" ManagedPtr ValueArray -> ValueArray
GObject.ValueArray.ValueArray
setRelationTarget :: (MonadIO m, IsRelation o) => o -> GObject.ValueArray.ValueArray -> m ()
setRelationTarget :: forall (m :: * -> *) o.
(MonadIO m, IsRelation o) =>
o -> ValueArray -> m ()
setRelationTarget o
obj ValueArray
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"target" (forall a. a -> Maybe a
Just ValueArray
val)
constructRelationTarget :: (IsRelation o, MIO.MonadIO m) => GObject.ValueArray.ValueArray -> m (GValueConstruct o)
constructRelationTarget :: forall o (m :: * -> *).
(IsRelation o, MonadIO m) =>
ValueArray -> m (GValueConstruct o)
constructRelationTarget ValueArray
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"target" (forall a. a -> Maybe a
P.Just ValueArray
val)
clearRelationTarget :: (MonadIO m, IsRelation o) => o -> m ()
clearRelationTarget :: forall (m :: * -> *) o. (MonadIO m, IsRelation o) => o -> m ()
clearRelationTarget o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"target" (forall a. Maybe a
Nothing :: Maybe GObject.ValueArray.ValueArray)
#if defined(ENABLE_OVERLOADING)
data RelationTargetPropertyInfo
instance AttrInfo RelationTargetPropertyInfo where
type AttrAllowedOps RelationTargetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint RelationTargetPropertyInfo = IsRelation
type AttrSetTypeConstraint RelationTargetPropertyInfo = (~) GObject.ValueArray.ValueArray
type AttrTransferTypeConstraint RelationTargetPropertyInfo = (~) GObject.ValueArray.ValueArray
type AttrTransferType RelationTargetPropertyInfo = GObject.ValueArray.ValueArray
type AttrGetType RelationTargetPropertyInfo = (Maybe GObject.ValueArray.ValueArray)
type AttrLabel RelationTargetPropertyInfo = "target"
type AttrOrigin RelationTargetPropertyInfo = Relation
attrGet = getRelationTarget
attrSet = setRelationTarget
attrTransfer _ v = do
return v
attrConstruct = constructRelationTarget
attrClear = clearRelationTarget
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.target"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#g:attr:target"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Relation
type instance O.AttributeList Relation = RelationAttributeList
type RelationAttributeList = ('[ '("relationType", RelationRelationTypePropertyInfo), '("target", RelationTargetPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
relationRelationType :: AttrLabelProxy "relationType"
relationRelationType = AttrLabelProxy
relationTarget :: AttrLabelProxy "target"
relationTarget = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Relation = RelationSignalList
type RelationSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "atk_relation_new" atk_relation_new ::
Ptr (Ptr Atk.Object.Object) ->
Int32 ->
CUInt ->
IO (Ptr Relation)
relationNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Atk.Object.Object]
-> Atk.Enums.RelationType
-> m Relation
relationNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Object] -> RelationType -> m Relation
relationNew [Object]
targets RelationType
relationship = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let nTargets :: Int32
nTargets = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Object]
targets
[Ptr Object]
targets' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Object]
targets
Ptr (Ptr Object)
targets'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr Object]
targets'
let relationship' :: CUInt
relationship' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RelationType
relationship
Ptr Relation
result <- Ptr (Ptr Object) -> Int32 -> CUInt -> IO (Ptr Relation)
atk_relation_new Ptr (Ptr Object)
targets'' Int32
nTargets CUInt
relationship'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"relationNew" Ptr Relation
result
Relation
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Relation -> Relation
Relation) Ptr Relation
result
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Object]
targets
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
targets''
forall (m :: * -> *) a. Monad m => a -> m a
return Relation
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "atk_relation_add_target" atk_relation_add_target ::
Ptr Relation ->
Ptr Atk.Object.Object ->
IO ()
relationAddTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRelation a, Atk.Object.IsObject b) =>
a
-> b
-> m ()
relationAddTarget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRelation a, IsObject b) =>
a -> b -> m ()
relationAddTarget a
relation b
target = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Relation
relation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
relation
Ptr Object
target' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
target
Ptr Relation -> Ptr Object -> IO ()
atk_relation_add_target Ptr Relation
relation' Ptr Object
target'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
relation
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
target
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RelationAddTargetMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsRelation a, Atk.Object.IsObject b) => O.OverloadedMethod RelationAddTargetMethodInfo a signature where
overloadedMethod = relationAddTarget
instance O.OverloadedMethodInfo RelationAddTargetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.relationAddTarget",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#v:relationAddTarget"
})
#endif
foreign import ccall "atk_relation_get_relation_type" atk_relation_get_relation_type ::
Ptr Relation ->
IO CUInt
relationGetRelationType ::
(B.CallStack.HasCallStack, MonadIO m, IsRelation a) =>
a
-> m Atk.Enums.RelationType
relationGetRelationType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRelation a) =>
a -> m RelationType
relationGetRelationType a
relation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Relation
relation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
relation
CUInt
result <- Ptr Relation -> IO CUInt
atk_relation_get_relation_type Ptr Relation
relation'
let result' :: RelationType
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
relation
forall (m :: * -> *) a. Monad m => a -> m a
return RelationType
result'
#if defined(ENABLE_OVERLOADING)
data RelationGetRelationTypeMethodInfo
instance (signature ~ (m Atk.Enums.RelationType), MonadIO m, IsRelation a) => O.OverloadedMethod RelationGetRelationTypeMethodInfo a signature where
overloadedMethod = relationGetRelationType
instance O.OverloadedMethodInfo RelationGetRelationTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.relationGetRelationType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#v:relationGetRelationType"
})
#endif
foreign import ccall "atk_relation_get_target" atk_relation_get_target ::
Ptr Relation ->
IO (Ptr (GPtrArray (Ptr Atk.Object.Object)))
relationGetTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRelation a) =>
a
-> m [Atk.Object.Object]
relationGetTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRelation a) =>
a -> m [Object]
relationGetTarget a
relation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Relation
relation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
relation
Ptr (GPtrArray (Ptr Object))
result <- Ptr Relation -> IO (Ptr (GPtrArray (Ptr Object)))
atk_relation_get_target Ptr Relation
relation'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"relationGetTarget" Ptr (GPtrArray (Ptr Object))
result
[Ptr Object]
result' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr Object))
result
[Object]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) [Ptr Object]
result'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
relation
forall (m :: * -> *) a. Monad m => a -> m a
return [Object]
result''
#if defined(ENABLE_OVERLOADING)
data RelationGetTargetMethodInfo
instance (signature ~ (m [Atk.Object.Object]), MonadIO m, IsRelation a) => O.OverloadedMethod RelationGetTargetMethodInfo a signature where
overloadedMethod = relationGetTarget
instance O.OverloadedMethodInfo RelationGetTargetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.relationGetTarget",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#v:relationGetTarget"
})
#endif
foreign import ccall "atk_relation_remove_target" atk_relation_remove_target ::
Ptr Relation ->
Ptr Atk.Object.Object ->
IO CInt
relationRemoveTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRelation a, Atk.Object.IsObject b) =>
a
-> b
-> m Bool
relationRemoveTarget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRelation a, IsObject b) =>
a -> b -> m Bool
relationRemoveTarget a
relation b
target = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Relation
relation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
relation
Ptr Object
target' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
target
CInt
result <- Ptr Relation -> Ptr Object -> IO CInt
atk_relation_remove_target Ptr Relation
relation' Ptr Object
target'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
relation
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
target
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RelationRemoveTargetMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsRelation a, Atk.Object.IsObject b) => O.OverloadedMethod RelationRemoveTargetMethodInfo a signature where
overloadedMethod = relationRemoveTarget
instance O.OverloadedMethodInfo RelationRemoveTargetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Objects.Relation.relationRemoveTarget",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Objects-Relation.html#v:relationRemoveTarget"
})
#endif