{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.ConstantExpression
(
ConstantExpression(..) ,
IsConstantExpression ,
toConstantExpression ,
#if defined(ENABLE_OVERLOADING)
ResolveConstantExpressionMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ConstantExpressionGetValueMethodInfo ,
#endif
constantExpressionGetValue ,
constantExpressionNewForValue ,
) 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.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.Gtk.Objects.Expression as Gtk.Expression
newtype ConstantExpression = ConstantExpression (SP.ManagedPtr ConstantExpression)
deriving (ConstantExpression -> ConstantExpression -> Bool
(ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> Eq ConstantExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantExpression -> ConstantExpression -> Bool
== :: ConstantExpression -> ConstantExpression -> Bool
$c/= :: ConstantExpression -> ConstantExpression -> Bool
/= :: ConstantExpression -> ConstantExpression -> Bool
Eq)
instance SP.ManagedPtrNewtype ConstantExpression where
toManagedPtr :: ConstantExpression -> ManagedPtr ConstantExpression
toManagedPtr (ConstantExpression ManagedPtr ConstantExpression
p) = ManagedPtr ConstantExpression
p
foreign import ccall "gtk_constant_expression_get_type"
c_gtk_constant_expression_get_type :: IO B.Types.GType
instance B.Types.TypedObject ConstantExpression where
glibType :: IO GType
glibType = IO GType
c_gtk_constant_expression_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ConstantExpression o) => IsConstantExpression o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ConstantExpression o) => IsConstantExpression o
instance O.HasParentTypes ConstantExpression
type instance O.ParentTypes ConstantExpression = '[Gtk.Expression.Expression]
toConstantExpression :: (MIO.MonadIO m, IsConstantExpression o) => o -> m ConstantExpression
toConstantExpression :: forall (m :: * -> *) o.
(MonadIO m, IsConstantExpression o) =>
o -> m ConstantExpression
toConstantExpression = IO ConstantExpression -> m ConstantExpression
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ConstantExpression -> m ConstantExpression)
-> (o -> IO ConstantExpression) -> o -> m ConstantExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ConstantExpression -> ConstantExpression)
-> o -> IO ConstantExpression
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ConstantExpression -> ConstantExpression
ConstantExpression
#if defined(ENABLE_OVERLOADING)
type family ResolveConstantExpressionMethod (t :: Symbol) (o :: *) :: * where
ResolveConstantExpressionMethod "bind" o = Gtk.Expression.ExpressionBindMethodInfo
ResolveConstantExpressionMethod "evaluate" o = Gtk.Expression.ExpressionEvaluateMethodInfo
ResolveConstantExpressionMethod "isStatic" o = Gtk.Expression.ExpressionIsStaticMethodInfo
ResolveConstantExpressionMethod "ref" o = Gtk.Expression.ExpressionRefMethodInfo
ResolveConstantExpressionMethod "unref" o = Gtk.Expression.ExpressionUnrefMethodInfo
ResolveConstantExpressionMethod "watch" o = Gtk.Expression.ExpressionWatchMethodInfo
ResolveConstantExpressionMethod "getValue" o = ConstantExpressionGetValueMethodInfo
ResolveConstantExpressionMethod "getValueType" o = Gtk.Expression.ExpressionGetValueTypeMethodInfo
ResolveConstantExpressionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveConstantExpressionMethod t ConstantExpression, O.OverloadedMethod info ConstantExpression p) => OL.IsLabel t (ConstantExpression -> 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 ~ ResolveConstantExpressionMethod t ConstantExpression, O.OverloadedMethod info ConstantExpression p, R.HasField t ConstantExpression p) => R.HasField t ConstantExpression p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveConstantExpressionMethod t ConstantExpression, O.OverloadedMethodInfo info ConstantExpression) => OL.IsLabel t (O.MethodProxy info ConstantExpression) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
instance BoxedPtr ConstantExpression where
boxedPtrCopy :: ConstantExpression -> IO ConstantExpression
boxedPtrCopy = ConstantExpression -> IO ConstantExpression
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: ConstantExpression -> IO ()
boxedPtrFree = \ConstantExpression
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gtk_constant_expression_new_for_value" gtk_constant_expression_new_for_value ::
Ptr GValue ->
IO (Ptr ConstantExpression)
constantExpressionNewForValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> m ConstantExpression
constantExpressionNewForValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> m ConstantExpression
constantExpressionNewForValue GValue
value = IO ConstantExpression -> m ConstantExpression
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ConstantExpression -> m ConstantExpression)
-> IO ConstantExpression -> m ConstantExpression
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr ConstantExpression
result <- Ptr GValue -> IO (Ptr ConstantExpression)
gtk_constant_expression_new_for_value Ptr GValue
value'
Text -> Ptr ConstantExpression -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"constantExpressionNewForValue" Ptr ConstantExpression
result
ConstantExpression
result' <- ((ManagedPtr ConstantExpression -> ConstantExpression)
-> Ptr ConstantExpression -> IO ConstantExpression
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ConstantExpression -> ConstantExpression
ConstantExpression) Ptr ConstantExpression
result
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
ConstantExpression -> IO ConstantExpression
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConstantExpression
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_constant_expression_get_value" gtk_constant_expression_get_value ::
Ptr ConstantExpression ->
IO (Ptr GValue)
constantExpressionGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsConstantExpression a) =>
a
-> m GValue
constantExpressionGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsConstantExpression a) =>
a -> m GValue
constantExpressionGetValue a
expression = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr ConstantExpression
expression' <- a -> IO (Ptr ConstantExpression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
expression
Ptr GValue
result <- Ptr ConstantExpression -> IO (Ptr GValue)
gtk_constant_expression_get_value Ptr ConstantExpression
expression'
Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"constantExpressionGetValue" Ptr GValue
result
GValue
result' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
expression
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'
#if defined(ENABLE_OVERLOADING)
data ConstantExpressionGetValueMethodInfo
instance (signature ~ (m GValue), MonadIO m, IsConstantExpression a) => O.OverloadedMethod ConstantExpressionGetValueMethodInfo a signature where
overloadedMethod = constantExpressionGetValue
instance O.OverloadedMethodInfo ConstantExpressionGetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.ConstantExpression.constantExpressionGetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-ConstantExpression.html#v:constantExpressionGetValue"
})
#endif