{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GObject.Objects.ParamSpec.ParamSpec' is an object structure that encapsulates the metadata
-- required to specify parameters, such as e.g. t'GI.GObject.Objects.Object.Object' properties.
-- 
-- ## Parameter names # {@/canonical/@-parameter-names}
-- 
-- A property name consists of segments consisting of ASCII letters and
-- digits, separated by either the @-@ or @_@ character. The first
-- character of a property name must be a letter. These are the same rules as
-- for signal naming (see @/g_signal_new()/@).
-- 
-- When creating and looking up a t'GI.GObject.Objects.ParamSpec.ParamSpec', either separator can be
-- used, but they cannot be mixed. Using @-@ is considerably more
-- efficient, and is the ‘canonical form’. Using @_@ is discouraged.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GObject.Objects.ParamSpec
    ( 

-- * Exported types
    ParamSpec(..)                           ,
    IsParamSpec                             ,
    toParamSpec                             ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveParamSpecMethod                  ,
#endif


-- ** getBlurb #method:getBlurb#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetBlurbMethodInfo             ,
#endif
    paramSpecGetBlurb                       ,


-- ** getDefaultValue #method:getDefaultValue#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetDefaultValueMethodInfo      ,
#endif
    paramSpecGetDefaultValue                ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetNameMethodInfo              ,
#endif
    paramSpecGetName                        ,


-- ** getNameQuark #method:getNameQuark#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetNameQuarkMethodInfo         ,
#endif
    paramSpecGetNameQuark                   ,


-- ** getNick #method:getNick#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetNickMethodInfo              ,
#endif
    paramSpecGetNick                        ,


-- ** getQdata #method:getQdata#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetQdataMethodInfo             ,
#endif
    paramSpecGetQdata                       ,


-- ** getRedirectTarget #method:getRedirectTarget#

#if defined(ENABLE_OVERLOADING)
    ParamSpecGetRedirectTargetMethodInfo    ,
#endif
    paramSpecGetRedirectTarget              ,


-- ** setQdata #method:setQdata#

#if defined(ENABLE_OVERLOADING)
    ParamSpecSetQdataMethodInfo             ,
#endif
    paramSpecSetQdata                       ,


-- ** sink #method:sink#

#if defined(ENABLE_OVERLOADING)
    ParamSpecSinkMethodInfo                 ,
#endif
    paramSpecSink                           ,


-- ** stealQdata #method:stealQdata#

#if defined(ENABLE_OVERLOADING)
    ParamSpecStealQdataMethodInfo           ,
#endif
    paramSpecStealQdata                     ,




    ) 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


-- | Memory-managed wrapper type.
newtype ParamSpec = ParamSpec (SP.ManagedPtr ParamSpec)
    deriving (ParamSpec -> ParamSpec -> Bool
(ParamSpec -> ParamSpec -> Bool)
-> (ParamSpec -> ParamSpec -> Bool) -> Eq ParamSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParamSpec -> ParamSpec -> Bool
$c/= :: ParamSpec -> ParamSpec -> Bool
== :: ParamSpec -> ParamSpec -> Bool
$c== :: ParamSpec -> ParamSpec -> Bool
Eq)

instance SP.ManagedPtrNewtype ParamSpec where
    toManagedPtr :: ParamSpec -> ManagedPtr ParamSpec
toManagedPtr (ParamSpec ManagedPtr ParamSpec
p) = ManagedPtr ParamSpec
p

foreign import ccall "haskell_gi_pspec_type_init_ParamSpec"
    c_haskell_gi_pspec_type_init_ParamSpec :: IO B.Types.GType

instance B.Types.TypedObject ParamSpec where
    glibType :: IO GType
glibType = IO GType
c_haskell_gi_pspec_type_init_ParamSpec

-- | Type class for types which can be safely cast to `ParamSpec`, for instance with `toParamSpec`.
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ParamSpec o) => IsParamSpec o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ParamSpec o) => IsParamSpec o

instance O.HasParentTypes ParamSpec
type instance O.ParentTypes ParamSpec = '[]

-- | Cast to `ParamSpec`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toParamSpec :: (MonadIO m, IsParamSpec o) => o -> m ParamSpec
toParamSpec :: o -> m ParamSpec
toParamSpec = IO ParamSpec -> m ParamSpec
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ParamSpec -> m ParamSpec)
-> (o -> IO ParamSpec) -> o -> m ParamSpec
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ParamSpec -> ParamSpec) -> o -> IO ParamSpec
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr ParamSpec -> ParamSpec
ParamSpec

