#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Atk.Interfaces.Action
(
Action(..) ,
noAction ,
IsAction ,
#if ENABLE_OVERLOADING
ActionDoActionMethodInfo ,
#endif
actionDoAction ,
#if ENABLE_OVERLOADING
ActionGetDescriptionMethodInfo ,
#endif
actionGetDescription ,
#if ENABLE_OVERLOADING
ActionGetKeybindingMethodInfo ,
#endif
actionGetKeybinding ,
#if ENABLE_OVERLOADING
ActionGetLocalizedNameMethodInfo ,
#endif
actionGetLocalizedName ,
#if ENABLE_OVERLOADING
ActionGetNActionsMethodInfo ,
#endif
actionGetNActions ,
#if ENABLE_OVERLOADING
ActionGetNameMethodInfo ,
#endif
actionGetName ,
#if ENABLE_OVERLOADING
ActionSetDescriptionMethodInfo ,
#endif
actionSetDescription ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
newtype Action = Action (ManagedPtr Action)
noAction :: Maybe Action
noAction :: Maybe Action
noAction = Maybe Action
forall a. Maybe a
Nothing
#if ENABLE_OVERLOADING
type instance O.SignalList Action = ActionSignalList
type ActionSignalList = ('[ ] :: [(Symbol, *)])
#endif
class ManagedPtrNewtype a => IsAction a
instance IsAction Action
instance WrappedPtr Action where
wrappedPtrCalloc :: IO (Ptr Action)
wrappedPtrCalloc = Ptr Action -> IO (Ptr Action)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Action
forall a. Ptr a
nullPtr
wrappedPtrCopy :: Action -> IO Action
wrappedPtrCopy = Action -> IO Action
forall (m :: * -> *) a. Monad m => a -> m a
return
wrappedPtrFree :: Maybe (FunPtr (Ptr Action -> IO ()))
wrappedPtrFree = Maybe (FunPtr (Ptr Action -> IO ()))
forall a. Maybe a
Nothing
#if ENABLE_OVERLOADING
type family ResolveActionMethod (t :: Symbol) (o :: *) :: * where
ResolveActionMethod "doAction" o = ActionDoActionMethodInfo
ResolveActionMethod "getDescription" o = ActionGetDescriptionMethodInfo
ResolveActionMethod "getKeybinding" o = ActionGetKeybindingMethodInfo
ResolveActionMethod "getLocalizedName" o = ActionGetLocalizedNameMethodInfo
ResolveActionMethod "getNActions" o = ActionGetNActionsMethodInfo
ResolveActionMethod "getName" o = ActionGetNameMethodInfo
ResolveActionMethod "setDescription" o = ActionSetDescriptionMethodInfo
ResolveActionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => O.IsLabelProxy t (Action -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => O.IsLabel t (Action -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif
foreign import ccall "atk_action_do_action" atk_action_do_action ::
Ptr Action ->
Int32 ->
IO CInt
actionDoAction ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> m Bool
actionDoAction :: a -> Int32 -> m Bool
actionDoAction action :: a
action i :: Int32
i = IO Bool -> m Bool
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 Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CInt
result <- Ptr Action -> Int32 -> IO CInt
atk_action_do_action Ptr Action
action' Int32
i
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if ENABLE_OVERLOADING
data ActionDoActionMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionDoActionMethodInfo a signature where
overloadedMethod _ = actionDoAction
#endif
foreign import ccall "atk_action_get_description" atk_action_get_description ::
Ptr Action ->
Int32 ->
IO CString
actionGetDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> m (Maybe T.Text)
actionGetDescription :: a -> Int32 -> m (Maybe Text)
actionGetDescription action :: a
action i :: Int32
i = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CString
result <- Ptr Action -> Int32 -> IO CString
atk_action_get_description Ptr Action
action' Int32
i
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if ENABLE_OVERLOADING
data ActionGetDescriptionMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetDescriptionMethodInfo a signature where
overloadedMethod _ = actionGetDescription
#endif
foreign import ccall "atk_action_get_keybinding" atk_action_get_keybinding ::
Ptr Action ->
Int32 ->
IO CString
actionGetKeybinding ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> m (Maybe T.Text)
actionGetKeybinding :: a -> Int32 -> m (Maybe Text)
actionGetKeybinding action :: a
action i :: Int32
i = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CString
result <- Ptr Action -> Int32 -> IO CString
atk_action_get_keybinding Ptr Action
action' Int32
i
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if ENABLE_OVERLOADING
data ActionGetKeybindingMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetKeybindingMethodInfo a signature where
overloadedMethod _ = actionGetKeybinding
#endif
foreign import ccall "atk_action_get_localized_name" atk_action_get_localized_name ::
Ptr Action ->
Int32 ->
IO CString
actionGetLocalizedName ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> m (Maybe T.Text)
actionGetLocalizedName :: a -> Int32 -> m (Maybe Text)
actionGetLocalizedName action :: a
action i :: Int32
i = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CString
result <- Ptr Action -> Int32 -> IO CString
atk_action_get_localized_name Ptr Action
action' Int32
i
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if ENABLE_OVERLOADING
data ActionGetLocalizedNameMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetLocalizedNameMethodInfo a signature where
overloadedMethod _ = actionGetLocalizedName
#endif
foreign import ccall "atk_action_get_n_actions" atk_action_get_n_actions ::
Ptr Action ->
IO Int32
actionGetNActions ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> m Int32
actionGetNActions :: a -> m Int32
actionGetNActions action :: a
action = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
Int32
result <- Ptr Action -> IO Int32
atk_action_get_n_actions Ptr Action
action'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if ENABLE_OVERLOADING
data ActionGetNActionsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAction a) => O.MethodInfo ActionGetNActionsMethodInfo a signature where
overloadedMethod _ = actionGetNActions
#endif
foreign import ccall "atk_action_get_name" atk_action_get_name ::
Ptr Action ->
Int32 ->
IO CString
actionGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> m (Maybe T.Text)
actionGetName :: a -> Int32 -> m (Maybe Text)
actionGetName action :: a
action i :: Int32
i = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CString
result <- Ptr Action -> Int32 -> IO CString
atk_action_get_name Ptr Action
action' Int32
i
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if ENABLE_OVERLOADING
data ActionGetNameMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsAction a) => O.MethodInfo ActionGetNameMethodInfo a signature where
overloadedMethod _ = actionGetName
#endif
foreign import ccall "atk_action_set_description" atk_action_set_description ::
Ptr Action ->
Int32 ->
CString ->
IO CInt
actionSetDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
a
-> Int32
-> T.Text
-> m Bool
actionSetDescription :: a -> Int32 -> Text -> m Bool
actionSetDescription action :: a
action i :: Int32
i desc :: Text
desc = IO Bool -> m Bool
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 Action
action' <- a -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
CString
desc' <- Text -> IO CString
textToCString Text
desc
CInt
result <- Ptr Action -> Int32 -> CString -> IO CInt
atk_action_set_description Ptr Action
action' Int32
i CString
desc'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
desc'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if ENABLE_OVERLOADING
data ActionSetDescriptionMethodInfo
instance (signature ~ (Int32 -> T.Text -> m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionSetDescriptionMethodInfo a signature where
overloadedMethod _ = actionSetDescription
#endif