{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A 'GI.Gio.Objects.SimpleAction.SimpleAction' is the obvious simple implementation of the 'GI.Gio.Interfaces.Action.Action' interface. This is the easiest way to create an action for purposes of adding it to a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'. See also @/GtkAction/@. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.SimpleAction ( -- * Exported types SimpleAction(..) , IsSimpleAction , toSimpleAction , noSimpleAction , -- * Methods -- ** new #method:new# simpleActionNew , -- ** newStateful #method:newStateful# simpleActionNewStateful , -- ** setEnabled #method:setEnabled# #if ENABLE_OVERLOADING SimpleActionSetEnabledMethodInfo , #endif simpleActionSetEnabled , -- ** setState #method:setState# #if ENABLE_OVERLOADING SimpleActionSetStateMethodInfo , #endif simpleActionSetState , -- ** setStateHint #method:setStateHint# #if ENABLE_OVERLOADING SimpleActionSetStateHintMethodInfo , #endif simpleActionSetStateHint , -- * Properties -- ** enabled #attr:enabled# {- | If /@action@/ is currently enabled. If the action is disabled then calls to 'GI.Gio.Interfaces.Action.actionActivate' and 'GI.Gio.Interfaces.Action.actionChangeState' have no effect. /Since: 2.28/ -} #if ENABLE_OVERLOADING SimpleActionEnabledPropertyInfo , #endif constructSimpleActionEnabled , getSimpleActionEnabled , setSimpleActionEnabled , #if ENABLE_OVERLOADING simpleActionEnabled , #endif -- ** name #attr:name# {- | The name of the action. This is mostly meaningful for identifying the action once it has been added to a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'. /Since: 2.28/ -} #if ENABLE_OVERLOADING SimpleActionNamePropertyInfo , #endif constructSimpleActionName , getSimpleActionName , #if ENABLE_OVERLOADING simpleActionName , #endif -- ** parameterType #attr:parameterType# {- | The type of the parameter that must be given when activating the action. /Since: 2.28/ -} #if ENABLE_OVERLOADING SimpleActionParameterTypePropertyInfo , #endif constructSimpleActionParameterType , getSimpleActionParameterType , #if ENABLE_OVERLOADING simpleActionParameterType , #endif -- ** state #attr:state# {- | The state of the action, or 'Nothing' if the action is stateless. /Since: 2.28/ -} #if ENABLE_OVERLOADING SimpleActionStatePropertyInfo , #endif constructSimpleActionState , getSimpleActionState , setSimpleActionState , #if ENABLE_OVERLOADING simpleActionState , #endif -- ** stateType #attr:stateType# {- | The 'GI.GLib.Structs.VariantType.VariantType' of the state that the action has, or 'Nothing' if the action is stateless. /Since: 2.28/ -} #if ENABLE_OVERLOADING SimpleActionStateTypePropertyInfo , #endif getSimpleActionStateType , #if ENABLE_OVERLOADING simpleActionStateType , #endif -- * Signals -- ** activate #signal:activate# C_SimpleActionActivateCallback , SimpleActionActivateCallback , #if ENABLE_OVERLOADING SimpleActionActivateSignalInfo , #endif afterSimpleActionActivate , genClosure_SimpleActionActivate , mk_SimpleActionActivateCallback , noSimpleActionActivateCallback , onSimpleActionActivate , wrap_SimpleActionActivateCallback , -- ** changeState #signal:changeState# 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.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.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 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 -- | Memory-managed wrapper type. 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 = c_g_simple_action_get_type -- | Type class for types which can be safely cast to `SimpleAction`, for instance with `toSimpleAction`. class (GObject o, O.IsDescendantOf SimpleAction o) => IsSimpleAction o instance (GObject o, O.IsDescendantOf SimpleAction o) => IsSimpleAction o instance O.HasParentTypes SimpleAction type instance O.ParentTypes SimpleAction = '[GObject.Object.Object, Gio.Action.Action] -- | Cast to `SimpleAction`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toSimpleAction :: (MonadIO m, IsSimpleAction o) => o -> m SimpleAction toSimpleAction = liftIO . unsafeCastTo SimpleAction -- | A convenience alias for `Nothing` :: `Maybe` `SimpleAction`. noSimpleAction :: Maybe SimpleAction noSimpleAction = 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) => OL.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 -- signal SimpleAction::activate {- | Indicates that the action was just activated. /@parameter@/ will always be of the expected type, i.e. the parameter type specified when the action was created. If an incorrect type is given when activating the action, this signal is not emitted. Since GLib 2.40, if no handler is connected to this signal then the default behaviour for boolean-stated actions with a 'Nothing' parameter type is to toggle them via the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@ signal. For stateful actions where the state type is equal to the parameter type, the default is to forward them directly to 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@. This should allow almost all users of 'GI.Gio.Objects.SimpleAction.SimpleAction' to connect only one handler or the other. /Since: 2.28/ -} type SimpleActionActivateCallback = Maybe GVariant {- ^ /@parameter@/: the parameter to the activation, or 'Nothing' if it has no parameter -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionActivateCallback`@. noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback noSimpleActionActivateCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_SimpleActionActivateCallback = Ptr () -> -- object Ptr GVariant -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_SimpleActionActivateCallback`. foreign import ccall "wrapper" mk_SimpleActionActivateCallback :: C_SimpleActionActivateCallback -> IO (FunPtr C_SimpleActionActivateCallback) -- | Wrap the callback into a `GClosure`. genClosure_SimpleActionActivate :: MonadIO m => SimpleActionActivateCallback -> m (GClosure C_SimpleActionActivateCallback) genClosure_SimpleActionActivate cb = liftIO $ do let cb' = wrap_SimpleActionActivateCallback cb mk_SimpleActionActivateCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `SimpleActionActivateCallback` into a `C_SimpleActionActivateCallback`. wrap_SimpleActionActivateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback wrap_SimpleActionActivateCallback _cb _ parameter _ = do maybeParameter <- if parameter == nullPtr then return Nothing else do parameter' <- B.GVariant.newGVariantFromPtr parameter return $ Just parameter' _cb maybeParameter {- | Connect a signal handler for the “@activate@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' simpleAction #activate callback @ -} onSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId onSimpleActionActivate obj cb = liftIO $ do let cb' = wrap_SimpleActionActivateCallback cb cb'' <- mk_SimpleActionActivateCallback cb' connectSignalFunPtr obj "activate" cb'' SignalConnectBefore {- | Connect a signal handler for the “@activate@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' simpleAction #activate callback @ -} afterSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId afterSimpleActionActivate obj cb = liftIO $ do let cb' = wrap_SimpleActionActivateCallback cb cb'' <- mk_SimpleActionActivateCallback cb' connectSignalFunPtr obj "activate" cb'' SignalConnectAfter -- signal SimpleAction::change-state {- | Indicates that the action just received a request to change its state. /@value@/ will always be of the correct state type, i.e. the type of the initial state passed to 'GI.Gio.Objects.SimpleAction.simpleActionNewStateful'. If an incorrect type is given when requesting to change the state, this signal is not emitted. If no handler is connected to this signal then the default behaviour is to call 'GI.Gio.Objects.SimpleAction.simpleActionSetState' to set the state to the requested value. If you connect a signal handler then no default action is taken. If the state should change then you must call 'GI.Gio.Objects.SimpleAction.simpleActionSetState' from the handler. An example of a \'change-state\' handler: === /C code/ > >static void >change_volume_state (GSimpleAction *action, > GVariant *value, > gpointer user_data) >{ > gint requested; > > requested = g_variant_get_int32 (value); > > // Volume only goes from 0 to 10 > if (0 <= requested && requested <= 10) > g_simple_action_set_state (action, value); >} The handler need not set the state to the requested value. It could set it to any value at all, or take some other action. /Since: 2.30/ -} type SimpleActionChangeStateCallback = Maybe GVariant {- ^ /@value@/: the requested value for the state -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionChangeStateCallback`@. noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback noSimpleActionChangeStateCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_SimpleActionChangeStateCallback = Ptr () -> -- object Ptr GVariant -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_SimpleActionChangeStateCallback`. foreign import ccall "wrapper" mk_SimpleActionChangeStateCallback :: C_SimpleActionChangeStateCallback -> IO (FunPtr C_SimpleActionChangeStateCallback) -- | Wrap the callback into a `GClosure`. genClosure_SimpleActionChangeState :: MonadIO m => SimpleActionChangeStateCallback -> m (GClosure C_SimpleActionChangeStateCallback) genClosure_SimpleActionChangeState cb = liftIO $ do let cb' = wrap_SimpleActionChangeStateCallback cb mk_SimpleActionChangeStateCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `SimpleActionChangeStateCallback` into a `C_SimpleActionChangeStateCallback`. wrap_SimpleActionChangeStateCallback :: SimpleActionChangeStateCallback -> C_SimpleActionChangeStateCallback wrap_SimpleActionChangeStateCallback _cb _ value _ = do maybeValue <- if value == nullPtr then return Nothing else do value' <- B.GVariant.newGVariantFromPtr value return $ Just value' _cb maybeValue {- | Connect a signal handler for the “@change-state@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' simpleAction #changeState callback @ -} onSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId onSimpleActionChangeState obj cb = liftIO $ do let cb' = wrap_SimpleActionChangeStateCallback cb cb'' <- mk_SimpleActionChangeStateCallback cb' connectSignalFunPtr obj "change-state" cb'' SignalConnectBefore {- | Connect a signal handler for the “@change-state@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' simpleAction #changeState callback @ -} afterSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId afterSimpleActionChangeState obj cb = liftIO $ do let cb' = wrap_SimpleActionChangeStateCallback cb cb'' <- mk_SimpleActionChangeStateCallback cb' connectSignalFunPtr obj "change-state" cb'' SignalConnectAfter --- XXX Duplicated object with different types: --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- XXX Duplicated object with different types: --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action. This is mostly meaningful for identifying\nthe action once it has been added to a #GSimpleActionGroup.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action. This is mostly meaningful for identifying\nthe action once it has been added to a #GActionGroup. It is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- XXX Duplicated object with different types: --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction. This is immutable, and may be %NULL if no parameter is needed when\nactivating the action.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- XXX Duplicated object with different types: --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- XXX Duplicated object with different types: --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless. This is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing} -- VVV Prop "enabled" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Just False) {- | Get the value of the “@enabled@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' simpleAction #enabled @ -} getSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> m Bool getSimpleActionEnabled obj = liftIO $ B.Properties.getObjectPropertyBool obj "enabled" {- | Set the value of the “@enabled@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' simpleAction [ #enabled 'Data.GI.Base.Attributes.:=' value ] @ -} setSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> Bool -> m () setSimpleActionEnabled obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enabled" val {- | Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructSimpleActionEnabled :: (IsSimpleAction o) => Bool -> IO (GValueConstruct o) constructSimpleActionEnabled val = B.Properties.constructObjectPropertyBool "enabled" 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 -- VVV Prop "name" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@name@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' simpleAction #name @ -} getSimpleActionName :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe T.Text) getSimpleActionName obj = liftIO $ B.Properties.getObjectPropertyString obj "name" {- | Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructSimpleActionName :: (IsSimpleAction o) => T.Text -> IO (GValueConstruct o) constructSimpleActionName val = B.Properties.constructObjectPropertyString "name" (Just 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 -- VVV Prop "parameter-type" -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@parameter-type@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' simpleAction #parameterType @ -} getSimpleActionParameterType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType) getSimpleActionParameterType obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "parameter-type" GLib.VariantType.VariantType {- | Construct a `GValueConstruct` with valid value for the “@parameter-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructSimpleActionParameterType :: (IsSimpleAction o) => GLib.VariantType.VariantType -> IO (GValueConstruct o) constructSimpleActionParameterType val = B.Properties.constructObjectPropertyBoxed "parameter-type" (Just 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 -- VVV Prop "state" -- Type: TVariant -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Nothing,Just False) {- | Get the value of the “@state@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' simpleAction #state @ -} getSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GVariant) getSimpleActionState obj = liftIO $ B.Properties.getObjectPropertyVariant obj "state" {- | Set the value of the “@state@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' simpleAction [ #state 'Data.GI.Base.Attributes.:=' value ] @ -} setSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> GVariant -> m () setSimpleActionState obj val = liftIO $ B.Properties.setObjectPropertyVariant obj "state" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@state@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructSimpleActionState :: (IsSimpleAction o) => GVariant -> IO (GValueConstruct o) constructSimpleActionState val = B.Properties.constructObjectPropertyVariant "state" (Just 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 -- VVV Prop "state-type" -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"}) -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@state-type@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' simpleAction #stateType @ -} getSimpleActionStateType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType) getSimpleActionStateType obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "state-type" 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 -- method SimpleAction::new -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of parameter that will be passed to\n handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"})) -- throws : False -- Skip return : False foreign import ccall "g_simple_action_new" g_simple_action_new :: CString -> -- name : TBasicType TUTF8 Ptr GLib.VariantType.VariantType -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"}) IO (Ptr SimpleAction) {- | Creates a new action. The created action is stateless. See 'GI.Gio.Objects.SimpleAction.simpleActionNewStateful' to create an action that has state. /Since: 2.28/ -} simpleActionNew :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@name@/: the name of the action -} -> Maybe (GLib.VariantType.VariantType) {- ^ /@parameterType@/: the type of parameter that will be passed to handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -} -> m SimpleAction {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -} simpleActionNew name parameterType = liftIO $ do name' <- textToCString name maybeParameterType <- case parameterType of Nothing -> return nullPtr Just jParameterType -> do jParameterType' <- unsafeManagedPtrGetPtr jParameterType return jParameterType' result <- g_simple_action_new name' maybeParameterType checkUnexpectedReturnNULL "simpleActionNew" result result' <- (wrapObject SimpleAction) result whenJust parameterType touchManagedPtr freeMem name' return result' #if ENABLE_OVERLOADING #endif -- method SimpleAction::new_stateful -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of the parameter that will be passed to\n handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the initial state of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"})) -- throws : False -- Skip return : False foreign import ccall "g_simple_action_new_stateful" g_simple_action_new_stateful :: CString -> -- name : TBasicType TUTF8 Ptr GLib.VariantType.VariantType -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"}) Ptr GVariant -> -- state : TVariant IO (Ptr SimpleAction) {- | Creates a new stateful action. All future state values must have the same 'GI.GLib.Structs.VariantType.VariantType' as the initial /@state@/. If the /@state@/ 'GVariant' is floating, it is consumed. /Since: 2.28/ -} simpleActionNewStateful :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@name@/: the name of the action -} -> Maybe (GLib.VariantType.VariantType) {- ^ /@parameterType@/: the type of the parameter that will be passed to handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -} -> GVariant {- ^ /@state@/: the initial state of the action -} -> m SimpleAction {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -} simpleActionNewStateful name parameterType state = liftIO $ do name' <- textToCString name maybeParameterType <- case parameterType of Nothing -> return nullPtr Just jParameterType -> do jParameterType' <- unsafeManagedPtrGetPtr jParameterType return jParameterType' state' <- unsafeManagedPtrGetPtr state result <- g_simple_action_new_stateful name' maybeParameterType state' checkUnexpectedReturnNULL "simpleActionNewStateful" result result' <- (wrapObject SimpleAction) result whenJust parameterType touchManagedPtr touchManagedPtr state freeMem name' return result' #if ENABLE_OVERLOADING #endif -- method SimpleAction::set_enabled -- method type : OrdinaryMethod -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the action is enabled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_simple_action_set_enabled" g_simple_action_set_enabled :: Ptr SimpleAction -> -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"}) CInt -> -- enabled : TBasicType TBoolean IO () {- | Sets the action as enabled or not. An action must be enabled in order to be activated or in order to have its state changed from outside callers. This should only be called by the implementor of the action. Users of the action should not attempt to modify its enabled flag. /Since: 2.28/ -} simpleActionSetEnabled :: (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) => a {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -} -> Bool {- ^ /@enabled@/: whether the action is enabled -} -> m () simpleActionSetEnabled simple enabled = liftIO $ do simple' <- unsafeManagedPtrCastPtr simple let enabled' = (fromIntegral . fromEnum) enabled g_simple_action_set_enabled simple' enabled' touchManagedPtr simple return () #if ENABLE_OVERLOADING data SimpleActionSetEnabledMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetEnabledMethodInfo a signature where overloadedMethod _ = simpleActionSetEnabled #endif -- method SimpleAction::set_state -- method type : OrdinaryMethod -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new #GVariant for the state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_simple_action_set_state" g_simple_action_set_state :: Ptr SimpleAction -> -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"}) Ptr GVariant -> -- value : TVariant IO () {- | Sets the state of the action. This directly updates the \'state\' property to the given value. This should only be called by the implementor of the action. Users of the action should not attempt to directly modify the \'state\' property. Instead, they should call 'GI.Gio.Interfaces.Action.actionChangeState' to request the change. If the /@value@/ GVariant is floating, it is consumed. /Since: 2.30/ -} simpleActionSetState :: (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) => a {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -} -> GVariant {- ^ /@value@/: the new 'GVariant' for the state -} -> m () simpleActionSetState simple value = liftIO $ do simple' <- unsafeManagedPtrCastPtr simple value' <- unsafeManagedPtrGetPtr value g_simple_action_set_state simple' value' touchManagedPtr simple touchManagedPtr value return () #if ENABLE_OVERLOADING data SimpleActionSetStateMethodInfo instance (signature ~ (GVariant -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateMethodInfo a signature where overloadedMethod _ = simpleActionSetState #endif -- method SimpleAction::set_state_hint -- method type : OrdinaryMethod -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state_hint", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant representing the state hint", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_simple_action_set_state_hint" g_simple_action_set_state_hint :: Ptr SimpleAction -> -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"}) Ptr GVariant -> -- state_hint : TVariant IO () {- | Sets the state hint for the action. See 'GI.Gio.Interfaces.Action.actionGetStateHint' for more information about action state hints. /Since: 2.44/ -} simpleActionSetStateHint :: (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) => a {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -} -> Maybe (GVariant) {- ^ /@stateHint@/: a 'GVariant' representing the state hint -} -> m () simpleActionSetStateHint simple stateHint = liftIO $ do simple' <- unsafeManagedPtrCastPtr simple maybeStateHint <- case stateHint of Nothing -> return nullPtr Just jStateHint -> do jStateHint' <- unsafeManagedPtrGetPtr jStateHint return jStateHint' g_simple_action_set_state_hint simple' maybeStateHint touchManagedPtr simple whenJust stateHint touchManagedPtr return () #if ENABLE_OVERLOADING data SimpleActionSetStateHintMethodInfo instance (signature ~ (Maybe (GVariant) -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateHintMethodInfo a signature where overloadedMethod _ = simpleActionSetStateHint #endif