{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.LayoutMeta
(
LayoutMeta(..) ,
IsLayoutMeta ,
toLayoutMeta ,
#if defined(ENABLE_OVERLOADING)
ResolveLayoutMetaMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
LayoutMetaGetManagerMethodInfo ,
#endif
layoutMetaGetManager ,
#if defined(ENABLE_OVERLOADING)
LayoutMetaManagerPropertyInfo ,
#endif
constructLayoutMetaManager ,
getLayoutMetaManager ,
#if defined(ENABLE_OVERLOADING)
layoutMetaManager ,
#endif
) 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.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import qualified GI.GObject.Objects.Object as GObject.Object
newtype LayoutMeta = LayoutMeta (SP.ManagedPtr LayoutMeta)
deriving (LayoutMeta -> LayoutMeta -> Bool
(LayoutMeta -> LayoutMeta -> Bool)
-> (LayoutMeta -> LayoutMeta -> Bool) -> Eq LayoutMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LayoutMeta -> LayoutMeta -> Bool
== :: LayoutMeta -> LayoutMeta -> Bool
$c/= :: LayoutMeta -> LayoutMeta -> Bool
/= :: LayoutMeta -> LayoutMeta -> Bool
Eq)
instance SP.ManagedPtrNewtype LayoutMeta where
toManagedPtr :: LayoutMeta -> ManagedPtr LayoutMeta
toManagedPtr (LayoutMeta ManagedPtr LayoutMeta
p) = ManagedPtr LayoutMeta
p
foreign import ccall "clutter_layout_meta_get_type"
c_clutter_layout_meta_get_type :: IO B.Types.GType
instance B.Types.TypedObject LayoutMeta where
glibType :: IO GType
glibType = IO GType
c_clutter_layout_meta_get_type
instance B.Types.GObject LayoutMeta
class (SP.GObject o, O.IsDescendantOf LayoutMeta o) => IsLayoutMeta o
instance (SP.GObject o, O.IsDescendantOf LayoutMeta o) => IsLayoutMeta o
instance O.HasParentTypes LayoutMeta
type instance O.ParentTypes LayoutMeta = '[Clutter.ChildMeta.ChildMeta, GObject.Object.Object]
toLayoutMeta :: (MIO.MonadIO m, IsLayoutMeta o) => o -> m LayoutMeta
toLayoutMeta :: forall (m :: * -> *) o.
(MonadIO m, IsLayoutMeta o) =>
o -> m LayoutMeta
toLayoutMeta = IO LayoutMeta -> m LayoutMeta
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO LayoutMeta -> m LayoutMeta)
-> (o -> IO LayoutMeta) -> o -> m LayoutMeta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr LayoutMeta -> LayoutMeta) -> o -> IO LayoutMeta
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr LayoutMeta -> LayoutMeta
LayoutMeta
instance B.GValue.IsGValue (Maybe LayoutMeta) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_layout_meta_get_type
gvalueSet_ :: Ptr GValue -> Maybe LayoutMeta -> IO ()
gvalueSet_ Ptr GValue
gv Maybe LayoutMeta
P.Nothing = Ptr GValue -> Ptr LayoutMeta -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr LayoutMeta
forall a. Ptr a
FP.nullPtr :: FP.Ptr LayoutMeta)
gvalueSet_ Ptr GValue
gv (P.Just LayoutMeta
obj) = LayoutMeta -> (Ptr LayoutMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr LayoutMeta
obj (Ptr GValue -> Ptr LayoutMeta -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe LayoutMeta)
gvalueGet_ Ptr GValue
gv = do
Ptr LayoutMeta
ptr <- Ptr GValue -> IO (Ptr LayoutMeta)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr LayoutMeta)
if Ptr LayoutMeta
ptr Ptr LayoutMeta -> Ptr LayoutMeta -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr LayoutMeta
forall a. Ptr a
FP.nullPtr
then LayoutMeta -> Maybe LayoutMeta
forall a. a -> Maybe a
P.Just (LayoutMeta -> Maybe LayoutMeta)
-> IO LayoutMeta -> IO (Maybe LayoutMeta)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr LayoutMeta -> LayoutMeta)
-> Ptr LayoutMeta -> IO LayoutMeta
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr LayoutMeta -> LayoutMeta
LayoutMeta Ptr LayoutMeta
ptr
else Maybe LayoutMeta -> IO (Maybe LayoutMeta)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe LayoutMeta
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveLayoutMetaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveLayoutMetaMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveLayoutMetaMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveLayoutMetaMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveLayoutMetaMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveLayoutMetaMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveLayoutMetaMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveLayoutMetaMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveLayoutMetaMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveLayoutMetaMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveLayoutMetaMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveLayoutMetaMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveLayoutMetaMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveLayoutMetaMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveLayoutMetaMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveLayoutMetaMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveLayoutMetaMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveLayoutMetaMethod "getActor" o = Clutter.ChildMeta.ChildMetaGetActorMethodInfo
ResolveLayoutMetaMethod "getContainer" o = Clutter.ChildMeta.ChildMetaGetContainerMethodInfo
ResolveLayoutMetaMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveLayoutMetaMethod "getManager" o = LayoutMetaGetManagerMethodInfo
ResolveLayoutMetaMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveLayoutMetaMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveLayoutMetaMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveLayoutMetaMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveLayoutMetaMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveLayoutMetaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveLayoutMetaMethod t LayoutMeta, O.OverloadedMethod info LayoutMeta p) => OL.IsLabel t (LayoutMeta -> 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 ~ ResolveLayoutMetaMethod t LayoutMeta, O.OverloadedMethod info LayoutMeta p, R.HasField t LayoutMeta p) => R.HasField t LayoutMeta p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveLayoutMetaMethod t LayoutMeta, O.OverloadedMethodInfo info LayoutMeta) => OL.IsLabel t (O.MethodProxy info LayoutMeta) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getLayoutMetaManager :: (MonadIO m, IsLayoutMeta o) => o -> m Clutter.LayoutManager.LayoutManager
getLayoutMetaManager :: forall (m :: * -> *) o.
(MonadIO m, IsLayoutMeta o) =>
o -> m LayoutManager
getLayoutMetaManager o
obj = IO LayoutManager -> m LayoutManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO LayoutManager -> m LayoutManager)
-> IO LayoutManager -> m LayoutManager
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe LayoutManager) -> IO LayoutManager
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getLayoutMetaManager" (IO (Maybe LayoutManager) -> IO LayoutManager)
-> IO (Maybe LayoutManager) -> IO LayoutManager
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr LayoutManager -> LayoutManager)
-> IO (Maybe LayoutManager)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"manager" ManagedPtr LayoutManager -> LayoutManager
Clutter.LayoutManager.LayoutManager
constructLayoutMetaManager :: (IsLayoutMeta o, MIO.MonadIO m, Clutter.LayoutManager.IsLayoutManager a) => a -> m (GValueConstruct o)
constructLayoutMetaManager :: forall o (m :: * -> *) a.
(IsLayoutMeta o, MonadIO m, IsLayoutManager a) =>
a -> m (GValueConstruct o)
constructLayoutMetaManager a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"manager" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data LayoutMetaManagerPropertyInfo
instance AttrInfo LayoutMetaManagerPropertyInfo where
type AttrAllowedOps LayoutMetaManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint LayoutMetaManagerPropertyInfo = IsLayoutMeta
type AttrSetTypeConstraint LayoutMetaManagerPropertyInfo = Clutter.LayoutManager.IsLayoutManager
type AttrTransferTypeConstraint LayoutMetaManagerPropertyInfo = Clutter.LayoutManager.IsLayoutManager
type AttrTransferType LayoutMetaManagerPropertyInfo = Clutter.LayoutManager.LayoutManager
type AttrGetType LayoutMetaManagerPropertyInfo = Clutter.LayoutManager.LayoutManager
type AttrLabel LayoutMetaManagerPropertyInfo = "manager"
type AttrOrigin LayoutMetaManagerPropertyInfo = LayoutMeta
attrGet = getLayoutMetaManager
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Clutter.LayoutManager.LayoutManager v
attrConstruct = constructLayoutMetaManager
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.LayoutMeta.manager"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-LayoutMeta.html#g:attr:manager"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList LayoutMeta
type instance O.AttributeList LayoutMeta = LayoutMetaAttributeList
type LayoutMetaAttributeList = ('[ '("actor", Clutter.ChildMeta.ChildMetaActorPropertyInfo), '("container", Clutter.ChildMeta.ChildMetaContainerPropertyInfo), '("manager", LayoutMetaManagerPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
layoutMetaManager :: AttrLabelProxy "manager"
layoutMetaManager = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList LayoutMeta = LayoutMetaSignalList
type LayoutMetaSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_layout_meta_get_manager" clutter_layout_meta_get_manager ::
Ptr LayoutMeta ->
IO (Ptr Clutter.LayoutManager.LayoutManager)
layoutMetaGetManager ::
(B.CallStack.HasCallStack, MonadIO m, IsLayoutMeta a) =>
a
-> m Clutter.LayoutManager.LayoutManager
layoutMetaGetManager :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayoutMeta a) =>
a -> m LayoutManager
layoutMetaGetManager a
data_ = IO LayoutManager -> m LayoutManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LayoutManager -> m LayoutManager)
-> IO LayoutManager -> m LayoutManager
forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutMeta
data_' <- a -> IO (Ptr LayoutMeta)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
data_
Ptr LayoutManager
result <- Ptr LayoutMeta -> IO (Ptr LayoutManager)
clutter_layout_meta_get_manager Ptr LayoutMeta
data_'
Text -> Ptr LayoutManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layoutMetaGetManager" Ptr LayoutManager
result
LayoutManager
result' <- ((ManagedPtr LayoutManager -> LayoutManager)
-> Ptr LayoutManager -> IO LayoutManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LayoutManager -> LayoutManager
Clutter.LayoutManager.LayoutManager) Ptr LayoutManager
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
data_
LayoutManager -> IO LayoutManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutManager
result'
#if defined(ENABLE_OVERLOADING)
data LayoutMetaGetManagerMethodInfo
instance (signature ~ (m Clutter.LayoutManager.LayoutManager), MonadIO m, IsLayoutMeta a) => O.OverloadedMethod LayoutMetaGetManagerMethodInfo a signature where
overloadedMethod = layoutMetaGetManager
instance O.OverloadedMethodInfo LayoutMetaGetManagerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.LayoutMeta.layoutMetaGetManager",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Objects-LayoutMeta.html#v:layoutMetaGetManager"
})
#endif