#if defined(ENABLE_OVERLOADING)
type family ResolveParamSpecMethod (t :: Symbol) (o :: *) :: * where
    ResolveParamSpecMethod "sink" o = ParamSpecSinkMethodInfo
    ResolveParamSpecMethod "stealQdata" o = ParamSpecStealQdataMethodInfo
    ResolveParamSpecMethod "getBlurb" o = ParamSpecGetBlurbMethodInfo
    ResolveParamSpecMethod "getDefaultValue" o = ParamSpecGetDefaultValueMethodInfo
    ResolveParamSpecMethod "getName" o = ParamSpecGetNameMethodInfo
    ResolveParamSpecMethod "getNameQuark" o = ParamSpecGetNameQuarkMethodInfo
    ResolveParamSpecMethod "getNick" o = ParamSpecGetNickMethodInfo
    ResolveParamSpecMethod "getQdata" o = ParamSpecGetQdataMethodInfo
    ResolveParamSpecMethod "getRedirectTarget" o = ParamSpecGetRedirectTargetMethodInfo
    ResolveParamSpecMethod "setQdata" o = ParamSpecSetQdataMethodInfo
    ResolveParamSpecMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveParamSpecMethod t ParamSpec, O.MethodInfo info ParamSpec p) => OL.IsLabel t (ParamSpec -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

foreign import ccall "g_param_spec_ref_sink" _ParamSpec_copy_g_param_spec_ref_sink :: Ptr a -> IO (Ptr a)

foreign import ccall "g_param_spec_unref" _ParamSpec_free_g_param_spec_unref :: Ptr a -> IO ()

instance BoxedPtr ParamSpec where
    boxedPtrCopy :: ParamSpec -> IO ParamSpec
boxedPtrCopy = \ParamSpec
p -> ParamSpec -> (Ptr ParamSpec -> IO ParamSpec) -> IO ParamSpec
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ParamSpec
p (Ptr ParamSpec -> IO (Ptr ParamSpec)
forall a. Ptr a -> IO (Ptr a)
_ParamSpec_copy_g_param_spec_ref_sink (Ptr ParamSpec -> IO (Ptr ParamSpec))
-> (Ptr ParamSpec -> IO ParamSpec) -> Ptr ParamSpec -> IO ParamSpec
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ParamSpec -> ParamSpec)
-> Ptr ParamSpec -> IO ParamSpec
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ParamSpec -> ParamSpec
ParamSpec)
    boxedPtrFree :: ParamSpec -> IO ()
