{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Interfaces.Activatable
(
Activatable(..) ,
IsActivatable ,
toActivatable ,
#if defined(ENABLE_OVERLOADING)
ResolveActivatableMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ActivatableDoSetRelatedActionMethodInfo ,
#endif
activatableDoSetRelatedAction ,
#if defined(ENABLE_OVERLOADING)
ActivatableGetRelatedActionMethodInfo ,
#endif
activatableGetRelatedAction ,
#if defined(ENABLE_OVERLOADING)
ActivatableGetUseActionAppearanceMethodInfo,
#endif
activatableGetUseActionAppearance ,
#if defined(ENABLE_OVERLOADING)
ActivatableSetRelatedActionMethodInfo ,
#endif
activatableSetRelatedAction ,
#if defined(ENABLE_OVERLOADING)
ActivatableSetUseActionAppearanceMethodInfo,
#endif
activatableSetUseActionAppearance ,
#if defined(ENABLE_OVERLOADING)
ActivatableSyncActionPropertiesMethodInfo,
#endif
activatableSyncActionProperties ,
#if defined(ENABLE_OVERLOADING)
ActivatableRelatedActionPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
activatableRelatedAction ,
#endif
constructActivatableRelatedAction ,
getActivatableRelatedAction ,
setActivatableRelatedAction ,
#if defined(ENABLE_OVERLOADING)
ActivatableUseActionAppearancePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
activatableUseActionAppearance ,
#endif
constructActivatableUseActionAppearance ,
getActivatableUseActionAppearance ,
setActivatableUseActionAppearance ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.Action as Gtk.Action
newtype Activatable = Activatable (SP.ManagedPtr Activatable)
deriving (Activatable -> Activatable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Activatable -> Activatable -> Bool
$c/= :: Activatable -> Activatable -> Bool
== :: Activatable -> Activatable -> Bool
$c== :: Activatable -> Activatable -> Bool
Eq)
instance SP.ManagedPtrNewtype Activatable where
toManagedPtr :: Activatable -> ManagedPtr Activatable
toManagedPtr (Activatable ManagedPtr Activatable
p) = ManagedPtr Activatable
p
foreign import ccall "gtk_activatable_get_type"
c_gtk_activatable_get_type :: IO B.Types.GType
instance B.Types.TypedObject Activatable where
glibType :: IO GType
glibType = IO GType
c_gtk_activatable_get_type
instance B.Types.GObject Activatable
class (SP.GObject o, O.IsDescendantOf Activatable o) => IsActivatable o
instance (SP.GObject o, O.IsDescendantOf Activatable o) => IsActivatable o
instance O.HasParentTypes Activatable
type instance O.ParentTypes Activatable = '[GObject.Object.Object]
toActivatable :: (MIO.MonadIO m, IsActivatable o) => o -> m Activatable
toActivatable :: forall (m :: * -> *) o.
(MonadIO m, IsActivatable o) =>
o -> m Activatable
toActivatable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Activatable -> Activatable
Activatable
instance B.GValue.IsGValue (Maybe Activatable) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_activatable_get_type
gvalueSet_ :: Ptr GValue -> Maybe Activatable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Activatable
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Activatable)
gvalueSet_ Ptr GValue
gv (P.Just Activatable
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Activatable
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Activatable)
gvalueGet_ Ptr GValue
gv = do
Ptr Activatable
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Activatable)
if Ptr Activatable
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Activatable -> Activatable
Activatable Ptr Activatable
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
getActivatableRelatedAction :: (MonadIO m, IsActivatable o) => o -> m Gtk.Action.Action
getActivatableRelatedAction :: forall (m :: * -> *) o.
(MonadIO m, IsActivatable o) =>
o -> m Action
getActivatableRelatedAction o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActivatableRelatedAction" forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"related-action" ManagedPtr Action -> Action
Gtk.Action.Action
setActivatableRelatedAction :: (MonadIO m, IsActivatable o, Gtk.Action.IsAction a) => o -> a -> m ()
setActivatableRelatedAction :: forall (m :: * -> *) o a.
(MonadIO m, IsActivatable o, IsAction a) =>
o -> a -> m ()
setActivatableRelatedAction o
obj a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"related-action" (forall a. a -> Maybe a
Just a
val)
constructActivatableRelatedAction :: (IsActivatable o, MIO.MonadIO m, Gtk.Action.IsAction a) => a -> m (GValueConstruct o)
constructActivatableRelatedAction :: forall o (m :: * -> *) a.
(IsActivatable o, MonadIO m, IsAction a) =>
a -> m (GValueConstruct o)
constructActivatableRelatedAction a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"related-action" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data ActivatableRelatedActionPropertyInfo
instance AttrInfo ActivatableRelatedActionPropertyInfo where
type AttrAllowedOps ActivatableRelatedActionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ActivatableRelatedActionPropertyInfo = IsActivatable
type AttrSetTypeConstraint ActivatableRelatedActionPropertyInfo = Gtk.Action.IsAction
type AttrTransferTypeConstraint ActivatableRelatedActionPropertyInfo = Gtk.Action.IsAction
type AttrTransferType ActivatableRelatedActionPropertyInfo = Gtk.Action.Action
type AttrGetType ActivatableRelatedActionPropertyInfo = Gtk.Action.Action
type AttrLabel ActivatableRelatedActionPropertyInfo = "related-action"
type AttrOrigin ActivatableRelatedActionPropertyInfo = Activatable
attrGet = getActivatableRelatedAction
attrSet = setActivatableRelatedAction
attrTransfer _ v = do
unsafeCastTo Gtk.Action.Action v
attrConstruct = constructActivatableRelatedAction
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.relatedAction"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#g:attr:relatedAction"
})
#endif
getActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> m Bool
getActivatableUseActionAppearance :: forall (m :: * -> *) o. (MonadIO m, IsActivatable o) => o -> m Bool
getActivatableUseActionAppearance o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"use-action-appearance"
setActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> Bool -> m ()
setActivatableUseActionAppearance :: forall (m :: * -> *) o.
(MonadIO m, IsActivatable o) =>
o -> Bool -> m ()
setActivatableUseActionAppearance o
obj Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-action-appearance" Bool
val
constructActivatableUseActionAppearance :: (IsActivatable o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActivatableUseActionAppearance :: forall o (m :: * -> *).
(IsActivatable o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActivatableUseActionAppearance Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-action-appearance" Bool
val
#if defined(ENABLE_OVERLOADING)
data ActivatableUseActionAppearancePropertyInfo
instance AttrInfo ActivatableUseActionAppearancePropertyInfo where
type AttrAllowedOps ActivatableUseActionAppearancePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ActivatableUseActionAppearancePropertyInfo = IsActivatable
type AttrSetTypeConstraint ActivatableUseActionAppearancePropertyInfo = (~) Bool
type AttrTransferTypeConstraint ActivatableUseActionAppearancePropertyInfo = (~) Bool
type AttrTransferType ActivatableUseActionAppearancePropertyInfo = Bool
type AttrGetType ActivatableUseActionAppearancePropertyInfo = Bool
type AttrLabel ActivatableUseActionAppearancePropertyInfo = "use-action-appearance"
type AttrOrigin ActivatableUseActionAppearancePropertyInfo = Activatable
attrGet = getActivatableUseActionAppearance
attrSet = setActivatableUseActionAppearance
attrTransfer _ v = do
return v
attrConstruct = constructActivatableUseActionAppearance
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.useActionAppearance"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#g:attr:useActionAppearance"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Activatable
type instance O.AttributeList Activatable = ActivatableAttributeList
type ActivatableAttributeList = ('[ '("relatedAction", ActivatableRelatedActionPropertyInfo), '("useActionAppearance", ActivatableUseActionAppearancePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
activatableRelatedAction :: AttrLabelProxy "relatedAction"
activatableRelatedAction = AttrLabelProxy
activatableUseActionAppearance :: AttrLabelProxy "useActionAppearance"
activatableUseActionAppearance = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveActivatableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveActivatableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveActivatableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveActivatableMethod "doSetRelatedAction" o = ActivatableDoSetRelatedActionMethodInfo
ResolveActivatableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveActivatableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveActivatableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveActivatableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveActivatableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveActivatableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveActivatableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveActivatableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveActivatableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveActivatableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveActivatableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveActivatableMethod "syncActionProperties" o = ActivatableSyncActionPropertiesMethodInfo
ResolveActivatableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveActivatableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveActivatableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveActivatableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveActivatableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveActivatableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveActivatableMethod "getRelatedAction" o = ActivatableGetRelatedActionMethodInfo
ResolveActivatableMethod "getUseActionAppearance" o = ActivatableGetUseActionAppearanceMethodInfo
ResolveActivatableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveActivatableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveActivatableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveActivatableMethod "setRelatedAction" o = ActivatableSetRelatedActionMethodInfo
ResolveActivatableMethod "setUseActionAppearance" o = ActivatableSetUseActionAppearanceMethodInfo
ResolveActivatableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveActivatableMethod t Activatable, O.OverloadedMethod info Activatable p) => OL.IsLabel t (Activatable -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveActivatableMethod t Activatable, O.OverloadedMethod info Activatable p, R.HasField t Activatable p) => R.HasField t Activatable p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveActivatableMethod t Activatable, O.OverloadedMethodInfo info Activatable) => OL.IsLabel t (O.MethodProxy info Activatable) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "gtk_activatable_do_set_related_action" gtk_activatable_do_set_related_action ::
Ptr Activatable ->
Ptr Gtk.Action.Action ->
IO ()
{-# DEPRECATED activatableDoSetRelatedAction ["(Since version 3.10)"] #-}
activatableDoSetRelatedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a, Gtk.Action.IsAction b) =>
a
-> b
-> m ()
activatableDoSetRelatedAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActivatable a, IsAction b) =>
a -> b -> m ()
activatableDoSetRelatedAction a
activatable b
action = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
Ptr Action
action' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
action
Ptr Activatable -> Ptr Action -> IO ()
gtk_activatable_do_set_related_action Ptr Activatable
activatable' Ptr Action
action'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
action
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ActivatableDoSetRelatedActionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActivatable a, Gtk.Action.IsAction b) => O.OverloadedMethod ActivatableDoSetRelatedActionMethodInfo a signature where
overloadedMethod = activatableDoSetRelatedAction
instance O.OverloadedMethodInfo ActivatableDoSetRelatedActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableDoSetRelatedAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableDoSetRelatedAction"
})
#endif
foreign import ccall "gtk_activatable_get_related_action" gtk_activatable_get_related_action ::
Ptr Activatable ->
IO (Ptr Gtk.Action.Action)
{-# DEPRECATED activatableGetRelatedAction ["(Since version 3.10)"] #-}
activatableGetRelatedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a) =>
a
-> m Gtk.Action.Action
activatableGetRelatedAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActivatable a) =>
a -> m Action
activatableGetRelatedAction a
activatable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
Ptr Action
result <- Ptr Activatable -> IO (Ptr Action)
gtk_activatable_get_related_action Ptr Activatable
activatable'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"activatableGetRelatedAction" Ptr Action
result
Action
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Action -> Action
Gtk.Action.Action) Ptr Action
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall (m :: * -> *) a. Monad m => a -> m a
return Action
result'
#if defined(ENABLE_OVERLOADING)
data ActivatableGetRelatedActionMethodInfo
instance (signature ~ (m Gtk.Action.Action), MonadIO m, IsActivatable a) => O.OverloadedMethod ActivatableGetRelatedActionMethodInfo a signature where
overloadedMethod = activatableGetRelatedAction
instance O.OverloadedMethodInfo ActivatableGetRelatedActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableGetRelatedAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableGetRelatedAction"
})
#endif
foreign import ccall "gtk_activatable_get_use_action_appearance" gtk_activatable_get_use_action_appearance ::
Ptr Activatable ->
IO CInt
{-# DEPRECATED activatableGetUseActionAppearance ["(Since version 3.10)"] #-}
activatableGetUseActionAppearance ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a) =>
a
-> m Bool
activatableGetUseActionAppearance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActivatable a) =>
a -> m Bool
activatableGetUseActionAppearance a
activatable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
CInt
result <- Ptr Activatable -> IO CInt
gtk_activatable_get_use_action_appearance Ptr Activatable
activatable'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ActivatableGetUseActionAppearanceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActivatable a) => O.OverloadedMethod ActivatableGetUseActionAppearanceMethodInfo a signature where
overloadedMethod = activatableGetUseActionAppearance
instance O.OverloadedMethodInfo ActivatableGetUseActionAppearanceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableGetUseActionAppearance",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableGetUseActionAppearance"
})
#endif
foreign import ccall "gtk_activatable_set_related_action" gtk_activatable_set_related_action ::
Ptr Activatable ->
Ptr Gtk.Action.Action ->
IO ()
{-# DEPRECATED activatableSetRelatedAction ["(Since version 3.10)"] #-}
activatableSetRelatedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a, Gtk.Action.IsAction b) =>
a
-> b
-> m ()
activatableSetRelatedAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActivatable a, IsAction b) =>
a -> b -> m ()
activatableSetRelatedAction a
activatable b
action = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
Ptr Action
action' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
action
Ptr Activatable -> Ptr Action -> IO ()
gtk_activatable_set_related_action Ptr Activatable
activatable' Ptr Action
action'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
action
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ActivatableSetRelatedActionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActivatable a, Gtk.Action.IsAction b) => O.OverloadedMethod ActivatableSetRelatedActionMethodInfo a signature where
overloadedMethod = activatableSetRelatedAction
instance O.OverloadedMethodInfo ActivatableSetRelatedActionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableSetRelatedAction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableSetRelatedAction"
})
#endif
foreign import ccall "gtk_activatable_set_use_action_appearance" gtk_activatable_set_use_action_appearance ::
Ptr Activatable ->
CInt ->
IO ()
{-# DEPRECATED activatableSetUseActionAppearance ["(Since version 3.10)"] #-}
activatableSetUseActionAppearance ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a) =>
a
-> Bool
-> m ()
activatableSetUseActionAppearance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActivatable a) =>
a -> Bool -> m ()
activatableSetUseActionAppearance a
activatable Bool
useAppearance = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
let useAppearance' :: CInt
useAppearance' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
useAppearance
Ptr Activatable -> CInt -> IO ()
gtk_activatable_set_use_action_appearance Ptr Activatable
activatable' CInt
useAppearance'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ActivatableSetUseActionAppearanceMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActivatable a) => O.OverloadedMethod ActivatableSetUseActionAppearanceMethodInfo a signature where
overloadedMethod = activatableSetUseActionAppearance
instance O.OverloadedMethodInfo ActivatableSetUseActionAppearanceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableSetUseActionAppearance",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableSetUseActionAppearance"
})
#endif
foreign import ccall "gtk_activatable_sync_action_properties" gtk_activatable_sync_action_properties ::
Ptr Activatable ->
Ptr Gtk.Action.Action ->
IO ()
{-# DEPRECATED activatableSyncActionProperties ["(Since version 3.10)"] #-}
activatableSyncActionProperties ::
(B.CallStack.HasCallStack, MonadIO m, IsActivatable a, Gtk.Action.IsAction b) =>
a
-> Maybe (b)
-> m ()
activatableSyncActionProperties :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActivatable a, IsAction b) =>
a -> Maybe b -> m ()
activatableSyncActionProperties a
activatable Maybe b
action = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Activatable
activatable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
activatable
Ptr Action
maybeAction <- case Maybe b
action of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jAction -> do
Ptr Action
jAction' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jAction
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Action
jAction'
Ptr Activatable -> Ptr Action -> IO ()
gtk_activatable_sync_action_properties Ptr Activatable
activatable' Ptr Action
maybeAction
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
activatable
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
action forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ActivatableSyncActionPropertiesMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActivatable a, Gtk.Action.IsAction b) => O.OverloadedMethod ActivatableSyncActionPropertiesMethodInfo a signature where
overloadedMethod = activatableSyncActionProperties
instance O.OverloadedMethodInfo ActivatableSyncActionPropertiesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Interfaces.Activatable.activatableSyncActionProperties",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Interfaces-Activatable.html#v:activatableSyncActionProperties"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Activatable = ActivatableSignalList
type ActivatableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif