#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Gio.Objects.SimpleAction
(
SimpleAction(..) ,
IsSimpleAction ,
toSimpleAction ,
noSimpleAction ,
simpleActionNew ,
simpleActionNewStateful ,
#if ENABLE_OVERLOADING
SimpleActionSetEnabledMethodInfo ,
#endif
simpleActionSetEnabled ,
#if ENABLE_OVERLOADING
SimpleActionSetStateMethodInfo ,
#endif
simpleActionSetState ,
#if ENABLE_OVERLOADING
SimpleActionSetStateHintMethodInfo ,
#endif
simpleActionSetStateHint ,
#if ENABLE_OVERLOADING
SimpleActionEnabledPropertyInfo ,
#endif
constructSimpleActionEnabled ,
getSimpleActionEnabled ,
setSimpleActionEnabled ,
#if ENABLE_OVERLOADING
simpleActionEnabled ,
#endif
#if ENABLE_OVERLOADING
SimpleActionNamePropertyInfo ,
#endif
constructSimpleActionName ,
getSimpleActionName ,
#if ENABLE_OVERLOADING
simpleActionName ,
#endif
#if ENABLE_OVERLOADING
SimpleActionParameterTypePropertyInfo ,
#endif
constructSimpleActionParameterType ,
getSimpleActionParameterType ,
#if ENABLE_OVERLOADING
simpleActionParameterType ,
#endif
#if ENABLE_OVERLOADING
SimpleActionStatePropertyInfo ,
#endif
constructSimpleActionState ,
getSimpleActionState ,
setSimpleActionState ,
#if ENABLE_OVERLOADING
simpleActionState ,
#endif
#if ENABLE_OVERLOADING
SimpleActionStateTypePropertyInfo ,
#endif
getSimpleActionStateType ,
#if ENABLE_OVERLOADING
simpleActionStateType ,
#endif
C_SimpleActionActivateCallback ,
SimpleActionActivateCallback ,
#if ENABLE_OVERLOADING
SimpleActionActivateSignalInfo ,
#endif
afterSimpleActionActivate ,
genClosure_SimpleActionActivate ,
mk_SimpleActionActivateCallback ,
noSimpleActionActivateCallback ,
onSimpleActionActivate ,
wrap_SimpleActionActivateCallback ,
C_SimpleActionChangeStateCallback ,
SimpleActionChangeStateCallback ,
#if ENABLE_OVERLOADING
SimpleActionChangeStateSignalInfo ,
#endif
afterSimpleActionChangeState ,
genClosure_SimpleActionChangeState ,
mk_SimpleActionChangeStateCallback ,
noSimpleActionChangeStateCallback ,
onSimpleActionChangeState ,
wrap_SimpleActionChangeStateCallback ,
) 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
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action
newtype SimpleAction = SimpleAction (ManagedPtr SimpleAction)
foreign import ccall "g_simple_action_get_type"
c_g_simple_action_get_type :: IO GType
instance GObject SimpleAction where
gobjectType :: SimpleAction -> IO GType
gobjectType _ = IO GType
c_g_simple_action_get_type
class GObject o => IsSimpleAction o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SimpleAction a) =>
IsSimpleAction a
#endif
instance IsSimpleAction SimpleAction
instance GObject.Object.IsObject SimpleAction
instance Gio.Action.IsAction SimpleAction
toSimpleAction :: (MonadIO m, IsSimpleAction o) => o -> m SimpleAction
toSimpleAction :: o -> m SimpleAction
toSimpleAction = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> (o -> IO SimpleAction) -> o -> m SimpleAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SimpleAction -> SimpleAction) -> o -> IO SimpleAction
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr SimpleAction -> SimpleAction
SimpleAction
noSimpleAction :: Maybe SimpleAction
noSimpleAction :: Maybe SimpleAction
noSimpleAction = Maybe SimpleAction
forall a. Maybe a
Nothing
#if ENABLE_OVERLOADING
type family ResolveSimpleActionMethod (t :: Symbol) (o :: *) :: * where
ResolveSimpleActionMethod "activate" o = Gio.Action.ActionActivateMethodInfo
ResolveSimpleActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSimpleActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSimpleActionMethod "changeState" o = Gio.Action.ActionChangeStateMethodInfo
ResolveSimpleActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSimpleActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSimpleActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSimpleActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSimpleActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSimpleActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSimpleActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSimpleActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSimpleActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSimpleActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSimpleActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSimpleActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSimpleActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSimpleActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSimpleActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSimpleActionMethod "getEnabled" o = Gio.Action.ActionGetEnabledMethodInfo
ResolveSimpleActionMethod "getName" o = Gio.Action.ActionGetNameMethodInfo
ResolveSimpleActionMethod "getParameterType" o = Gio.Action.ActionGetParameterTypeMethodInfo
ResolveSimpleActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSimpleActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSimpleActionMethod "getState" o = Gio.Action.ActionGetStateMethodInfo
ResolveSimpleActionMethod "getStateHint" o = Gio.Action.ActionGetStateHintMethodInfo
ResolveSimpleActionMethod "getStateType" o = Gio.Action.ActionGetStateTypeMethodInfo
ResolveSimpleActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSimpleActionMethod "setEnabled" o = SimpleActionSetEnabledMethodInfo
ResolveSimpleActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSimpleActionMethod "setState" o = SimpleActionSetStateMethodInfo
ResolveSimpleActionMethod "setStateHint" o = SimpleActionSetStateHintMethodInfo
ResolveSimpleActionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSimpleActionMethod t SimpleAction, O.MethodInfo info SimpleAction p) => O.IsLabelProxy t (SimpleAction -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveSimpleActionMethod t SimpleAction, O.MethodInfo info SimpleAction p) => O.IsLabel t (SimpleAction -> 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
type SimpleActionActivateCallback =
Maybe GVariant
-> IO ()
noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionActivateCallback = Maybe SimpleActionActivateCallback
forall a. Maybe a
Nothing
type C_SimpleActionActivateCallback =
Ptr () ->
Ptr GVariant ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SimpleActionActivateCallback :: C_SimpleActionActivateCallback -> IO (FunPtr C_SimpleActionActivateCallback)
genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionActivate cb :: SimpleActionActivateCallback
cb = do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb' IO (FunPtr C_SimpleActionActivateCallback)
-> (FunPtr C_SimpleActionActivateCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SimpleActionActivateCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_SimpleActionActivateCallback ::
SimpleActionActivateCallback ->
C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback _cb :: SimpleActionActivateCallback
_cb _ parameter :: Ptr GVariant
parameter _ = do
Maybe GVariant
maybeParameter <-
if Ptr GVariant
parameter Ptr GVariant -> Ptr GVariant -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GVariant
forall a. Ptr a
nullPtr
then Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
forall a. Maybe a
Nothing
else do
GVariant
parameter' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
parameter
Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GVariant -> IO (Maybe GVariant))
-> Maybe GVariant -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
parameter'
SimpleActionActivateCallback
_cb Maybe GVariant
maybeParameter
onSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionActivate :: a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionActivate obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb'
a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "activate" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectBefore
afterSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionActivate :: a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionActivate obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb'
a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "activate" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectAfter
type SimpleActionChangeStateCallback =
Maybe GVariant
-> IO ()
noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback
noSimpleActionChangeStateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionChangeStateCallback = Maybe SimpleActionActivateCallback
forall a. Maybe a
Nothing
type C_SimpleActionChangeStateCallback =
Ptr () ->
Ptr GVariant ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SimpleActionChangeStateCallback :: C_SimpleActionChangeStateCallback -> IO (FunPtr C_SimpleActionChangeStateCallback)
genClosure_SimpleActionChangeState :: SimpleActionChangeStateCallback -> IO Closure
genClosure_SimpleActionChangeState :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionChangeState cb :: SimpleActionActivateCallback
cb = do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb' IO (FunPtr C_SimpleActionActivateCallback)
-> (FunPtr C_SimpleActionActivateCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SimpleActionActivateCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_SimpleActionChangeStateCallback ::
SimpleActionChangeStateCallback ->
C_SimpleActionChangeStateCallback
wrap_SimpleActionChangeStateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback _cb :: SimpleActionActivateCallback
_cb _ value :: Ptr GVariant
value _ = do
Maybe GVariant
maybeValue <-
if Ptr GVariant
value Ptr GVariant -> Ptr GVariant -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GVariant
forall a. Ptr a
nullPtr
then Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
forall a. Maybe a
Nothing
else do
GVariant
value' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
value
Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GVariant -> IO (Maybe GVariant))
-> Maybe GVariant -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
value'
SimpleActionActivateCallback
_cb Maybe GVariant
maybeValue
onSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
onSimpleActionChangeState :: a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionChangeState obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb'
a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "change-state" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectBefore
afterSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
afterSimpleActionChangeState :: a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionChangeState obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb'
a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "change-state" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectAfter
getSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> m Bool
getSimpleActionEnabled :: o -> m Bool
getSimpleActionEnabled obj :: o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "enabled"
setSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> Bool -> m ()
setSimpleActionEnabled :: o -> Bool -> m ()
setSimpleActionEnabled obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
setObjectPropertyBool o
obj "enabled" Bool
val
constructSimpleActionEnabled :: (IsSimpleAction o) => Bool -> IO (GValueConstruct o)
constructSimpleActionEnabled :: Bool -> IO (GValueConstruct o)
constructSimpleActionEnabled val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "enabled" Bool
val
#if ENABLE_OVERLOADING
data SimpleActionEnabledPropertyInfo
instance AttrInfo SimpleActionEnabledPropertyInfo where
type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool
type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = IsSimpleAction
type AttrGetType SimpleActionEnabledPropertyInfo = Bool
type AttrLabel SimpleActionEnabledPropertyInfo = "enabled"
type AttrOrigin SimpleActionEnabledPropertyInfo = SimpleAction
attrGet _ = getSimpleActionEnabled
attrSet _ = setSimpleActionEnabled
attrConstruct _ = constructSimpleActionEnabled
attrClear _ = undefined
#endif
getSimpleActionName :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe T.Text)
getSimpleActionName :: o -> m (Maybe Text)
getSimpleActionName obj :: o
obj = 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
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
getObjectPropertyString o
obj "name"
constructSimpleActionName :: (IsSimpleAction o) => T.Text -> IO (GValueConstruct o)
constructSimpleActionName :: Text -> IO (GValueConstruct o)
constructSimpleActionName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
#if ENABLE_OVERLOADING
data SimpleActionNamePropertyInfo
instance AttrInfo SimpleActionNamePropertyInfo where
type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text
type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = IsSimpleAction
type AttrGetType SimpleActionNamePropertyInfo = (Maybe T.Text)
type AttrLabel SimpleActionNamePropertyInfo = "name"
type AttrOrigin SimpleActionNamePropertyInfo = SimpleAction
attrGet _ = getSimpleActionName
attrSet _ = undefined
attrConstruct _ = constructSimpleActionName
attrClear _ = undefined
#endif
getSimpleActionParameterType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getSimpleActionParameterType :: o -> m (Maybe VariantType)
getSimpleActionParameterType obj :: o
obj = IO (Maybe VariantType) -> m (Maybe VariantType)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr VariantType -> VariantType)
-> IO (Maybe VariantType)
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed o
obj "parameter-type" ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType
constructSimpleActionParameterType :: (IsSimpleAction o) => GLib.VariantType.VariantType -> IO (GValueConstruct o)
constructSimpleActionParameterType :: VariantType -> IO (GValueConstruct o)
constructSimpleActionParameterType val :: VariantType
val = String -> Maybe VariantType -> IO (GValueConstruct o)
forall a o.
BoxedObject a =>
String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyBoxed "parameter-type" (VariantType -> Maybe VariantType
forall a. a -> Maybe a
Just VariantType
val)
#if ENABLE_OVERLOADING
data SimpleActionParameterTypePropertyInfo
instance AttrInfo SimpleActionParameterTypePropertyInfo where
type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType.VariantType
type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = IsSimpleAction
type AttrGetType SimpleActionParameterTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
type AttrLabel SimpleActionParameterTypePropertyInfo = "parameter-type"
type AttrOrigin SimpleActionParameterTypePropertyInfo = SimpleAction
attrGet _ = getSimpleActionParameterType
attrSet _ = undefined
attrConstruct _ = constructSimpleActionParameterType
attrClear _ = undefined
#endif
getSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GVariant)
getSimpleActionState :: o -> m (Maybe GVariant)
getSimpleActionState obj :: o
obj = IO (Maybe GVariant) -> m (Maybe GVariant)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe GVariant)
forall a. GObject a => a -> String -> IO (Maybe GVariant)
getObjectPropertyVariant o
obj "state"
setSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> GVariant -> m ()
setSimpleActionState :: o -> GVariant -> m ()
setSimpleActionState obj :: o
obj val :: GVariant
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> SimpleActionActivateCallback
forall a. GObject a => a -> String -> SimpleActionActivateCallback
setObjectPropertyVariant o
obj "state" (GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
val)
constructSimpleActionState :: (IsSimpleAction o) => GVariant -> IO (GValueConstruct o)
constructSimpleActionState :: GVariant -> IO (GValueConstruct o)
constructSimpleActionState val :: GVariant
val = String -> Maybe GVariant -> IO (GValueConstruct o)
forall o. String -> Maybe GVariant -> IO (GValueConstruct o)
constructObjectPropertyVariant "state" (GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
val)
#if ENABLE_OVERLOADING
data SimpleActionStatePropertyInfo
instance AttrInfo SimpleActionStatePropertyInfo where
type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant
type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = IsSimpleAction
type AttrGetType SimpleActionStatePropertyInfo = (Maybe GVariant)
type AttrLabel SimpleActionStatePropertyInfo = "state"
type AttrOrigin SimpleActionStatePropertyInfo = SimpleAction
attrGet _ = getSimpleActionState
attrSet _ = setSimpleActionState
attrConstruct _ = constructSimpleActionState
attrClear _ = undefined
#endif
getSimpleActionStateType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getSimpleActionStateType :: o -> m (Maybe VariantType)
getSimpleActionStateType obj :: o
obj = IO (Maybe VariantType) -> m (Maybe VariantType)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr VariantType -> VariantType)
-> IO (Maybe VariantType)
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed o
obj "state-type" ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType
#if ENABLE_OVERLOADING
data SimpleActionStateTypePropertyInfo
instance AttrInfo SimpleActionStateTypePropertyInfo where
type AttrAllowedOps SimpleActionStateTypePropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SimpleActionStateTypePropertyInfo = (~) ()
type AttrBaseTypeConstraint SimpleActionStateTypePropertyInfo = IsSimpleAction
type AttrGetType SimpleActionStateTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
type AttrLabel SimpleActionStateTypePropertyInfo = "state-type"
type AttrOrigin SimpleActionStateTypePropertyInfo = SimpleAction
attrGet _ = getSimpleActionStateType
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList SimpleAction
type instance O.AttributeList SimpleAction = SimpleActionAttributeList
type SimpleActionAttributeList = ('[ '("enabled", SimpleActionEnabledPropertyInfo), '("name", SimpleActionNamePropertyInfo), '("parameterType", SimpleActionParameterTypePropertyInfo), '("state", SimpleActionStatePropertyInfo), '("stateType", SimpleActionStateTypePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
simpleActionEnabled :: AttrLabelProxy "enabled"
simpleActionEnabled = AttrLabelProxy
simpleActionName :: AttrLabelProxy "name"
simpleActionName = AttrLabelProxy
simpleActionParameterType :: AttrLabelProxy "parameterType"
simpleActionParameterType = AttrLabelProxy
simpleActionState :: AttrLabelProxy "state"
simpleActionState = AttrLabelProxy
simpleActionStateType :: AttrLabelProxy "stateType"
simpleActionStateType = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data SimpleActionActivateSignalInfo
instance SignalInfo SimpleActionActivateSignalInfo where
type HaskellCallbackType SimpleActionActivateSignalInfo = SimpleActionActivateCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SimpleActionActivateCallback cb
cb'' <- mk_SimpleActionActivateCallback cb'
connectSignalFunPtr obj "activate" cb'' connectMode
data SimpleActionChangeStateSignalInfo
instance SignalInfo SimpleActionChangeStateSignalInfo where
type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_SimpleActionChangeStateCallback cb
cb'' <- mk_SimpleActionChangeStateCallback cb'
connectSignalFunPtr obj "change-state" cb'' connectMode
type instance O.SignalList SimpleAction = SimpleActionSignalList
type SimpleActionSignalList = ('[ '("activate", SimpleActionActivateSignalInfo), '("changeState", SimpleActionChangeStateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_simple_action_new" g_simple_action_new ::
CString ->
Ptr GLib.VariantType.VariantType ->
IO (Ptr SimpleAction)
simpleActionNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (GLib.VariantType.VariantType)
-> m SimpleAction
simpleActionNew :: Text -> Maybe VariantType -> m SimpleAction
simpleActionNew name :: Text
name parameterType :: Maybe VariantType
parameterType = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> IO SimpleAction -> m SimpleAction
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr VariantType
maybeParameterType <- case Maybe VariantType
parameterType of
Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
Just jParameterType :: VariantType
jParameterType -> do
Ptr VariantType
jParameterType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jParameterType
Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jParameterType'
Ptr SimpleAction
result <- CString -> Ptr VariantType -> IO (Ptr SimpleAction)
g_simple_action_new CString
name' Ptr VariantType
maybeParameterType
Text -> Ptr SimpleAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "simpleActionNew" Ptr SimpleAction
result
SimpleAction
result' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SimpleAction -> SimpleAction
SimpleAction) Ptr SimpleAction
result
Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
parameterType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
SimpleAction -> IO SimpleAction
forall (m :: * -> *) a. Monad m => a -> m a
return SimpleAction
result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "g_simple_action_new_stateful" g_simple_action_new_stateful ::
CString ->
Ptr GLib.VariantType.VariantType ->
Ptr GVariant ->
IO (Ptr SimpleAction)
simpleActionNewStateful ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (GLib.VariantType.VariantType)
-> GVariant
-> m SimpleAction
simpleActionNewStateful :: Text -> Maybe VariantType -> GVariant -> m SimpleAction
simpleActionNewStateful name :: Text
name parameterType :: Maybe VariantType
parameterType state :: GVariant
state = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> IO SimpleAction -> m SimpleAction
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr VariantType
maybeParameterType <- case Maybe VariantType
parameterType of
Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
Just jParameterType :: VariantType
jParameterType -> do
Ptr VariantType
jParameterType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jParameterType
Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jParameterType'
Ptr GVariant
state' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
state
Ptr SimpleAction
result <- CString -> Ptr VariantType -> Ptr GVariant -> IO (Ptr SimpleAction)
g_simple_action_new_stateful CString
name' Ptr VariantType
maybeParameterType Ptr GVariant
state'
Text -> Ptr SimpleAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "simpleActionNewStateful" Ptr SimpleAction
result
SimpleAction
result' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SimpleAction -> SimpleAction
SimpleAction) Ptr SimpleAction
result
Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
parameterType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
state
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
SimpleAction -> IO SimpleAction
forall (m :: * -> *) a. Monad m => a -> m a
return SimpleAction
result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "g_simple_action_set_enabled" g_simple_action_set_enabled ::
Ptr SimpleAction ->
CInt ->
IO ()
simpleActionSetEnabled ::
(B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
a
-> Bool
-> m ()
simpleActionSetEnabled :: a -> Bool -> m ()
simpleActionSetEnabled simple :: a
simple enabled :: Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
Ptr SimpleAction -> CInt -> IO ()
g_simple_action_set_enabled Ptr SimpleAction
simple' CInt
enabled'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data SimpleActionSetEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetEnabledMethodInfo a signature where
overloadedMethod _ = simpleActionSetEnabled
#endif
foreign import ccall "g_simple_action_set_state" g_simple_action_set_state ::
Ptr SimpleAction ->
Ptr GVariant ->
IO ()
simpleActionSetState ::
(B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
a
-> GVariant
-> m ()
simpleActionSetState :: a -> GVariant -> m ()
simpleActionSetState simple :: a
simple value :: GVariant
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr SimpleAction -> Ptr GVariant -> IO ()
g_simple_action_set_state Ptr SimpleAction
simple' Ptr GVariant
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data SimpleActionSetStateMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateMethodInfo a signature where
overloadedMethod _ = simpleActionSetState
#endif
foreign import ccall "g_simple_action_set_state_hint" g_simple_action_set_state_hint ::
Ptr SimpleAction ->
Ptr GVariant ->
IO ()
simpleActionSetStateHint ::
(B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
a
-> Maybe (GVariant)
-> m ()
simpleActionSetStateHint :: a -> Maybe GVariant -> m ()
simpleActionSetStateHint simple :: a
simple stateHint :: Maybe GVariant
stateHint = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
Ptr GVariant
maybeStateHint <- case Maybe GVariant
stateHint of
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
Just jStateHint :: GVariant
jStateHint -> do
Ptr GVariant
jStateHint' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jStateHint
Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jStateHint'
Ptr SimpleAction -> Ptr GVariant -> IO ()
g_simple_action_set_state_hint Ptr SimpleAction
simple' Ptr GVariant
maybeStateHint
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
stateHint GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data SimpleActionSetStateHintMethodInfo
instance (signature ~ (Maybe (GVariant) -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateHintMethodInfo a signature where
overloadedMethod _ = simpleActionSetStateHint
#endif