boxedPtrFree = \ParamSpec
p -> ParamSpec -> (Ptr ParamSpec -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ParamSpec
p Ptr ParamSpec -> IO ()
forall a. Ptr a -> IO ()
_ParamSpec_free_g_param_spec_unref


-- method ParamSpec::get_blurb
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GParamSpec"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_blurb" g_param_spec_get_blurb :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO CString

-- | Get the short description of a t'GI.GObject.Objects.ParamSpec.ParamSpec'.
paramSpecGetBlurb ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a valid t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m T.Text
    -- ^ __Returns:__ the short description of /@pspec@/.
paramSpecGetBlurb :: GParamSpec -> m Text
paramSpecGetBlurb GParamSpec
pspec = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    CString
result <- Ptr GParamSpec -> IO CString
g_param_spec_get_blurb Ptr GParamSpec
pspec'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paramSpecGetBlurb" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetBlurbMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ParamSpecGetBlurbMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetBlurb

#endif

-- method ParamSpec::get_default_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpec" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TGValue
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_default_value" g_param_spec_get_default_value :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO (Ptr GValue)

-- | Gets the default value of /@pspec@/ as a pointer to a t'GI.GObject.Structs.Value.Value'.
-- 
-- The t'GI.GObject.Structs.Value.Value' will remain valid for the life of /@pspec@/.
-- 
-- /Since: 2.38/
paramSpecGetDefaultValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m GValue
    -- ^ __Returns:__ a pointer to a t'GI.GObject.Structs.Value.Value' which must not be modified
paramSpecGetDefaultValue :: GParamSpec -> m GValue
paramSpecGetDefaultValue GParamSpec
pspec = IO GValue -> m GValue
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 GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GValue
result <- Ptr GParamSpec -> IO (Ptr GValue)
g_param_spec_get_default_value Ptr GParamSpec
pspec'
    Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paramSpecGetDefaultValue" Ptr GValue
result
    GValue
result' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetDefaultValueMethodInfo
instance (signature ~ (m GValue), MonadIO m) => O.MethodInfo ParamSpecGetDefaultValueMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetDefaultValue

#endif

-- method ParamSpec::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GParamSpec"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_name" g_param_spec_get_name :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO CString

-- | Get the name of a t'GI.GObject.Objects.ParamSpec.ParamSpec'.
-- 
-- The name is always an \"interned\" string (as per 'GI.GLib.Functions.internString').
-- This allows for pointer-value comparisons.
paramSpecGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a valid t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m T.Text
    -- ^ __Returns:__ the name of /@pspec@/.
paramSpecGetName :: GParamSpec -> m Text
paramSpecGetName GParamSpec
pspec = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    CString
result <- Ptr GParamSpec -> IO CString
g_param_spec_get_name Ptr GParamSpec
pspec'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paramSpecGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ParamSpecGetNameMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetName

#endif

-- method ParamSpec::get_name_quark
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpec" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_name_quark" g_param_spec_get_name_quark :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO Word32

-- | Gets the GQuark for the name.
-- 
-- /Since: 2.46/
paramSpecGetNameQuark ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m Word32
    -- ^ __Returns:__ the GQuark for /@pspec@/->name.
paramSpecGetNameQuark :: GParamSpec -> m Word32
paramSpecGetNameQuark GParamSpec
pspec = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Word32
result <- Ptr GParamSpec -> IO Word32
g_param_spec_get_name_quark Ptr GParamSpec
pspec'
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetNameQuarkMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo ParamSpecGetNameQuarkMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetNameQuark

#endif

-- method ParamSpec::get_nick
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GParamSpec"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_nick" g_param_spec_get_nick :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO CString

-- | Get the nickname of a t'GI.GObject.Objects.ParamSpec.ParamSpec'.
paramSpecGetNick ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a valid t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m T.Text
    -- ^ __Returns:__ the nickname of /@pspec@/.
paramSpecGetNick :: GParamSpec -> m Text
paramSpecGetNick GParamSpec
pspec = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    CString
result <- Ptr GParamSpec -> IO CString
g_param_spec_get_nick Ptr GParamSpec
pspec'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paramSpecGetNick" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetNickMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ParamSpecGetNickMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetNick

#endif

-- method ParamSpec::get_qdata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GParamSpec"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "quark"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GQuark, naming the user data pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_qdata" g_param_spec_get_qdata :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Word32 ->                               -- quark : TBasicType TUInt32
    IO (Ptr ())

-- | Gets back user data pointers stored via 'GI.GObject.Objects.ParamSpec.paramSpecSetQdata'.
paramSpecGetQdata ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a valid t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> Word32
    -- ^ /@quark@/: a @/GQuark/@, naming the user data pointer
    -> m (Ptr ())
    -- ^ __Returns:__ the user data pointer set, or 'P.Nothing'
paramSpecGetQdata :: GParamSpec -> Word32 -> m (Ptr ())
paramSpecGetQdata GParamSpec
pspec Word32
quark = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr ()
result <- Ptr GParamSpec -> Word32 -> IO (Ptr ())
g_param_spec_get_qdata Ptr GParamSpec
pspec' Word32
quark
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo ParamSpecGetQdataMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetQdata

#endif

-- method ParamSpec::get_redirect_target
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpec" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TParamSpec
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_get_redirect_target" g_param_spec_get_redirect_target :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO (Ptr GParamSpec)

-- | If the paramspec redirects operations to another paramspec,
-- returns that paramspec. Redirect is used typically for
-- providing a new implementation of a property in a derived
-- type while preserving all the properties from the parent
-- type. Redirection is established by creating a property
-- of type t'GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride'. See 'GI.GObject.Structs.ObjectClass.objectClassOverrideProperty'
-- for an example of the use of this capability.
-- 
-- /Since: 2.4/
paramSpecGetRedirectTarget ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m GParamSpec
    -- ^ __Returns:__ paramspec to which requests on this
    --          paramspec should be redirected, or 'P.Nothing' if none.
paramSpecGetRedirectTarget :: GParamSpec -> m GParamSpec
paramSpecGetRedirectTarget GParamSpec
pspec = IO GParamSpec -> m GParamSpec
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GParamSpec -> m GParamSpec) -> IO GParamSpec -> m GParamSpec
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GParamSpec
result <- Ptr GParamSpec -> IO (Ptr GParamSpec)
g_param_spec_get_redirect_target Ptr GParamSpec
pspec'
    Text -> Ptr GParamSpec -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paramSpecGetRedirectTarget" Ptr GParamSpec
