{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Interfaces.Value
(
Value(..) ,
IsValue ,
toValue ,
#if defined(ENABLE_OVERLOADING)
ResolveValueMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ValueGetCurrentValueMethodInfo ,
#endif
valueGetCurrentValue ,
#if defined(ENABLE_OVERLOADING)
ValueGetIncrementMethodInfo ,
#endif
valueGetIncrement ,
#if defined(ENABLE_OVERLOADING)
ValueGetMaximumValueMethodInfo ,
#endif
valueGetMaximumValue ,
#if defined(ENABLE_OVERLOADING)
ValueGetMinimumIncrementMethodInfo ,
#endif
valueGetMinimumIncrement ,
#if defined(ENABLE_OVERLOADING)
ValueGetMinimumValueMethodInfo ,
#endif
valueGetMinimumValue ,
#if defined(ENABLE_OVERLOADING)
ValueGetRangeMethodInfo ,
#endif
valueGetRange ,
#if defined(ENABLE_OVERLOADING)
ValueGetSubRangesMethodInfo ,
#endif
valueGetSubRanges ,
#if defined(ENABLE_OVERLOADING)
ValueGetValueAndTextMethodInfo ,
#endif
valueGetValueAndText ,
#if defined(ENABLE_OVERLOADING)
ValueSetCurrentValueMethodInfo ,
#endif
valueSetCurrentValue ,
#if defined(ENABLE_OVERLOADING)
ValueSetValueMethodInfo ,
#endif
valueSetValue ,
ValueValueChangedCallback ,
#if defined(ENABLE_OVERLOADING)
ValueValueChangedSignalInfo ,
#endif
afterValueValueChanged ,
onValueValueChanged ,
) 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 {-# SOURCE #-} qualified GI.Atk.Structs.Range as Atk.Range
import qualified GI.GObject.Objects.Object as GObject.Object
newtype Value = Value (SP.ManagedPtr Value)
deriving (Value -> Value -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: Value -> Value -> Bool
Eq)
instance SP.ManagedPtrNewtype Value where
toManagedPtr :: Value -> ManagedPtr Value
toManagedPtr (Value ManagedPtr Value
p) = ManagedPtr Value
p
foreign import ccall "atk_value_get_type"
c_atk_value_get_type :: IO B.Types.GType
instance B.Types.TypedObject Value where
glibType :: IO GType
glibType = IO GType
c_atk_value_get_type
instance B.Types.GObject Value
class (SP.GObject o, O.IsDescendantOf Value o) => IsValue o
instance (SP.GObject o, O.IsDescendantOf Value o) => IsValue o
instance O.HasParentTypes Value
type instance O.ParentTypes Value = '[GObject.Object.Object]
toValue :: (MIO.MonadIO m, IsValue o) => o -> m Value
toValue :: forall (m :: * -> *) o. (MonadIO m, IsValue o) => o -> m Value
toValue = 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 Value -> Value
Value
instance B.GValue.IsGValue (Maybe Value) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_value_get_type
gvalueSet_ :: Ptr GValue -> Maybe Value -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Value
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 Value)
gvalueSet_ Ptr GValue
gv (P.Just Value
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Value
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Value)
gvalueGet_ Ptr GValue
gv = do
Ptr Value
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Value)
if Ptr Value
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 Value -> Value
Value Ptr Value
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Value
type instance O.AttributeList Value = ValueAttributeList
type ValueAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveValueMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveValueMethod "getCurrentValue" o = ValueGetCurrentValueMethodInfo
ResolveValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveValueMethod "getIncrement" o = ValueGetIncrementMethodInfo
ResolveValueMethod "getMaximumValue" o = ValueGetMaximumValueMethodInfo
ResolveValueMethod "getMinimumIncrement" o = ValueGetMinimumIncrementMethodInfo
ResolveValueMethod "getMinimumValue" o = ValueGetMinimumValueMethodInfo
ResolveValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveValueMethod "getRange" o = ValueGetRangeMethodInfo
ResolveValueMethod "getSubRanges" o = ValueGetSubRangesMethodInfo
ResolveValueMethod "getValueAndText" o = ValueGetValueAndTextMethodInfo
ResolveValueMethod "setCurrentValue" o = ValueSetCurrentValueMethodInfo
ResolveValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveValueMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveValueMethod "setValue" o = ValueSetValueMethodInfo
ResolveValueMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p) => OL.IsLabel t (Value -> 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 ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p, R.HasField t Value p) => R.HasField t Value p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveValueMethod t Value, O.OverloadedMethodInfo info Value) => OL.IsLabel t (O.MethodProxy info Value) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "atk_value_get_current_value" atk_value_get_current_value ::
Ptr Value ->
Ptr GValue ->
IO ()
{-# DEPRECATED valueGetCurrentValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetValueAndText'","instead."] #-}
valueGetCurrentValue ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (GValue)
valueGetCurrentValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m GValue
valueGetCurrentValue a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr Value -> Ptr GValue -> IO ()
atk_value_get_current_value Ptr Value
obj' Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
#if defined(ENABLE_OVERLOADING)
data ValueGetCurrentValueMethodInfo
instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetCurrentValueMethodInfo a signature where
overloadedMethod = valueGetCurrentValue
instance O.OverloadedMethodInfo ValueGetCurrentValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetCurrentValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetCurrentValue"
})
#endif
foreign import ccall "atk_value_get_increment" atk_value_get_increment ::
Ptr Value ->
IO CDouble
valueGetIncrement ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Double
valueGetIncrement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Double
valueGetIncrement a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
CDouble
result <- Ptr Value -> IO CDouble
atk_value_get_increment Ptr Value
obj'
let result' :: Double
result' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data ValueGetIncrementMethodInfo
instance (signature ~ (m Double), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetIncrementMethodInfo a signature where
overloadedMethod = valueGetIncrement
instance O.OverloadedMethodInfo ValueGetIncrementMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetIncrement",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetIncrement"
})
#endif
foreign import ccall "atk_value_get_maximum_value" atk_value_get_maximum_value ::
Ptr Value ->
Ptr GValue ->
IO ()
{-# DEPRECATED valueGetMaximumValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetRange' instead."] #-}
valueGetMaximumValue ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (GValue)
valueGetMaximumValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m GValue
valueGetMaximumValue a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr Value -> Ptr GValue -> IO ()
atk_value_get_maximum_value Ptr Value
obj' Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
#if defined(ENABLE_OVERLOADING)
data ValueGetMaximumValueMethodInfo
instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMaximumValueMethodInfo a signature where
overloadedMethod = valueGetMaximumValue
instance O.OverloadedMethodInfo ValueGetMaximumValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetMaximumValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetMaximumValue"
})
#endif
foreign import ccall "atk_value_get_minimum_increment" atk_value_get_minimum_increment ::
Ptr Value ->
Ptr GValue ->
IO ()
{-# DEPRECATED valueGetMinimumIncrement ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetIncrement' instead."] #-}
valueGetMinimumIncrement ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (GValue)
valueGetMinimumIncrement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m GValue
valueGetMinimumIncrement a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr Value -> Ptr GValue -> IO ()
atk_value_get_minimum_increment Ptr Value
obj' Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
#if defined(ENABLE_OVERLOADING)
data ValueGetMinimumIncrementMethodInfo
instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMinimumIncrementMethodInfo a signature where
overloadedMethod = valueGetMinimumIncrement
instance O.OverloadedMethodInfo ValueGetMinimumIncrementMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetMinimumIncrement",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetMinimumIncrement"
})
#endif
foreign import ccall "atk_value_get_minimum_value" atk_value_get_minimum_value ::
Ptr Value ->
Ptr GValue ->
IO ()
{-# DEPRECATED valueGetMinimumValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetRange' instead."] #-}
valueGetMinimumValue ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (GValue)
valueGetMinimumValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m GValue
valueGetMinimumValue a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr Value -> Ptr GValue -> IO ()
atk_value_get_minimum_value Ptr Value
obj' Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
#if defined(ENABLE_OVERLOADING)
data ValueGetMinimumValueMethodInfo
instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMinimumValueMethodInfo a signature where
overloadedMethod = valueGetMinimumValue
instance O.OverloadedMethodInfo ValueGetMinimumValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetMinimumValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetMinimumValue"
})
#endif
foreign import ccall "atk_value_get_range" atk_value_get_range ::
Ptr Value ->
IO (Ptr Atk.Range.Range)
valueGetRange ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (Maybe Atk.Range.Range)
valueGetRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m (Maybe Range)
valueGetRange a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr Range
result <- Ptr Value -> IO (Ptr Range)
atk_value_get_range Ptr Value
obj'
Maybe Range
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Range
result forall a b. (a -> b) -> a -> b
$ \Ptr Range
result' -> do
Range
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Range -> Range
Atk.Range.Range) Ptr Range
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Range
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Range
maybeResult
#if defined(ENABLE_OVERLOADING)
data ValueGetRangeMethodInfo
instance (signature ~ (m (Maybe Atk.Range.Range)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetRangeMethodInfo a signature where
overloadedMethod = valueGetRange
instance O.OverloadedMethodInfo ValueGetRangeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetRange"
})
#endif
foreign import ccall "atk_value_get_sub_ranges" atk_value_get_sub_ranges ::
Ptr Value ->
IO (Ptr (GSList (Ptr Atk.Range.Range)))
valueGetSubRanges ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m [Atk.Range.Range]
valueGetSubRanges :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m [Range]
valueGetSubRanges a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr (GSList (Ptr Range))
result <- Ptr Value -> IO (Ptr (GSList (Ptr Range)))
atk_value_get_sub_ranges Ptr Value
obj'
[Ptr Range]
result' <- forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Range))
result
[Range]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Range -> Range
Atk.Range.Range) [Ptr Range]
result'
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Range))
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return [Range]
result''
#if defined(ENABLE_OVERLOADING)
data ValueGetSubRangesMethodInfo
instance (signature ~ (m [Atk.Range.Range]), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetSubRangesMethodInfo a signature where
overloadedMethod = valueGetSubRanges
instance O.OverloadedMethodInfo ValueGetSubRangesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetSubRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetSubRanges"
})
#endif
foreign import ccall "atk_value_get_value_and_text" atk_value_get_value_and_text ::
Ptr Value ->
Ptr CDouble ->
Ptr CString ->
IO ()
valueGetValueAndText ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m ((Double, T.Text))
valueGetValueAndText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m (Double, Text)
valueGetValueAndText a
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr CDouble
value <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CString
text <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Value -> Ptr CDouble -> Ptr CString -> IO ()
atk_value_get_value_and_text Ptr Value
obj' Ptr CDouble
value Ptr CString
text
CDouble
value' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
value
let value'' :: Double
value'' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
value'
CString
text' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
text
Text
text'' <- HasCallStack => CString -> IO Text
cstringToText CString
text'
forall a. Ptr a -> IO ()
freeMem CString
text'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
value
forall a. Ptr a -> IO ()
freeMem Ptr CString
text
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
value'', Text
text'')
#if defined(ENABLE_OVERLOADING)
data ValueGetValueAndTextMethodInfo
instance (signature ~ (m ((Double, T.Text))), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetValueAndTextMethodInfo a signature where
overloadedMethod = valueGetValueAndText
instance O.OverloadedMethodInfo ValueGetValueAndTextMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueGetValueAndText",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueGetValueAndText"
})
#endif
foreign import ccall "atk_value_set_current_value" atk_value_set_current_value ::
Ptr Value ->
Ptr GValue ->
IO CInt
{-# DEPRECATED valueSetCurrentValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueSetValue' instead."] #-}
valueSetCurrentValue ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> GValue
-> m Bool
valueSetCurrentValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> GValue -> m Bool
valueSetCurrentValue a
obj GValue
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr GValue
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
CInt
result <- Ptr Value -> Ptr GValue -> IO CInt
atk_value_set_current_value Ptr Value
obj' Ptr GValue
value'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueSetCurrentValueMethodInfo
instance (signature ~ (GValue -> m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueSetCurrentValueMethodInfo a signature where
overloadedMethod = valueSetCurrentValue
instance O.OverloadedMethodInfo ValueSetCurrentValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueSetCurrentValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueSetCurrentValue"
})
#endif
foreign import ccall "atk_value_set_value" atk_value_set_value ::
Ptr Value ->
CDouble ->
IO ()
valueSetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> Double
-> m ()
valueSetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Double -> m ()
valueSetValue a
obj Double
newValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Value
obj' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
let newValue' :: CDouble
newValue' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
newValue
Ptr Value -> CDouble -> IO ()
atk_value_set_value Ptr Value
obj' CDouble
newValue'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ValueSetValueMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsValue a) => O.OverloadedMethod ValueSetValueMethodInfo a signature where
overloadedMethod = valueSetValue
instance O.OverloadedMethodInfo ValueSetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value.valueSetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#v:valueSetValue"
})
#endif
type ValueValueChangedCallback =
Double
-> T.Text
-> IO ()
type C_ValueValueChangedCallback =
Ptr Value ->
CDouble ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ValueValueChangedCallback :: C_ValueValueChangedCallback -> IO (FunPtr C_ValueValueChangedCallback)
wrap_ValueValueChangedCallback ::
GObject a => (a -> ValueValueChangedCallback) ->
C_ValueValueChangedCallback
wrap_ValueValueChangedCallback :: forall a.
GObject a =>
(a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
gi'cb Ptr Value
gi'selfPtr CDouble
value CString
text Ptr ()
_ = do
let value' :: Double
value' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
value
Text
text' <- HasCallStack => CString -> IO Text
cstringToText CString
text
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Value
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Value
gi'self -> a -> ValueValueChangedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Value
gi'self) Double
value' Text
text'
onValueValueChanged :: (IsValue a, MonadIO m) => a -> ((?self :: a) => ValueValueChangedCallback) -> m SignalHandlerId
onValueValueChanged :: forall a (m :: * -> *).
(IsValue a, MonadIO m) =>
a -> ((?self::a) => ValueValueChangedCallback) -> m SignalHandlerId
onValueValueChanged a
obj (?self::a) => ValueValueChangedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> ValueValueChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ValueValueChangedCallback
cb
let wrapped' :: C_ValueValueChangedCallback
wrapped' = forall a.
GObject a =>
(a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
wrapped
FunPtr C_ValueValueChangedCallback
wrapped'' <- C_ValueValueChangedCallback
-> IO (FunPtr C_ValueValueChangedCallback)
mk_ValueValueChangedCallback C_ValueValueChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"value-changed" FunPtr C_ValueValueChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterValueValueChanged :: (IsValue a, MonadIO m) => a -> ((?self :: a) => ValueValueChangedCallback) -> m SignalHandlerId
afterValueValueChanged :: forall a (m :: * -> *).
(IsValue a, MonadIO m) =>
a -> ((?self::a) => ValueValueChangedCallback) -> m SignalHandlerId
afterValueValueChanged a
obj (?self::a) => ValueValueChangedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> ValueValueChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ValueValueChangedCallback
cb
let wrapped' :: C_ValueValueChangedCallback
wrapped' = forall a.
GObject a =>
(a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
wrapped
FunPtr C_ValueValueChangedCallback
wrapped'' <- C_ValueValueChangedCallback
-> IO (FunPtr C_ValueValueChangedCallback)
mk_ValueValueChangedCallback C_ValueValueChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"value-changed" FunPtr C_ValueValueChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ValueValueChangedSignalInfo
instance SignalInfo ValueValueChangedSignalInfo where
type HaskellCallbackType ValueValueChangedSignalInfo = ValueValueChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ValueValueChangedCallback cb
cb'' <- mk_ValueValueChangedCallback cb'
connectSignalFunPtr obj "value-changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Interfaces.Value::value-changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Interfaces-Value.html#g:signal:valueChanged"})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Value = ValueSignalList
type ValueSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("valueChanged", ValueValueChangedSignalInfo)] :: [(Symbol, DK.Type)])
#endif