{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Objects.EngineLang
(
EngineLang(..) ,
IsEngineLang ,
toEngineLang ,
#if defined(ENABLE_OVERLOADING)
ResolveEngineLangMethod ,
#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.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.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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Pango.Objects.Engine as Pango.Engine
newtype EngineLang = EngineLang (SP.ManagedPtr EngineLang)
deriving (EngineLang -> EngineLang -> Bool
(EngineLang -> EngineLang -> Bool)
-> (EngineLang -> EngineLang -> Bool) -> Eq EngineLang
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EngineLang -> EngineLang -> Bool
$c/= :: EngineLang -> EngineLang -> Bool
== :: EngineLang -> EngineLang -> Bool
$c== :: EngineLang -> EngineLang -> Bool
Eq)
instance SP.ManagedPtrNewtype EngineLang where
toManagedPtr :: EngineLang -> ManagedPtr EngineLang
toManagedPtr (EngineLang ManagedPtr EngineLang
p) = ManagedPtr EngineLang
p
foreign import ccall "pango_engine_lang_get_type"
c_pango_engine_lang_get_type :: IO B.Types.GType
instance B.Types.TypedObject EngineLang where
glibType :: IO GType
glibType = IO GType
c_pango_engine_lang_get_type
instance B.Types.GObject EngineLang
class (SP.GObject o, O.IsDescendantOf EngineLang o) => IsEngineLang o
instance (SP.GObject o, O.IsDescendantOf EngineLang o) => IsEngineLang o
instance O.HasParentTypes EngineLang
type instance O.ParentTypes EngineLang = '[Pango.Engine.Engine, GObject.Object.Object]
toEngineLang :: (MIO.MonadIO m, IsEngineLang o) => o -> m EngineLang
toEngineLang :: forall (m :: * -> *) o.
(MonadIO m, IsEngineLang o) =>
o -> m EngineLang
toEngineLang = IO EngineLang -> m EngineLang
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO EngineLang -> m EngineLang)
-> (o -> IO EngineLang) -> o -> m EngineLang
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr EngineLang -> EngineLang) -> o -> IO EngineLang
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr EngineLang -> EngineLang
EngineLang
instance B.GValue.IsGValue (Maybe EngineLang) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_engine_lang_get_type
gvalueSet_ :: Ptr GValue -> Maybe EngineLang -> IO ()
gvalueSet_ Ptr GValue
gv Maybe EngineLang
P.Nothing = Ptr GValue -> Ptr EngineLang -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr EngineLang
forall a. Ptr a
FP.nullPtr :: FP.Ptr EngineLang)
gvalueSet_ Ptr GValue
gv (P.Just EngineLang
obj) = EngineLang -> (Ptr EngineLang -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EngineLang
obj (Ptr GValue -> Ptr EngineLang -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe EngineLang)
gvalueGet_ Ptr GValue
gv = do
Ptr EngineLang
ptr <- Ptr GValue -> IO (Ptr EngineLang)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr EngineLang)
if Ptr EngineLang
ptr Ptr EngineLang -> Ptr EngineLang -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr EngineLang
forall a. Ptr a
FP.nullPtr
then EngineLang -> Maybe EngineLang
forall a. a -> Maybe a
P.Just (EngineLang -> Maybe EngineLang)
-> IO EngineLang -> IO (Maybe EngineLang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr EngineLang -> EngineLang)
-> Ptr EngineLang -> IO EngineLang
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr EngineLang -> EngineLang
EngineLang Ptr EngineLang
ptr
else Maybe EngineLang -> IO (Maybe EngineLang)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe EngineLang
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveEngineLangMethod (t :: Symbol) (o :: *) :: * where
ResolveEngineLangMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveEngineLangMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveEngineLangMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveEngineLangMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveEngineLangMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveEngineLangMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveEngineLangMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveEngineLangMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveEngineLangMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveEngineLangMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveEngineLangMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveEngineLangMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveEngineLangMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveEngineLangMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveEngineLangMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveEngineLangMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveEngineLangMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveEngineLangMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveEngineLangMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveEngineLangMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveEngineLangMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveEngineLangMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveEngineLangMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEngineLangMethod t EngineLang, O.OverloadedMethod info EngineLang p) => OL.IsLabel t (EngineLang -> 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 ~ ResolveEngineLangMethod t EngineLang, O.OverloadedMethod info EngineLang p, R.HasField t EngineLang p) => R.HasField t EngineLang p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEngineLangMethod t EngineLang, O.OverloadedMethodInfo info EngineLang) => OL.IsLabel t (O.MethodProxy info EngineLang) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EngineLang
type instance O.AttributeList EngineLang = EngineLangAttributeList
type EngineLangAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EngineLang = EngineLangSignalList
type EngineLangSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif