{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- All the fields in the GObject structure are private
-- to the t'GI.GObject.Objects.Object.Object' implementation and should never be accessed directly.

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

module GI.GObject.Objects.Object
    ( 
#if defined(ENABLE_OVERLOADING)
    ObjectInterfaceListPropertiesMethodInfo ,
#endif

-- * Exported types
    Object(..)                              ,
    IsObject                                ,
    toObject                                ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveObjectMethod                     ,
#endif


-- ** bindProperty #method:bindProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectBindPropertyMethodInfo            ,
#endif
    objectBindProperty                      ,


-- ** bindPropertyFull #method:bindPropertyFull#

#if defined(ENABLE_OVERLOADING)
    ObjectBindPropertyFullMethodInfo        ,
#endif
    objectBindPropertyFull                  ,


-- ** compatControl #method:compatControl#

    objectCompatControl                     ,


-- ** forceFloating #method:forceFloating#

#if defined(ENABLE_OVERLOADING)
    ObjectForceFloatingMethodInfo           ,
#endif
    objectForceFloating                     ,


-- ** freezeNotify #method:freezeNotify#

#if defined(ENABLE_OVERLOADING)
    ObjectFreezeNotifyMethodInfo            ,
#endif
    objectFreezeNotify                      ,


-- ** getData #method:getData#

#if defined(ENABLE_OVERLOADING)
    ObjectGetDataMethodInfo                 ,
#endif
    objectGetData                           ,


-- ** getProperty #method:getProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectGetPropertyMethodInfo             ,
#endif
    objectGetProperty                       ,


-- ** getQdata #method:getQdata#

#if defined(ENABLE_OVERLOADING)
    ObjectGetQdataMethodInfo                ,
#endif
    objectGetQdata                          ,


-- ** getv #method:getv#

#if defined(ENABLE_OVERLOADING)
    ObjectGetvMethodInfo                    ,
#endif
    objectGetv                              ,


-- ** interfaceFindProperty #method:interfaceFindProperty#

    objectInterfaceFindProperty             ,


-- ** interfaceInstallProperty #method:interfaceInstallProperty#

    objectInterfaceInstallProperty          ,


-- ** isFloating #method:isFloating#

#if defined(ENABLE_OVERLOADING)
    ObjectIsFloatingMethodInfo              ,
#endif
    objectIsFloating                        ,


-- ** newv #method:newv#

    objectNewv                              ,


-- ** notify #method:notify#

#if defined(ENABLE_OVERLOADING)
    ObjectNotifyMethodInfo                  ,
#endif
    objectNotify                            ,


-- ** notifyByPspec #method:notifyByPspec#

#if defined(ENABLE_OVERLOADING)
    ObjectNotifyByPspecMethodInfo           ,
#endif
    objectNotifyByPspec                     ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    ObjectRefMethodInfo                     ,
#endif
    objectRef                               ,


-- ** refSink #method:refSink#

#if defined(ENABLE_OVERLOADING)
    ObjectRefSinkMethodInfo                 ,
#endif
    objectRefSink                           ,


-- ** runDispose #method:runDispose#

#if defined(ENABLE_OVERLOADING)
    ObjectRunDisposeMethodInfo              ,
#endif
    objectRunDispose                        ,


-- ** setData #method:setData#

#if defined(ENABLE_OVERLOADING)
    ObjectSetDataMethodInfo                 ,
#endif
    objectSetData                           ,


-- ** setDataFull #method:setDataFull#

#if defined(ENABLE_OVERLOADING)
    ObjectSetDataFullMethodInfo             ,
#endif
    objectSetDataFull                       ,


-- ** setProperty #method:setProperty#

#if defined(ENABLE_OVERLOADING)
    ObjectSetPropertyMethodInfo             ,
#endif
    objectSetProperty                       ,


-- ** stealData #method:stealData#

#if defined(ENABLE_OVERLOADING)
    ObjectStealDataMethodInfo               ,
#endif
    objectStealData                         ,


-- ** stealQdata #method:stealQdata#

#if defined(ENABLE_OVERLOADING)
    ObjectStealQdataMethodInfo              ,
#endif
    objectStealQdata                        ,


-- ** thawNotify #method:thawNotify#

#if defined(ENABLE_OVERLOADING)
    ObjectThawNotifyMethodInfo              ,
#endif
    objectThawNotify                        ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    ObjectUnrefMethodInfo                   ,
#endif
    objectUnref                             ,


-- ** watchClosure #method:watchClosure#

#if defined(ENABLE_OVERLOADING)
    ObjectWatchClosureMethodInfo            ,
#endif
    objectWatchClosure                      ,




 -- * Signals
-- ** notify #signal:notify#

    C_ObjectNotifyCallback                  ,
    ObjectNotifyCallback                    ,
#if defined(ENABLE_OVERLOADING)
    ObjectNotifySignalInfo                  ,
#endif
    afterObjectNotify                       ,
    genClosure_ObjectNotify                 ,
    mk_ObjectNotifyCallback                 ,
    noObjectNotifyCallback                  ,
    onObjectNotify                          ,
    wrap_ObjectNotifyCallback               ,




    ) 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 GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
import {-# SOURCE #-} qualified GI.GObject.Objects.Binding as GObject.Binding
import {-# SOURCE #-} qualified GI.GObject.Structs.Parameter as GObject.Parameter
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInterface as GObject.TypeInterface

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

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

foreign import ccall "g_object_get_type"
    c_g_object_get_type :: IO B.Types.GType

instance B.Types.TypedObject Object where
    glibType :: IO GType
glibType = IO GType
c_g_object_get_type

instance B.Types.GObject Object

-- | Convert 'Object' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Object where
    toGValue :: Object -> IO GValue
toGValue Object
o = do
        GType
gtype <- IO GType
c_g_object_get_type
        Object -> (Ptr Object -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Object
o (GType -> (GValue -> Ptr Object -> IO ()) -> Ptr Object -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Object -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Object
fromGValue GValue
gv = do
        Ptr Object
ptr <- GValue -> IO (Ptr Object)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Object)
        (ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Object -> Object
Object Ptr Object
ptr
        
    

-- | Type class for types which can be safely cast to `Object`, for instance with `toObject`.
class (SP.GObject o, O.IsDescendantOf Object o) => IsObject o
instance (SP.GObject o, O.IsDescendantOf Object o) => IsObject o

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where
    ResolveObjectMethod "bindProperty" o = ObjectBindPropertyMethodInfo
    ResolveObjectMethod "bindPropertyFull" o = ObjectBindPropertyFullMethodInfo
    ResolveObjectMethod "forceFloating" o = ObjectForceFloatingMethodInfo
    ResolveObjectMethod "freezeNotify" o = ObjectFreezeNotifyMethodInfo
    ResolveObjectMethod "getv" o = ObjectGetvMethodInfo
    ResolveObjectMethod "isFloating" o = ObjectIsFloatingMethodInfo
    ResolveObjectMethod "notify" o = ObjectNotifyMethodInfo
    ResolveObjectMethod "notifyByPspec" o = ObjectNotifyByPspecMethodInfo
    ResolveObjectMethod "ref" o = ObjectRefMethodInfo
    ResolveObjectMethod "refSink" o = ObjectRefSinkMethodInfo
    ResolveObjectMethod "runDispose" o = ObjectRunDisposeMethodInfo
    ResolveObjectMethod "stealData" o = ObjectStealDataMethodInfo
    ResolveObjectMethod "stealQdata" o = ObjectStealQdataMethodInfo
    ResolveObjectMethod "thawNotify" o = ObjectThawNotifyMethodInfo
    ResolveObjectMethod "unref" o = ObjectUnrefMethodInfo
    ResolveObjectMethod "watchClosure" o = ObjectWatchClosureMethodInfo
    ResolveObjectMethod "getData" o = ObjectGetDataMethodInfo
    ResolveObjectMethod "getProperty" o = ObjectGetPropertyMethodInfo
    ResolveObjectMethod "getQdata" o = ObjectGetQdataMethodInfo
    ResolveObjectMethod "setData" o = ObjectSetDataMethodInfo
    ResolveObjectMethod "setDataFull" o = ObjectSetDataFullMethodInfo
    ResolveObjectMethod "setProperty" o = ObjectSetPropertyMethodInfo
    ResolveObjectMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Object::notify
-- | The notify signal is emitted on an object when one of its properties has
-- its value set through 'GI.GObject.Objects.Object.objectSetProperty', @/g_object_set()/@, et al.
-- 
-- Note that getting this signal doesn’t itself guarantee that the value of
-- the property has actually changed. When it is emitted is determined by the
-- derived GObject class. If the implementor did not create the property with
-- 'GI.GObject.Flags.ParamFlagsExplicitNotify', then any call to 'GI.GObject.Objects.Object.objectSetProperty' results
-- in [notify](#g:signal:notify) being emitted, even if the new value is the same as the old.
-- If they did pass 'GI.GObject.Flags.ParamFlagsExplicitNotify', then this signal is emitted only
-- when they explicitly call 'GI.GObject.Objects.Object.objectNotify' or 'GI.GObject.Objects.Object.objectNotifyByPspec',
-- and common practice is to do that only when the value has actually changed.
-- 
-- This signal is typically used to obtain change notification for a
-- single property, by specifying the property name as a detail in the
-- @/g_signal_connect()/@ call, like this:
-- 
-- === /C code/
-- >
-- >g_signal_connect (text_view->buffer, "notify::paste-target-list",
-- >                  G_CALLBACK (gtk_text_view_target_list_notify),
-- >                  text_view)
-- 
-- It is important to note that you must use
-- [canonical parameter names][canonical-parameter-names] as
-- detail strings for the notify signal.
type ObjectNotifyCallback =
    GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the property which changed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectNotifyCallback`@.
noObjectNotifyCallback :: Maybe ObjectNotifyCallback
noObjectNotifyCallback :: Maybe ObjectNotifyCallback
noObjectNotifyCallback = Maybe ObjectNotifyCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectNotifyCallback =
    Ptr () ->                               -- object
    Ptr GParamSpec ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectNotifyCallback`.
foreign import ccall "wrapper"
    mk_ObjectNotifyCallback :: C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_ObjectNotify :: MonadIO m => ObjectNotifyCallback -> m (GClosure C_ObjectNotifyCallback)
genClosure_ObjectNotify :: ObjectNotifyCallback -> m (GClosure C_ObjectNotifyCallback)
genClosure_ObjectNotify ObjectNotifyCallback
cb = IO (GClosure C_ObjectNotifyCallback)
-> m (GClosure C_ObjectNotifyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ObjectNotifyCallback)
 -> m (GClosure C_ObjectNotifyCallback))
-> IO (GClosure C_ObjectNotifyCallback)
-> m (GClosure C_ObjectNotifyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ObjectNotifyCallback
cb' = ObjectNotifyCallback -> C_ObjectNotifyCallback
wrap_ObjectNotifyCallback ObjectNotifyCallback
cb
    C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)
mk_ObjectNotifyCallback C_ObjectNotifyCallback
cb' IO (FunPtr C_ObjectNotifyCallback)
-> (FunPtr C_ObjectNotifyCallback
    -> IO (GClosure C_ObjectNotifyCallback))
-> IO (GClosure C_ObjectNotifyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ObjectNotifyCallback
-> IO (GClosure C_ObjectNotifyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ObjectNotifyCallback` into a `C_ObjectNotifyCallback`.
wrap_ObjectNotifyCallback ::
    ObjectNotifyCallback ->
    C_ObjectNotifyCallback
wrap_ObjectNotifyCallback :: ObjectNotifyCallback -> C_ObjectNotifyCallback
wrap_ObjectNotifyCallback ObjectNotifyCallback
_cb Ptr ()
_ Ptr GParamSpec
pspec Ptr ()
_ = do
    GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
    ObjectNotifyCallback
_cb  GParamSpec
pspec'


-- | Connect a signal handler for the [notify](#signal:notify) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #notify callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@notify::detail@” instead.
-- 
onObjectNotify :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ObjectNotifyCallback -> m SignalHandlerId
onObjectNotify :: a -> Maybe Text -> ObjectNotifyCallback -> m SignalHandlerId
onObjectNotify a
obj Maybe Text
detail ObjectNotifyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ObjectNotifyCallback
cb' = ObjectNotifyCallback -> C_ObjectNotifyCallback
wrap_ObjectNotifyCallback ObjectNotifyCallback
cb
    FunPtr C_ObjectNotifyCallback
cb'' <- C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)
mk_ObjectNotifyCallback C_ObjectNotifyCallback
cb'
    a
-> Text
-> FunPtr C_ObjectNotifyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"notify" FunPtr C_ObjectNotifyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [notify](#signal:notify) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #notify callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@notify::detail@” instead.
-- 
afterObjectNotify :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ObjectNotifyCallback -> m SignalHandlerId
afterObjectNotify :: a -> Maybe Text -> ObjectNotifyCallback -> m SignalHandlerId
afterObjectNotify a
obj Maybe Text
detail ObjectNotifyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ObjectNotifyCallback
cb' = ObjectNotifyCallback -> C_ObjectNotifyCallback
wrap_ObjectNotifyCallback ObjectNotifyCallback
cb
    FunPtr C_ObjectNotifyCallback
cb'' <- C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)
mk_ObjectNotifyCallback C_ObjectNotifyCallback
cb'
    a
-> Text
-> FunPtr C_ObjectNotifyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"notify" FunPtr C_ObjectNotifyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data ObjectNotifySignalInfo
instance SignalInfo ObjectNotifySignalInfo where
    type HaskellCallbackType ObjectNotifySignalInfo = ObjectNotifyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ObjectNotifyCallback cb
        cb'' <- mk_ObjectNotifyCallback cb'
        connectSignalFunPtr obj "notify" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Object
type instance O.AttributeList Object = ObjectAttributeList
type ObjectAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Object = ObjectSignalList
type ObjectSignalList = ('[ '("notify", ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Object::newv
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "object_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the type id of the #GObject subtype to instantiate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_parameters"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of the @parameters array"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameters"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 1
--                 (TInterface Name { namespace = "GObject" , name = "Parameter" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of #GParameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_parameters"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the length of the @parameters array"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "g_object_newv" g_object_newv :: 
    CGType ->                               -- object_type : TBasicType TGType
    Word32 ->                               -- n_parameters : TBasicType TUInt
    Ptr GObject.Parameter.Parameter ->      -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "GObject", name = "Parameter"}))
    IO (Ptr Object)

{-# DEPRECATED objectNewv ["(Since version 2.54)","Use @/g_object_new_with_properties()/@ instead.","deprecated. See t'GI.GObject.Structs.Parameter.Parameter' for more information."] #-}
-- | Creates a new instance of a t'GI.GObject.Objects.Object.Object' subtype and sets its properties.
-- 
-- Construction parameters (see @/G_PARAM_CONSTRUCT/@, @/G_PARAM_CONSTRUCT_ONLY/@)
-- which are not explicitly specified are set to their default values.
objectNewv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GType
    -- ^ /@objectType@/: the type id of the t'GI.GObject.Objects.Object.Object' subtype to instantiate
    -> [GObject.Parameter.Parameter]
    -- ^ /@parameters@/: an array of t'GI.GObject.Structs.Parameter.Parameter'
    -> m Object
    -- ^ __Returns:__ a new instance of
    -- /@objectType@/
objectNewv :: GType -> [Parameter] -> m Object
objectNewv GType
objectType [Parameter]
parameters = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    let nParameters :: Word32
nParameters = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Parameter] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Parameter]
parameters
    let objectType' :: CGType
objectType' = GType -> CGType
gtypeToCGType GType
objectType
    [Ptr Parameter]
parameters' <- (Parameter -> IO (Ptr Parameter))
-> [Parameter] -> IO [Ptr Parameter]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Parameter -> IO (Ptr Parameter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Parameter]
parameters
    Ptr Parameter
parameters'' <- Int -> [Ptr Parameter] -> IO (Ptr Parameter)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
32 [Ptr Parameter]
parameters'
    Ptr Object
result <- CGType -> Word32 -> Ptr Parameter -> IO (Ptr Object)
g_object_newv CGType
objectType' Word32
nParameters Ptr Parameter
parameters''
    Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectNewv" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
Object) Ptr Object
result
    (Parameter -> IO ()) -> [Parameter] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Parameter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Parameter]
parameters
    Ptr Parameter -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Parameter
parameters''
    Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Object::bind_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the source #GObject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_property"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the property on @source to bind"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the target #GObject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target_property"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the property on @target to bind"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "BindingFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags to pass to #GBinding"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Binding" })
-- throws : False
-- Skip return : False

foreign import ccall "g_object_bind_property" g_object_bind_property :: 
    Ptr Object ->                           -- source : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- source_property : TBasicType TUTF8
    Ptr Object ->                           -- target : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- target_property : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "GObject", name = "BindingFlags"})
    IO (Ptr GObject.Binding.Binding)

-- | Creates a binding between /@sourceProperty@/ on /@source@/ and /@targetProperty@/
-- on /@target@/. Whenever the /@sourceProperty@/ is changed the /@targetProperty@/ is
-- updated using the same value. For instance:
-- 
-- >
-- >  g_object_bind_property (action, "active", widget, "sensitive", 0);
-- 
-- 
-- Will result in the \"sensitive\" property of the widget t'GI.GObject.Objects.Object.Object' instance to be
-- updated with the same value of the \"active\" property of the action t'GI.GObject.Objects.Object.Object'
-- instance.
-- 
-- If /@flags@/ contains 'GI.GObject.Flags.BindingFlagsBidirectional' then the binding will be mutual:
-- if /@targetProperty@/ on /@target@/ changes then the /@sourceProperty@/ on /@source@/
-- will be updated as well.
-- 
-- The binding will automatically be removed when either the /@source@/ or the
-- /@target@/ instances are finalized. To remove the binding without affecting the
-- /@source@/ and the /@target@/ you can just call 'GI.GObject.Objects.Object.objectUnref' on the returned
-- t'GI.GObject.Objects.Binding.Binding' instance.
-- 
-- A t'GI.GObject.Objects.Object.Object' can have multiple bindings.
-- 
-- /Since: 2.26/
objectBindProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    -- ^ /@source@/: the source t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@sourceProperty@/: the property on /@source@/ to bind
    -> b
    -- ^ /@target@/: the target t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@targetProperty@/: the property on /@target@/ to bind
    -> [GObject.Flags.BindingFlags]
    -- ^ /@flags@/: flags to pass to t'GI.GObject.Objects.Binding.Binding'
    -> m GObject.Binding.Binding
    -- ^ __Returns:__ the t'GI.GObject.Objects.Binding.Binding' instance representing the
    --     binding between the two t'GI.GObject.Objects.Object.Object' instances. The binding is released
    --     whenever the t'GI.GObject.Objects.Binding.Binding' reference count reaches zero.
objectBindProperty :: a -> Text -> b -> Text -> [BindingFlags] -> m Binding
objectBindProperty a
source Text
sourceProperty b
target Text
targetProperty [BindingFlags]
flags = IO Binding -> m Binding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Binding -> m Binding) -> IO Binding -> m Binding
forall a b. (a -> b) -> a -> b
$ do
    Ptr Object
source' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
source
    CString
sourceProperty' <- Text -> IO CString
textToCString Text
sourceProperty
    Ptr Object
target' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
target
    CString
targetProperty' <- Text -> IO CString
textToCString Text
targetProperty
    let flags' :: CUInt
flags' = [BindingFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BindingFlags]
flags
    Ptr Binding
result <- Ptr Object
-> CString -> Ptr Object -> CString -> CUInt -> IO (Ptr Binding)
g_object_bind_property Ptr Object
source' CString
sourceProperty' Ptr Object
target' CString
targetProperty' CUInt
flags'
    Text -> Ptr Binding -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectBindProperty" Ptr Binding
result
    Binding
result' <- ((ManagedPtr Binding -> Binding) -> Ptr Binding -> IO Binding
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Binding -> Binding
GObject.Binding.Binding) Ptr Binding
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
source
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
target
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
sourceProperty'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
targetProperty'
    Binding -> IO Binding
forall (m :: * -> *) a. Monad m => a -> m a
return Binding
result'

#if defined(ENABLE_OVERLOADING)
data ObjectBindPropertyMethodInfo
instance (signature ~ (T.Text -> b -> T.Text -> [GObject.Flags.BindingFlags] -> m GObject.Binding.Binding), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectBindPropertyMethodInfo a signature where
    overloadedMethod = objectBindProperty

#endif

-- method Object::bind_property_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the source #GObject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_property"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the property on @source to bind"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the target #GObject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target_property"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the property on @target to bind"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "BindingFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags to pass to #GBinding"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transform_to"
--           , argType = TGClosure Nothing
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GClosure wrapping the transformation function\n    from the @source to the @target, or %NULL to use the default"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transform_from"
--           , argType = TGClosure Nothing
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GClosure wrapping the transformation function\n    from the @target to the @source, or %NULL to use the default"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Binding" })
-- throws : False
-- Skip return : False

foreign import ccall "g_object_bind_property_with_closures" g_object_bind_property_with_closures :: 
    Ptr Object ->                           -- source : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- source_property : TBasicType TUTF8
    Ptr Object ->                           -- target : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- target_property : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "GObject", name = "BindingFlags"})
    Ptr (GClosure ()) ->                    -- transform_to : TGClosure Nothing
    Ptr (GClosure ()) ->                    -- transform_from : TGClosure Nothing
    IO (Ptr GObject.Binding.Binding)

-- | Creates a binding between /@sourceProperty@/ on /@source@/ and /@targetProperty@/
-- on /@target@/, allowing you to set the transformation functions to be used by
-- the binding.
-- 
-- This function is the language bindings friendly version of
-- @/g_object_bind_property_full()/@, using @/GClosures/@ instead of
-- function pointers.
-- 
-- /Since: 2.26/
objectBindPropertyFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    -- ^ /@source@/: the source t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@sourceProperty@/: the property on /@source@/ to bind
    -> b
    -- ^ /@target@/: the target t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@targetProperty@/: the property on /@target@/ to bind
    -> [GObject.Flags.BindingFlags]
    -- ^ /@flags@/: flags to pass to t'GI.GObject.Objects.Binding.Binding'
    -> GClosure c
    -- ^ /@transformTo@/: a t'GI.GObject.Structs.Closure.Closure' wrapping the transformation function
    --     from the /@source@/ to the /@target@/, or 'P.Nothing' to use the default
    -> GClosure d
    -- ^ /@transformFrom@/: a t'GI.GObject.Structs.Closure.Closure' wrapping the transformation function
    --     from the /@target@/ to the /@source@/, or 'P.Nothing' to use the default
    -> m GObject.Binding.Binding
    -- ^ __Returns:__ the t'GI.GObject.Objects.Binding.Binding' instance representing the
    --     binding between the two t'GI.GObject.Objects.Object.Object' instances. The binding is released
    --     whenever the t'GI.GObject.Objects.Binding.Binding' reference count reaches zero.
objectBindPropertyFull :: a
-> Text
-> b
-> Text
-> [BindingFlags]
-> GClosure c
-> GClosure d
-> m Binding
objectBindPropertyFull a
source Text
sourceProperty b
target Text
targetProperty [BindingFlags]
flags GClosure c
transformTo GClosure d
transformFrom = IO Binding -> m Binding
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Binding -> m Binding) -> IO Binding -> m Binding
forall a b. (a -> b) -> a -> b
$ do
    Ptr Object
source' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
source
    CString
sourceProperty' <- Text -> IO CString
textToCString Text
sourceProperty
    Ptr Object
target' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
target
    CString
targetProperty' <- Text -> IO CString
textToCString Text
targetProperty
    let flags' :: CUInt
flags' = [BindingFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BindingFlags]
flags
    Ptr (GClosure ())
transformTo' <- GClosure c -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure c
transformTo
    Ptr (GClosure ())
transformFrom' <- GClosure d -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure d
transformFrom
    Ptr Binding
result <- Ptr Object
-> CString
-> Ptr Object
-> CString
-> CUInt
-> Ptr (GClosure ())
-> Ptr (GClosure ())
-> IO (Ptr Binding)
g_object_bind_property_with_closures Ptr Object
source' CString
sourceProperty' Ptr Object
target' CString
targetProperty' CUInt
flags' Ptr (GClosure ())
transformTo' Ptr (GClosure ())
transformFrom'
    Text -> Ptr Binding -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectBindPropertyFull" Ptr Binding
result
    Binding
result' <- ((ManagedPtr Binding -> Binding) -> Ptr Binding -> IO Binding
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Binding -> Binding
GObject.Binding.Binding) Ptr Binding
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
source
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
target
    GClosure c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure c
transformTo
    GClosure d -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure d
transformFrom
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
sourceProperty'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
targetProperty'
    Binding -> IO Binding
forall (m :: * -> *) a. Monad m => a -> m a
return Binding
result'

#if defined(ENABLE_OVERLOADING)
data ObjectBindPropertyFullMethodInfo
instance (signature ~ (T.Text -> b -> T.Text -> [GObject.Flags.BindingFlags] -> GClosure c -> GClosure d -> m GObject.Binding.Binding), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectBindPropertyFullMethodInfo a signature where
    overloadedMethod = objectBindPropertyFull

#endif

-- method Object::force_floating
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_force_floating" g_object_force_floating :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | This function is intended for t'GI.GObject.Objects.Object.Object' implementations to re-enforce
-- a [floating][floating-ref] object reference. Doing this is seldom
-- required: all @/GInitiallyUnowneds/@ are created with a floating reference
-- which usually just needs to be sunken by calling 'GI.GObject.Objects.Object.objectRefSink'.
-- 
-- /Since: 2.10/
objectForceFloating ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m ()
objectForceFloating :: a -> m ()
objectForceFloating a
object = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object -> IO ()
g_object_force_floating Ptr Object
object'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectForceFloatingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectForceFloatingMethodInfo a signature where
    overloadedMethod = objectForceFloating

#endif

-- method Object::freeze_notify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_freeze_notify" g_object_freeze_notify :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | Increases the freeze count on /@object@/. If the freeze count is
-- non-zero, the emission of \"notify\" signals on /@object@/ is
-- stopped. The signals are queued until the freeze count is decreased
-- to zero. Duplicate notifications are squashed so that at most one
-- [notify]("GI.GObject.Objects.Object#g:signal:notify") signal is emitted for each property modified while the
-- object is frozen.
-- 
-- This is necessary for accessors that modify multiple properties to prevent
-- premature notification while the object is still being modified.
objectFreezeNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m ()
objectFreezeNotify :: a -> m ()
objectFreezeNotify a
object = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object -> IO ()
g_object_freeze_notify Ptr Object
object'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectFreezeNotifyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectFreezeNotifyMethodInfo a signature where
    overloadedMethod = objectFreezeNotify

#endif

-- method Object::get_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GObject containing the associations"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the key for that association"
--                 , 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_object_get_data" g_object_get_data :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- key : TBasicType TUTF8
    IO (Ptr ())

-- | Gets a named field from the objects table of associations (see 'GI.GObject.Objects.Object.objectSetData').
objectGetData ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: t'GI.GObject.Objects.Object.Object' containing the associations
    -> T.Text
    -- ^ /@key@/: name of the key for that association
    -> m (Ptr ())
    -- ^ __Returns:__ the data if found,
    --          or 'P.Nothing' if no such data exists.
objectGetData :: a -> Text -> m (Ptr ())
objectGetData a
object Text
key = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr ()
result <- Ptr Object -> CString -> IO (Ptr ())
g_object_get_data Ptr Object
object' CString
key'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ObjectGetDataMethodInfo
instance (signature ~ (T.Text -> m (Ptr ())), MonadIO m, IsObject a) => O.MethodInfo ObjectGetDataMethodInfo a signature where
    overloadedMethod = objectGetData

#endif

-- method Object::get_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the property to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the property value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_get_property" g_object_get_property :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Gets a property of an object.
-- 
-- The /@value@/ can be:
-- 
--  - an empty t'GI.GObject.Structs.Value.Value' initialized by @/G_VALUE_INIT/@, which will be
--    automatically initialized with the expected type of the property
--    (since GLib 2.60)
--  - a t'GI.GObject.Structs.Value.Value' initialized with the expected type of the property
--  - a t'GI.GObject.Structs.Value.Value' initialized with a type to which the expected type
--    of the property can be transformed
-- 
-- In general, a copy is made of the property contents and the caller is
-- responsible for freeing the memory by calling 'GI.GObject.Structs.Value.valueUnset'.
-- 
-- Note that 'GI.GObject.Objects.Object.objectGetProperty' is really intended for language
-- bindings, @/g_object_get()/@ is much more convenient for C programming.
objectGetProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@propertyName@/: the name of the property to get
    -> GValue
    -- ^ /@value@/: return location for the property value
    -> m ()
objectGetProperty :: a -> Text -> GValue -> m ()
objectGetProperty a
object Text
propertyName GValue
value = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr Object -> CString -> Ptr GValue -> IO ()
g_object_get_property Ptr Object
object' CString
propertyName' Ptr GValue
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
value'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectGetPropertyMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectGetPropertyMethodInfo a signature where
    overloadedMethod = objectGetProperty

#endif

-- method Object::get_qdata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The GObject 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_object_get_qdata" g_object_get_qdata :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Word32 ->                               -- quark : TBasicType TUInt32
    IO (Ptr ())

-- | This function gets back user data pointers stored via
-- @/g_object_set_qdata()/@.
objectGetQdata ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: The GObject 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'
objectGetQdata :: a -> Word32 -> m (Ptr ())
objectGetQdata a
object 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr ()
result <- Ptr Object -> Word32 -> IO (Ptr ())
g_object_get_qdata Ptr Object
object' Word32
quark
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ObjectGetQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m, IsObject a) => O.MethodInfo ObjectGetQdataMethodInfo a signature where
    overloadedMethod = objectGetQdata

#endif

-- method Object::getv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_properties"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of properties"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "names"
--           , argType = TCArray False (-1) 1 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the names of each property to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "values"
--           , argType = TCArray False (-1) 1 TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the values of each property to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of properties"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of properties"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_getv" g_object_getv :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Word32 ->                               -- n_properties : TBasicType TUInt
    Ptr CString ->                          -- names : TCArray False (-1) 1 (TBasicType TUTF8)
    Ptr B.GValue.GValue ->                  -- values : TCArray False (-1) 1 TGValue
    IO ()

-- | Gets /@nProperties@/ properties for an /@object@/.
-- Obtained properties will be set to /@values@/. All properties must be valid.
-- Warnings will be emitted and undefined behaviour may result if invalid
-- properties are passed in.
-- 
-- /Since: 2.54/
objectGetv ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> [T.Text]
    -- ^ /@names@/: the names of each property to get
    -> [GValue]
    -- ^ /@values@/: the values of each property to get
    -> m ()
objectGetv :: a -> [Text] -> [GValue] -> m ()
objectGetv a
object [Text]
names [GValue]
values = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let nProperties :: Word32
nProperties = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
    let names_expected_length_ :: Word32
names_expected_length_ = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
names
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Word32
names_expected_length_ Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
nProperties) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"GObject.objectGetv : length of 'names' does not agree with that of 'values'."
    Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr CString
names' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
names
    Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
    Ptr Object -> Word32 -> Ptr CString -> Ptr GValue -> IO ()
g_object_getv Ptr Object
object' Word32
nProperties Ptr CString
names' Ptr GValue
values'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    (GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
    (Word32 -> (CString -> IO ()) -> Ptr CString -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Word32
nProperties) CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
names'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
names'
    (Word32 -> (Ptr GValue -> IO ()) -> Ptr GValue -> IO ()
forall a c.
Integral a =>
a -> (Ptr GValue -> IO c) -> Ptr GValue -> IO ()
B.GValue.mapGValueArrayWithLength Word32
nProperties) Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
values'
    Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectGetvMethodInfo
instance (signature ~ ([T.Text] -> [GValue] -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectGetvMethodInfo a signature where
    overloadedMethod = objectGetv

#endif

-- method Object::is_floating
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_object_is_floating" g_object_is_floating :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO CInt

-- | Checks whether /@object@/ has a [floating][floating-ref] reference.
-- 
-- /Since: 2.10/
objectIsFloating ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@object@/ has a floating reference
objectIsFloating :: a -> m Bool
objectIsFloating a
object = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CInt
result <- Ptr Object -> IO CInt
g_object_is_floating Ptr Object
object'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ObjectIsFloatingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsObject a) => O.MethodInfo ObjectIsFloatingMethodInfo a signature where
    overloadedMethod = objectIsFloating

#endif

-- method Object::notify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of a property installed on the class of @object."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_notify" g_object_notify :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO ()

-- | Emits a \"notify\" signal for the property /@propertyName@/ on /@object@/.
-- 
-- When possible, eg. when signaling a property change from within the class
-- that registered the property, you should use 'GI.GObject.Objects.Object.objectNotifyByPspec'
-- instead.
-- 
-- Note that emission of the notify signal may be blocked with
-- 'GI.GObject.Objects.Object.objectFreezeNotify'. In this case, the signal emissions are queued
-- and will be emitted (in reverse order) when 'GI.GObject.Objects.Object.objectThawNotify' is
-- called.
objectNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@propertyName@/: the name of a property installed on the class of /@object@/.
    -> m ()
objectNotify :: a -> Text -> m ()
objectNotify a
object Text
propertyName = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr Object -> CString -> IO ()
g_object_notify Ptr Object
object' CString
propertyName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectNotifyMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectNotifyMethodInfo a signature where
    overloadedMethod = objectNotify

#endif

-- method Object::notify_by_pspec
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GParamSpec of a property installed on the class of @object."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_notify_by_pspec" g_object_notify_by_pspec :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | Emits a \"notify\" signal for the property specified by /@pspec@/ on /@object@/.
-- 
-- This function omits the property name lookup, hence it is faster than
-- 'GI.GObject.Objects.Object.objectNotify'.
-- 
-- One way to avoid using 'GI.GObject.Objects.Object.objectNotify' from within the
-- class that registered the properties, and using 'GI.GObject.Objects.Object.objectNotifyByPspec'
-- instead, is to store the GParamSpec used with
-- 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty' inside a static array, e.g.:
-- 
-- 
-- === /C code/
-- >
-- >  enum
-- >  {
-- >    PROP_0,
-- >    PROP_FOO,
-- >    PROP_LAST
-- >  };
-- >
-- >  static GParamSpec *properties[PROP_LAST];
-- >
-- >  static void
-- >  my_object_class_init (MyObjectClass *klass)
-- >  {
-- >    properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
-- >                                             0, 100,
-- >                                             50,
-- >                                             G_PARAM_READWRITE);
-- >    g_object_class_install_property (gobject_class,
-- >                                     PROP_FOO,
-- >                                     properties[PROP_FOO]);
-- >  }
-- 
-- 
-- and then notify a change on the \"foo\" property with:
-- 
-- 
-- === /C code/
-- >
-- >  g_object_notify_by_pspec (self, properties[PROP_FOO]);
-- 
-- 
-- /Since: 2.26/
objectNotifyByPspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' of a property installed on the class of /@object@/.
    -> m ()
objectNotifyByPspec :: a -> GParamSpec -> m ()
objectNotifyByPspec a
object 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr Object -> Ptr GParamSpec -> IO ()
g_object_notify_by_pspec Ptr Object
object' Ptr GParamSpec
pspec'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    ObjectNotifyCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectNotifyByPspecMethodInfo
instance (signature ~ (GParamSpec -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectNotifyByPspecMethodInfo a signature where
    overloadedMethod = objectNotifyByPspec

#endif

-- method Object::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "g_object_ref" g_object_ref :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO (Ptr Object)

-- | Increases the reference count of /@object@/.
-- 
-- Since GLib 2.56, if @GLIB_VERSION_MAX_ALLOWED@ is 2.56 or greater, the type
-- of /@object@/ will be propagated to the return type (using the GCC @/typeof()/@
-- extension), so any casting the caller needs to do on the return type must be
-- explicit.
objectRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m Object
    -- ^ __Returns:__ the same /@object@/
objectRef :: a -> m Object
objectRef a
object = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object
result <- Ptr Object -> IO (Ptr Object)
g_object_ref Ptr Object
object'
    Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectRef" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Object) Ptr Object
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

#if defined(ENABLE_OVERLOADING)
data ObjectRefMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectRefMethodInfo a signature where
    overloadedMethod = objectRef

#endif

-- method Object::ref_sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "g_object_ref_sink" g_object_ref_sink :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO (Ptr Object)

-- | Increase the reference count of /@object@/, and possibly remove the
-- [floating][floating-ref] reference, if /@object@/ has a floating reference.
-- 
-- In other words, if the object is floating, then this call \"assumes
-- ownership\" of the floating reference, converting it to a normal
-- reference by clearing the floating flag while leaving the reference
-- count unchanged.  If the object is not floating, then this call
-- adds a new normal reference increasing the reference count by one.
-- 
-- Since GLib 2.56, the type of /@object@/ will be propagated to the return type
-- under the same conditions as for 'GI.GObject.Objects.Object.objectRef'.
-- 
-- /Since: 2.10/
objectRefSink ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m Object
    -- ^ __Returns:__ /@object@/
objectRefSink :: a -> m Object
objectRefSink a
object = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object
result <- Ptr Object -> IO (Ptr Object)
g_object_ref_sink Ptr Object
object'
    Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectRefSink" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Object) Ptr Object
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

#if defined(ENABLE_OVERLOADING)
data ObjectRefSinkMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectRefSinkMethodInfo a signature where
    overloadedMethod = objectRefSink

#endif

-- method Object::run_dispose
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_run_dispose" g_object_run_dispose :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | Releases all references to other objects. This can be used to break
-- reference cycles.
-- 
-- This function should only be called from object system implementations.
objectRunDispose ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m ()
objectRunDispose :: a -> m ()
objectRunDispose a
object = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object -> IO ()
g_object_run_dispose Ptr Object
object'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectRunDisposeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectRunDisposeMethodInfo a signature where
    overloadedMethod = objectRunDispose

#endif

-- method Object::set_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GObject containing the associations."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the key" , 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 "data to associate with that key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_set_data" g_object_set_data :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- key : TBasicType TUTF8
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | Each object carries around a table of associations from
-- strings to pointers.  This function lets you set an association.
-- 
-- If the object already had an association with that name,
-- the old association will be destroyed.
-- 
-- Internally, the /@key@/ is converted to a @/GQuark/@ using 'GI.GLib.Functions.quarkFromString'.
-- This means a copy of /@key@/ is kept permanently (even after /@object@/ has been
-- finalized) — so it is recommended to only use a small, bounded set of values
-- for /@key@/ in your program, to avoid the @/GQuark/@ storage growing unbounded.
objectSetData ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: t'GI.GObject.Objects.Object.Object' containing the associations.
    -> T.Text
    -- ^ /@key@/: name of the key
    -> Ptr ()
    -- ^ /@data@/: data to associate with that key
    -> m ()
objectSetData :: a -> Text -> Ptr () -> m ()
objectSetData a
object Text
key 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr Object -> CString -> Ptr () -> IO ()
g_object_set_data Ptr Object
object' CString
key' Ptr ()
data_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetDataMethodInfo
instance (signature ~ (T.Text -> Ptr () -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetDataMethodInfo a signature where
    overloadedMethod = objectSetData

#endif

-- method Object::set_data_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GObject containing the associations"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the key" , 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 "data to associate with that key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "function to call when the association is destroyed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_set_data_full" g_object_set_data_full :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- key : TBasicType TUTF8
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Like 'GI.GObject.Objects.Object.objectSetData' except it adds notification
-- for when the association is destroyed, either by setting it
-- to a different value or when the object is destroyed.
-- 
-- Note that the /@destroy@/ callback is not called if /@data@/ is 'P.Nothing'.
objectSetDataFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: t'GI.GObject.Objects.Object.Object' containing the associations
    -> T.Text
    -- ^ /@key@/: name of the key
    -> Ptr ()
    -- ^ /@data@/: data to associate with that key
    -> Maybe (GLib.Callbacks.DestroyNotify)
    -- ^ /@destroy@/: function to call when the association is destroyed
    -> m ()
objectSetDataFull :: a -> Text -> Ptr () -> Maybe (Ptr () -> IO ()) -> m ()
objectSetDataFull a
object Text
key Ptr ()
data_ Maybe (Ptr () -> IO ())
destroy = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
key' <- Text -> IO CString
textToCString Text
key
    FunPtr (Ptr () -> IO ())
maybeDestroy <- case Maybe (Ptr () -> IO ())
destroy of
        Maybe (Ptr () -> IO ())
Nothing -> FunPtr (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr (Ptr () -> IO ())
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just Ptr () -> IO ()
jDestroy -> do
            Ptr (FunPtr (Ptr () -> IO ()))
ptrdestroy <- IO (Ptr (FunPtr (Ptr () -> IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
            FunPtr (Ptr () -> IO ())
jDestroy' <- (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr (Ptr () -> IO ())))
-> (Ptr () -> IO ()) -> Ptr () -> IO ()
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr (Ptr () -> IO ()))
-> Maybe (Ptr (FunPtr (Ptr () -> IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (Ptr () -> IO ()))
ptrdestroy) Ptr () -> IO ()
jDestroy)
            Ptr (FunPtr (Ptr () -> IO ())) -> FunPtr (Ptr () -> IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (Ptr () -> IO ()))
ptrdestroy FunPtr (Ptr () -> IO ())
jDestroy'
            FunPtr (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr (Ptr () -> IO ())
jDestroy'
    Ptr Object
-> CString -> Ptr () -> FunPtr (Ptr () -> IO ()) -> IO ()
g_object_set_data_full Ptr Object
object' CString
key' Ptr ()
data_ FunPtr (Ptr () -> IO ())
maybeDestroy
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetDataFullMethodInfo
instance (signature ~ (T.Text -> Ptr () -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetDataFullMethodInfo a signature where
    overloadedMethod = objectSetDataFull

#endif

-- method Object::set_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the property to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_set_property" g_object_set_property :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Sets a property on an object.
objectSetProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> T.Text
    -- ^ /@propertyName@/: the name of the property to set
    -> GValue
    -- ^ /@value@/: the value
    -> m ()
objectSetProperty :: a -> Text -> GValue -> m ()
objectSetProperty a
object Text
propertyName GValue
value = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr Object -> CString -> Ptr GValue -> IO ()
g_object_set_property Ptr Object
object' CString
propertyName' Ptr GValue
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
value'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetPropertyMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetPropertyMethodInfo a signature where
    overloadedMethod = objectSetProperty

#endif

-- method Object::steal_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GObject containing the associations"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the key" , 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_object_steal_data" g_object_steal_data :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    CString ->                              -- key : TBasicType TUTF8
    IO (Ptr ())

-- | Remove a specified datum from the object\'s data associations,
-- without invoking the association\'s destroy handler.
objectStealData ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: t'GI.GObject.Objects.Object.Object' containing the associations
    -> T.Text
    -- ^ /@key@/: name of the key
    -> m (Ptr ())
    -- ^ __Returns:__ the data if found, or 'P.Nothing'
    --          if no such data exists.
objectStealData :: a -> Text -> m (Ptr ())
objectStealData a
object Text
key = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr ()
result <- Ptr Object -> CString -> IO (Ptr ())
g_object_steal_data Ptr Object
object' CString
key'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ObjectStealDataMethodInfo
instance (signature ~ (T.Text -> m (Ptr ())), MonadIO m, IsObject a) => O.MethodInfo ObjectStealDataMethodInfo a signature where
    overloadedMethod = objectStealData

#endif

-- method Object::steal_qdata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The GObject 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_object_steal_qdata" g_object_steal_qdata :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Word32 ->                               -- quark : TBasicType TUInt32
    IO (Ptr ())

-- | This function gets back user data pointers stored via
-- @/g_object_set_qdata()/@ and removes the /@data@/ from object
-- 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, for example:
-- 
-- === /C code/
-- >
-- >void
-- >object_add_to_user_list (GObject     *object,
-- >                         const gchar *new_string)
-- >{
-- >  // the quark, naming the object data
-- >  GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
-- >  // retrive the old string list
-- >  GList *list = g_object_steal_qdata (object, quark_string_list);
-- >
-- >  // prepend new string
-- >  list = g_list_prepend (list, g_strdup (new_string));
-- >  // this changed 'list', so we need to set it again
-- >  g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
-- >}
-- >static void
-- >free_string_list (gpointer data)
-- >{
-- >  GList *node, *list = data;
-- >
-- >  for (node = list; node; node = node->next)
-- >    g_free (node->data);
-- >  g_list_free (list);
-- >}
-- 
-- Using 'GI.GObject.Objects.Object.objectGetQdata' in the above example, instead of
-- 'GI.GObject.Objects.Object.objectStealQdata' would have left the destroy function set,
-- and thus the partial string list would have been freed upon
-- @/g_object_set_qdata_full()/@.
objectStealQdata ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: The GObject 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'
objectStealQdata :: a -> Word32 -> m (Ptr ())
objectStealQdata a
object 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr ()
result <- Ptr Object -> Word32 -> IO (Ptr ())
g_object_steal_qdata Ptr Object
object' Word32
quark
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data ObjectStealQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m, IsObject a) => O.MethodInfo ObjectStealQdataMethodInfo a signature where
    overloadedMethod = objectStealQdata

#endif

-- method Object::thaw_notify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_thaw_notify" g_object_thaw_notify :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | Reverts the effect of a previous call to
-- 'GI.GObject.Objects.Object.objectFreezeNotify'. The freeze count is decreased on /@object@/
-- and when it reaches zero, queued \"notify\" signals are emitted.
-- 
-- Duplicate notifications for each property are squashed so that at most one
-- [notify]("GI.GObject.Objects.Object#g:signal:notify") signal is emitted for each property, in the reverse order
-- in which they have been queued.
-- 
-- It is an error to call this function when the freeze count is zero.
objectThawNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m ()
objectThawNotify :: a -> m ()
objectThawNotify a
object = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object -> IO ()
g_object_thaw_notify Ptr Object
object'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectThawNotifyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectThawNotifyMethodInfo a signature where
    overloadedMethod = objectThawNotify

#endif

-- method Object::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_unref" g_object_unref :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | Decreases the reference count of /@object@/. When its reference count
-- drops to 0, the object is finalized (i.e. its memory is freed).
-- 
-- If the pointer to the t'GI.GObject.Objects.Object.Object' may be reused in future (for example, if it is
-- an instance variable of another object), it is recommended to clear the
-- pointer to 'P.Nothing' rather than retain a dangling pointer to a potentially
-- invalid t'GI.GObject.Objects.Object.Object' instance. Use @/g_clear_object()/@ for this.
objectUnref ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: a t'GI.GObject.Objects.Object.Object'
    -> m ()
objectUnref :: a -> m ()
objectUnref a
object = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Object -> IO ()
g_object_unref Ptr Object
object'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectUnrefMethodInfo a signature where
    overloadedMethod = objectUnref

#endif

-- method Object::watch_closure
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GObject restricting lifetime of @closure"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "closure"
--           , argType = TGClosure Nothing
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GClosure to watch" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_watch_closure" g_object_watch_closure :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (GClosure ()) ->                    -- closure : TGClosure Nothing
    IO ()

-- | This function essentially limits the life time of the /@closure@/ to
-- the life time of the object. That is, when the object is finalized,
-- the /@closure@/ is invalidated by calling 'GI.GObject.Structs.Closure.closureInvalidate' on
-- it, in order to prevent invocations of the closure with a finalized
-- (nonexisting) object. Also, 'GI.GObject.Objects.Object.objectRef' and 'GI.GObject.Objects.Object.objectUnref' are
-- added as marshal guards to the /@closure@/, to ensure that an extra
-- reference count is held on /@object@/ during invocation of the
-- /@closure@/.  Usually, this function will be called on closures that
-- use this /@object@/ as closure data.
objectWatchClosure ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@object@/: t'GI.GObject.Objects.Object.Object' restricting lifetime of /@closure@/
    -> GClosure b
    -- ^ /@closure@/: t'GI.GObject.Structs.Closure.Closure' to watch
    -> m ()
objectWatchClosure :: a -> GClosure b -> m ()
objectWatchClosure a
object GClosure b
closure = 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 Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr (GClosure ())
closure' <- GClosure b -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure b
closure
    Ptr Object -> Ptr (GClosure ()) -> IO ()
g_object_watch_closure Ptr Object
object' Ptr (GClosure ())
closure'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    GClosure b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure b
closure
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectWatchClosureMethodInfo
instance (signature ~ (GClosure b -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectWatchClosureMethodInfo a signature where
    overloadedMethod = objectWatchClosure

#endif

-- method Object::compat_control
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "what"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "g_object_compat_control" g_object_compat_control :: 
    Word64 ->                               -- what : TBasicType TUInt64
    Ptr () ->                               -- data : TBasicType TPtr
    IO Word64

-- | /No description available in the introspection data./
objectCompatControl ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word64
    -> Ptr ()
    -> m Word64
objectCompatControl :: CGType -> Ptr () -> m CGType
objectCompatControl CGType
what Ptr ()
data_ = IO CGType -> m CGType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
    CGType
result <- CGType -> Ptr () -> IO CGType
g_object_compat_control CGType
what Ptr ()
data_
    CGType -> IO CGType
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result

#if defined(ENABLE_OVERLOADING)
#endif

-- method Object::interface_find_property
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "g_iface"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "TypeInterface" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "any interface vtable for the\n interface, or the default vtable for the interface"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of a property to look up."
--                 , 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_object_interface_find_property" g_object_interface_find_property :: 
    Ptr GObject.TypeInterface.TypeInterface -> -- g_iface : TInterface (Name {namespace = "GObject", name = "TypeInterface"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr GParamSpec)

-- | Find the t'GI.GObject.Objects.ParamSpec.ParamSpec' with the given name for an
-- interface. Generally, the interface vtable passed in as /@gIface@/
-- will be the default vtable from 'GI.GObject.Functions.typeDefaultInterfaceRef', or,
-- if you know the interface has already been loaded,
-- 'GI.GObject.Functions.typeDefaultInterfacePeek'.
-- 
-- /Since: 2.4/
objectInterfaceFindProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GObject.TypeInterface.TypeInterface
    -- ^ /@gIface@/: any interface vtable for the
    --  interface, or the default vtable for the interface
    -> T.Text
    -- ^ /@propertyName@/: name of a property to look up.
    -> m GParamSpec
    -- ^ __Returns:__ the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the property of the
    --          interface with the name /@propertyName@/, or 'P.Nothing' if no
    --          such property exists.
objectInterfaceFindProperty :: TypeInterface -> Text -> m GParamSpec
objectInterfaceFindProperty TypeInterface
gIface Text
propertyName = 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 TypeInterface
gIface' <- TypeInterface -> IO (Ptr TypeInterface)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInterface
gIface
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GParamSpec
result <- Ptr TypeInterface -> CString -> IO (Ptr GParamSpec)
g_object_interface_find_property Ptr TypeInterface
gIface' CString
propertyName'
    Text -> Ptr GParamSpec -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInterfaceFindProperty" Ptr GParamSpec
result
    GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
    TypeInterface -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInterface
gIface
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Object::interface_install_property
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "g_iface"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "TypeInterface" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "any interface vtable for the\n   interface, or the default\n vtable for the interface."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GParamSpec for the new property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_object_interface_install_property" g_object_interface_install_property :: 
    Ptr GObject.TypeInterface.TypeInterface -> -- g_iface : TInterface (Name {namespace = "GObject", name = "TypeInterface"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO ()

-- | Add a property to an interface; this is only useful for interfaces
-- that are added to GObject-derived types. Adding a property to an
-- interface forces all objects classes with that interface to have a
-- compatible property. The compatible property could be a newly
-- created t'GI.GObject.Objects.ParamSpec.ParamSpec', but normally
-- 'GI.GObject.Structs.ObjectClass.objectClassOverrideProperty' will be used so that the object
-- class only needs to provide an implementation and inherits the
-- property description, default value, bounds, and so forth from the
-- interface property.
-- 
-- This function is meant to be called from the interface\'s default
-- vtable initialization function (the /@classInit@/ member of
-- t'GI.GObject.Structs.TypeInfo.TypeInfo'.) It must not be called after after /@classInit@/ has
-- been called for any object types implementing this interface.
-- 
-- If /@pspec@/ is a floating reference, it will be consumed.
-- 
-- /Since: 2.4/
objectInterfaceInstallProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GObject.TypeInterface.TypeInterface
    -- ^ /@gIface@/: any interface vtable for the
    --    interface, or the default
    --  vtable for the interface.
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' for the new property
    -> m ()
objectInterfaceInstallProperty :: TypeInterface -> GParamSpec -> m ()
objectInterfaceInstallProperty TypeInterface
gIface 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 TypeInterface
gIface' <- TypeInterface -> IO (Ptr TypeInterface)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInterface
gIface
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr TypeInterface -> Ptr GParamSpec -> IO ()
g_object_interface_install_property Ptr TypeInterface
gIface' Ptr GParamSpec
pspec'
    TypeInterface -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInterface
gIface
    ObjectNotifyCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- XXX Could not generate method Object::interface_list_properties
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ObjectInterfaceListPropertiesMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "interfaceListProperties" Object) => O.MethodInfo ObjectInterfaceListPropertiesMethodInfo o p where
    overloadedMethod = undefined
#endif