{-# LANGUAGE TypeApplications #-} -- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte -- License : LGPL-2.1 -- Maintainer : Iñaki García Etxebarria -- -- An AtkStateSet is a read-only representation of the full set of @/AtkStates/@ -- that apply to an object at a given time. This set is not meant to be -- modified, but rather created when @/atk_object_ref_state_set/@() is called. #if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) #define ENABLE_OVERLOADING #endif module GI.Atk.Objects.StateSet ( -- * Exported types StateSet(..) , IsStateSet , toStateSet , noStateSet , -- * Methods -- ** Overloaded methods #method:Overloaded methods# #if defined(ENABLE_OVERLOADING) ResolveStateSetMethod , #endif -- ** addState #method:addState# #if defined(ENABLE_OVERLOADING) StateSetAddStateMethodInfo , #endif stateSetAddState , -- ** addStates #method:addStates# #if defined(ENABLE_OVERLOADING) StateSetAddStatesMethodInfo , #endif stateSetAddStates , -- ** andSets #method:andSets# #if defined(ENABLE_OVERLOADING) StateSetAndSetsMethodInfo , #endif stateSetAndSets , -- ** clearStates #method:clearStates# #if defined(ENABLE_OVERLOADING) StateSetClearStatesMethodInfo , #endif stateSetClearStates , -- ** containsState #method:containsState# #if defined(ENABLE_OVERLOADING) StateSetContainsStateMethodInfo , #endif stateSetContainsState , -- ** containsStates #method:containsStates# #if defined(ENABLE_OVERLOADING) StateSetContainsStatesMethodInfo , #endif stateSetContainsStates , -- ** isEmpty #method:isEmpty# #if defined(ENABLE_OVERLOADING) StateSetIsEmptyMethodInfo , #endif stateSetIsEmpty , -- ** new #method:new# stateSetNew , -- ** orSets #method:orSets# #if defined(ENABLE_OVERLOADING) StateSetOrSetsMethodInfo , #endif stateSetOrSets , -- ** removeState #method:removeState# #if defined(ENABLE_OVERLOADING) StateSetRemoveStateMethodInfo , #endif stateSetRemoveState , -- ** xorSets #method:xorSets# #if defined(ENABLE_OVERLOADING) StateSetXorSetsMethodInfo , #endif stateSetXorSets , ) 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.GI.Base.Signals as B.Signals 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 qualified GI.GObject.Objects.Object as GObject.Object -- | Memory-managed wrapper type. newtype StateSet = StateSet (ManagedPtr StateSet) deriving (Eq) foreign import ccall "atk_state_set_get_type" c_atk_state_set_get_type :: IO GType instance GObject StateSet where gobjectType = c_atk_state_set_get_type -- | Convert 'StateSet' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. instance B.GValue.IsGValue StateSet where toGValue o = do gtype <- c_atk_state_set_get_type B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object) fromGValue gv = do ptr <- B.GValue.get_object gv :: IO (Ptr StateSet) B.ManagedPtr.newObject StateSet ptr -- | Type class for types which can be safely cast to `StateSet`, for instance with `toStateSet`. class (GObject o, O.IsDescendantOf StateSet o) => IsStateSet o instance (GObject o, O.IsDescendantOf StateSet o) => IsStateSet o instance O.HasParentTypes StateSet type instance O.ParentTypes StateSet = '[GObject.Object.Object] -- | Cast to `StateSet`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toStateSet :: (MonadIO m, IsStateSet o) => o -> m StateSet toStateSet = liftIO . unsafeCastTo StateSet -- | A convenience alias for `Nothing` :: `Maybe` `StateSet`. noStateSet :: Maybe StateSet noStateSet = Nothing #if defined(ENABLE_OVERLOADING) type family ResolveStateSetMethod (t :: Symbol) (o :: *) :: * where ResolveStateSetMethod "addState" o = StateSetAddStateMethodInfo ResolveStateSetMethod "addStates" o = StateSetAddStatesMethodInfo ResolveStateSetMethod "andSets" o = StateSetAndSetsMethodInfo ResolveStateSetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveStateSetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveStateSetMethod "clearStates" o = StateSetClearStatesMethodInfo ResolveStateSetMethod "containsState" o = StateSetContainsStateMethodInfo ResolveStateSetMethod "containsStates" o = StateSetContainsStatesMethodInfo ResolveStateSetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveStateSetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveStateSetMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveStateSetMethod "isEmpty" o = StateSetIsEmptyMethodInfo ResolveStateSetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveStateSetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveStateSetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveStateSetMethod "orSets" o = StateSetOrSetsMethodInfo ResolveStateSetMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveStateSetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveStateSetMethod "removeState" o = StateSetRemoveStateMethodInfo ResolveStateSetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveStateSetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveStateSetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveStateSetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveStateSetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveStateSetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveStateSetMethod "xorSets" o = StateSetXorSetsMethodInfo ResolveStateSetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveStateSetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveStateSetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveStateSetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveStateSetMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo ResolveStateSetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveStateSetMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveStateSetMethod t StateSet, O.MethodInfo info StateSet p) => OL.IsLabel t (StateSet -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod @info #else fromLabel _ = O.overloadedMethod @info #endif #endif #if defined(ENABLE_OVERLOADING) instance O.HasAttributeList StateSet type instance O.AttributeList StateSet = StateSetAttributeList type StateSetAttributeList = ('[ ] :: [(Symbol, *)]) #endif #if defined(ENABLE_OVERLOADING) #endif #if defined(ENABLE_OVERLOADING) type instance O.SignalList StateSet = StateSetSignalList type StateSetSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method StateSet::new -- method type : Constructor -- Args: [] -- Lengths: [] -- returnType: Just (TInterface Name { namespace = "Atk" , name = "StateSet" }) -- throws : False -- Skip return : False foreign import ccall "atk_state_set_new" atk_state_set_new :: IO (Ptr StateSet) -- | Creates a new empty state set. stateSetNew :: (B.CallStack.HasCallStack, MonadIO m) => m StateSet -- ^ __Returns:__ a new t'GI.Atk.Objects.StateSet.StateSet' stateSetNew = liftIO $ do result <- atk_state_set_new checkUnexpectedReturnNULL "stateSetNew" result result' <- (wrapObject StateSet) result return result' #if defined(ENABLE_OVERLOADING) #endif -- method StateSet::add_state -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "type" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateType" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateType" , 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_state_set_add_state" atk_state_set_add_state :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) CUInt -> -- type : TInterface (Name {namespace = "Atk", name = "StateType"}) IO CInt -- | Adds the state of the specified type to the state set if it is not already -- present. -- -- Note that because an t'GI.Atk.Objects.StateSet.StateSet' is a read-only object, this method should -- be used to add a state to a newly-created set which will then be returned by -- @/atk_object_ref_state_set/@. It should not be used to modify the existing state -- of an object. See also @/atk_object_notify_state_change/@. stateSetAddState :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> Atk.Enums.StateType -- ^ /@type@/: an t'GI.Atk.Enums.StateType' -> m Bool -- ^ __Returns:__ 'P.True' if the state for /@type@/ is not already in /@set@/. stateSetAddState set type_ = liftIO $ do set' <- unsafeManagedPtrCastPtr set let type_' = (fromIntegral . fromEnum) type_ result <- atk_state_set_add_state set' type_' let result' = (/= 0) result touchManagedPtr set return result' #if defined(ENABLE_OVERLOADING) data StateSetAddStateMethodInfo instance (signature ~ (Atk.Enums.StateType -> m Bool), MonadIO m, IsStateSet a) => O.MethodInfo StateSetAddStateMethodInfo a signature where overloadedMethod = stateSetAddState #endif -- method StateSet::add_states -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "types" -- , argType = -- TCArray -- False -- (-1) -- 2 -- (TInterface Name { namespace = "Atk" , name = "StateType" }) -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an array of #AtkStateType" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "n_types" -- , argType = TBasicType TInt -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "The number of elements in the array" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [ Arg -- { argCName = "n_types" -- , argType = TBasicType TInt -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "The number of elements in the array" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- returnType: Nothing -- throws : False -- Skip return : False foreign import ccall "atk_state_set_add_states" atk_state_set_add_states :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) Ptr CUInt -> -- types : TCArray False (-1) 2 (TInterface (Name {namespace = "Atk", name = "StateType"})) Int32 -> -- n_types : TBasicType TInt IO () -- | Adds the states of the specified types to the state set. -- -- Note that because an t'GI.Atk.Objects.StateSet.StateSet' is a read-only object, this method should -- be used to add states to a newly-created set which will then be returned by -- @/atk_object_ref_state_set/@. It should not be used to modify the existing state -- of an object. See also @/atk_object_notify_state_change/@. stateSetAddStates :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> [Atk.Enums.StateType] -- ^ /@types@/: an array of t'GI.Atk.Enums.StateType' -> m () stateSetAddStates set types = liftIO $ do let nTypes = fromIntegral $ length types set' <- unsafeManagedPtrCastPtr set let types' = map (fromIntegral . fromEnum) types types'' <- packStorableArray types' atk_state_set_add_states set' types'' nTypes touchManagedPtr set freeMem types'' return () #if defined(ENABLE_OVERLOADING) data StateSetAddStatesMethodInfo instance (signature ~ ([Atk.Enums.StateType] -> m ()), MonadIO m, IsStateSet a) => O.MethodInfo StateSetAddStatesMethodInfo a signature where overloadedMethod = stateSetAddStates #endif -- method StateSet::and_sets -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "compare_set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "another #AtkStateSet" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [] -- returnType: Just (TInterface Name { namespace = "Atk" , name = "StateSet" }) -- throws : False -- Skip return : False foreign import ccall "atk_state_set_and_sets" atk_state_set_and_sets :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) Ptr StateSet -> -- compare_set : TInterface (Name {namespace = "Atk", name = "StateSet"}) IO (Ptr StateSet) -- | Constructs the intersection of the two sets, returning 'P.Nothing' if the -- intersection is empty. stateSetAndSets :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a, IsStateSet b) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> b -- ^ /@compareSet@/: another t'GI.Atk.Objects.StateSet.StateSet' -> m StateSet -- ^ __Returns:__ a new t'GI.Atk.Objects.StateSet.StateSet' which is the intersection of -- the two sets. stateSetAndSets set compareSet = liftIO $ do set' <- unsafeManagedPtrCastPtr set compareSet' <- unsafeManagedPtrCastPtr compareSet result <- atk_state_set_and_sets set' compareSet' checkUnexpectedReturnNULL "stateSetAndSets" result result' <- (wrapObject StateSet) result touchManagedPtr set touchManagedPtr compareSet return result' #if defined(ENABLE_OVERLOADING) data StateSetAndSetsMethodInfo instance (signature ~ (b -> m StateSet), MonadIO m, IsStateSet a, IsStateSet b) => O.MethodInfo StateSetAndSetsMethodInfo a signature where overloadedMethod = stateSetAndSets #endif -- method StateSet::clear_states -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [] -- returnType: Nothing -- throws : False -- Skip return : False foreign import ccall "atk_state_set_clear_states" atk_state_set_clear_states :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) IO () -- | Removes all states from the state set. stateSetClearStates :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> m () stateSetClearStates set = liftIO $ do set' <- unsafeManagedPtrCastPtr set atk_state_set_clear_states set' touchManagedPtr set return () #if defined(ENABLE_OVERLOADING) data StateSetClearStatesMethodInfo instance (signature ~ (m ()), MonadIO m, IsStateSet a) => O.MethodInfo StateSetClearStatesMethodInfo a signature where overloadedMethod = stateSetClearStates #endif -- method StateSet::contains_state -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "type" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateType" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateType" , 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_state_set_contains_state" atk_state_set_contains_state :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) CUInt -> -- type : TInterface (Name {namespace = "Atk", name = "StateType"}) IO CInt -- | Checks whether the state for the specified type is in the specified set. stateSetContainsState :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> Atk.Enums.StateType -- ^ /@type@/: an t'GI.Atk.Enums.StateType' -> m Bool -- ^ __Returns:__ 'P.True' if /@type@/ is the state type is in /@set@/. stateSetContainsState set type_ = liftIO $ do set' <- unsafeManagedPtrCastPtr set let type_' = (fromIntegral . fromEnum) type_ result <- atk_state_set_contains_state set' type_' let result' = (/= 0) result touchManagedPtr set return result' #if defined(ENABLE_OVERLOADING) data StateSetContainsStateMethodInfo instance (signature ~ (Atk.Enums.StateType -> m Bool), MonadIO m, IsStateSet a) => O.MethodInfo StateSetContainsStateMethodInfo a signature where overloadedMethod = stateSetContainsState #endif -- method StateSet::contains_states -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "types" -- , argType = -- TCArray -- False -- (-1) -- 2 -- (TInterface Name { namespace = "Atk" , name = "StateType" }) -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an array of #AtkStateType" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "n_types" -- , argType = TBasicType TInt -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "The number of elements in the array" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [ Arg -- { argCName = "n_types" -- , argType = TBasicType TInt -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "The number of elements in the array" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- returnType: Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_state_set_contains_states" atk_state_set_contains_states :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) Ptr CUInt -> -- types : TCArray False (-1) 2 (TInterface (Name {namespace = "Atk", name = "StateType"})) Int32 -> -- n_types : TBasicType TInt IO CInt -- | Checks whether the states for all the specified types are in the -- specified set. stateSetContainsStates :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> [Atk.Enums.StateType] -- ^ /@types@/: an array of t'GI.Atk.Enums.StateType' -> m Bool -- ^ __Returns:__ 'P.True' if all the states for /@type@/ are in /@set@/. stateSetContainsStates set types = liftIO $ do let nTypes = fromIntegral $ length types set' <- unsafeManagedPtrCastPtr set let types' = map (fromIntegral . fromEnum) types types'' <- packStorableArray types' result <- atk_state_set_contains_states set' types'' nTypes let result' = (/= 0) result touchManagedPtr set freeMem types'' return result' #if defined(ENABLE_OVERLOADING) data StateSetContainsStatesMethodInfo instance (signature ~ ([Atk.Enums.StateType] -> m Bool), MonadIO m, IsStateSet a) => O.MethodInfo StateSetContainsStatesMethodInfo a signature where overloadedMethod = stateSetContainsStates #endif -- method StateSet::is_empty -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateType" , 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_state_set_is_empty" atk_state_set_is_empty :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) IO CInt -- | Checks whether the state set is empty, i.e. has no states set. stateSetIsEmpty :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Enums.StateType' -> m Bool -- ^ __Returns:__ 'P.True' if /@set@/ has no states set, otherwise 'P.False' stateSetIsEmpty set = liftIO $ do set' <- unsafeManagedPtrCastPtr set result <- atk_state_set_is_empty set' let result' = (/= 0) result touchManagedPtr set return result' #if defined(ENABLE_OVERLOADING) data StateSetIsEmptyMethodInfo instance (signature ~ (m Bool), MonadIO m, IsStateSet a) => O.MethodInfo StateSetIsEmptyMethodInfo a signature where overloadedMethod = stateSetIsEmpty #endif -- method StateSet::or_sets -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "compare_set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "another #AtkStateSet" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [] -- returnType: Just (TInterface Name { namespace = "Atk" , name = "StateSet" }) -- throws : False -- Skip return : False foreign import ccall "atk_state_set_or_sets" atk_state_set_or_sets :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) Ptr StateSet -> -- compare_set : TInterface (Name {namespace = "Atk", name = "StateSet"}) IO (Ptr StateSet) -- | Constructs the union of the two sets. stateSetOrSets :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a, IsStateSet b) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> b -- ^ /@compareSet@/: another t'GI.Atk.Objects.StateSet.StateSet' -> m (Maybe StateSet) -- ^ __Returns:__ a new t'GI.Atk.Objects.StateSet.StateSet' which is -- the union of the two sets, returning 'P.Nothing' is empty. stateSetOrSets set compareSet = liftIO $ do set' <- unsafeManagedPtrCastPtr set compareSet' <- unsafeManagedPtrCastPtr compareSet result <- atk_state_set_or_sets set' compareSet' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject StateSet) result' return result'' touchManagedPtr set touchManagedPtr compareSet return maybeResult #if defined(ENABLE_OVERLOADING) data StateSetOrSetsMethodInfo instance (signature ~ (b -> m (Maybe StateSet)), MonadIO m, IsStateSet a, IsStateSet b) => O.MethodInfo StateSetOrSetsMethodInfo a signature where overloadedMethod = stateSetOrSets #endif -- method StateSet::remove_state -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "type" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateType" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkType" , 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_state_set_remove_state" atk_state_set_remove_state :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) CUInt -> -- type : TInterface (Name {namespace = "Atk", name = "StateType"}) IO CInt -- | Removes the state for the specified type from the state set. -- -- Note that because an t'GI.Atk.Objects.StateSet.StateSet' is a read-only object, this method should -- be used to remove a state to a newly-created set which will then be returned -- by @/atk_object_ref_state_set/@. It should not be used to modify the existing -- state of an object. See also @/atk_object_notify_state_change/@. stateSetRemoveState :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> Atk.Enums.StateType -- ^ /@type@/: an @/AtkType/@ -> m Bool -- ^ __Returns:__ 'P.True' if /@type@/ was the state type is in /@set@/. stateSetRemoveState set type_ = liftIO $ do set' <- unsafeManagedPtrCastPtr set let type_' = (fromIntegral . fromEnum) type_ result <- atk_state_set_remove_state set' type_' let result' = (/= 0) result touchManagedPtr set return result' #if defined(ENABLE_OVERLOADING) data StateSetRemoveStateMethodInfo instance (signature ~ (Atk.Enums.StateType -> m Bool), MonadIO m, IsStateSet a) => O.MethodInfo StateSetRemoveStateMethodInfo a signature where overloadedMethod = stateSetRemoveState #endif -- method StateSet::xor_sets -- method type : OrdinaryMethod -- Args: [ Arg -- { argCName = "set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "an #AtkStateSet" , sinceVersion = Nothing } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- , Arg -- { argCName = "compare_set" -- , argType = -- TInterface Name { namespace = "Atk" , name = "StateSet" } -- , direction = DirectionIn -- , mayBeNull = False -- , argDoc = -- Documentation -- { rawDocText = Just "another #AtkStateSet" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [] -- returnType: Just (TInterface Name { namespace = "Atk" , name = "StateSet" }) -- throws : False -- Skip return : False foreign import ccall "atk_state_set_xor_sets" atk_state_set_xor_sets :: Ptr StateSet -> -- set : TInterface (Name {namespace = "Atk", name = "StateSet"}) Ptr StateSet -> -- compare_set : TInterface (Name {namespace = "Atk", name = "StateSet"}) IO (Ptr StateSet) -- | Constructs the exclusive-or of the two sets, returning 'P.Nothing' is empty. -- The set returned by this operation contains the states in exactly -- one of the two sets. stateSetXorSets :: (B.CallStack.HasCallStack, MonadIO m, IsStateSet a, IsStateSet b) => a -- ^ /@set@/: an t'GI.Atk.Objects.StateSet.StateSet' -> b -- ^ /@compareSet@/: another t'GI.Atk.Objects.StateSet.StateSet' -> m StateSet -- ^ __Returns:__ a new t'GI.Atk.Objects.StateSet.StateSet' which contains the states -- which are in exactly one of the two sets. stateSetXorSets set compareSet = liftIO $ do set' <- unsafeManagedPtrCastPtr set compareSet' <- unsafeManagedPtrCastPtr compareSet result <- atk_state_set_xor_sets set' compareSet' checkUnexpectedReturnNULL "stateSetXorSets" result result' <- (wrapObject StateSet) result touchManagedPtr set touchManagedPtr compareSet return result' #if defined(ENABLE_OVERLOADING) data StateSetXorSetsMethodInfo instance (signature ~ (b -> m StateSet), MonadIO m, IsStateSet a, IsStateSet b) => O.MethodInfo StateSetXorSetsMethodInfo a signature where overloadedMethod = stateSetXorSets #endif