result
    GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'

#if defined(ENABLE_OVERLOADING)
data ParamSpecGetRedirectTargetMethodInfo
instance (signature ~ (m GParamSpec), MonadIO m) => O.MethodInfo ParamSpecGetRedirectTargetMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecGetRedirectTarget

#endif

-- method ParamSpec::set_qdata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GParamSpec to set store a user data pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "quark"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GQuark, naming the user data pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an opaque user data pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_set_qdata" g_param_spec_set_qdata :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Word32 ->                               -- quark : TBasicType TUInt32
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | Sets an opaque, named pointer on a t'GI.GObject.Objects.ParamSpec.ParamSpec'. The name is
-- specified through a @/GQuark/@ (retrieved e.g. via
-- 'GI.GLib.Functions.quarkFromStaticString'), and the pointer can be gotten back
-- from the /@pspec@/ with 'GI.GObject.Objects.ParamSpec.paramSpecGetQdata'.  Setting a
-- previously set user data pointer, overrides (frees) the old pointer
-- set, using 'P.Nothing' as pointer essentially removes the data stored.
paramSpecSetQdata ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' to set store a user data pointer
    -> Word32
    -- ^ /@quark@/: a @/GQuark/@, naming the user data pointer
    -> Ptr ()
    -- ^ /@data@/: an opaque user data pointer
    -> m ()
paramSpecSetQdata :: GParamSpec -> Word32 -> Ptr () -> m ()
paramSpecSetQdata GParamSpec
pspec Word32
quark Ptr ()
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GParamSpec -> Word32 -> Ptr () -> IO ()
g_param_spec_set_qdata Ptr GParamSpec
pspec' Word32
quark Ptr ()
data_
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ParamSpecSetQdataMethodInfo
instance (signature ~ (Word32 -> Ptr () -> m ()), MonadIO m) => O.MethodInfo ParamSpecSetQdataMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecSetQdata

#endif

-- method ParamSpec::sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a valid #GParamSpec"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_sink" g_param_spec_sink :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | The initial reference count of a newly created t'GI.GObject.Objects.ParamSpec.ParamSpec' is 1,
-- even though no one has explicitly called @/g_param_spec_ref()/@ on it
-- yet. So the initial reference count is flagged as \"floating\", until
-- someone calls @g_param_spec_ref (pspec); g_param_spec_sink
-- (pspec);@ in sequence on it, taking over the initial
-- reference count (thus ending up with a /@pspec@/ that has a reference
-- count of 1 still, but is not flagged \"floating\" anymore).
paramSpecSink ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: a valid t'GI.GObject.Objects.ParamSpec.ParamSpec'
    -> m ()
paramSpecSink :: GParamSpec -> m ()
paramSpecSink GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GParamSpec -> IO ()
g_param_spec_sink Ptr GParamSpec
pspec'
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ParamSpecSinkMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ParamSpecSinkMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecSink

#endif

-- method ParamSpec::steal_qdata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GParamSpec to get a stored user data pointer from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "quark"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GQuark, naming the user data pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_steal_qdata" g_param_spec_steal_qdata :: 
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Word32 ->                               -- quark : TBasicType TUInt32
    IO (Ptr ())

-- | Gets back user data pointers stored via 'GI.GObject.Objects.ParamSpec.paramSpecSetQdata'
-- and removes the /@data@/ from /@pspec@/ without invoking its @/destroy()/@
-- function (if any was set).  Usually, calling this function is only
-- required to update user data pointers with a destroy notifier.
paramSpecStealQdata ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' to get a stored user data pointer from
    -> Word32
    -- ^ /@quark@/: a @/GQuark/@, naming the user data pointer
    -> m (Ptr ())
    -- ^ __Returns:__ the user data pointer set, or 'P.Nothing'
paramSpecStealQdata :: GParamSpec -> Word32 -> m (Ptr ())
paramSpecStealQdata GParamSpec
pspec Word32
quark = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr ()
result <- Ptr GParamSpec -> Word32 -> IO (Ptr ())
g_param_spec_steal_qdata Ptr GParamSpec
pspec' Word32
quark
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ParamSpecStealQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo ParamSpecStealQdataMethodInfo GParamSpec signature where
    overloadedMethod = paramSpecStealQdata

#endif