{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GtkBuilderScope@ implementation for the C language.
-- 
-- @GtkBuilderCScope@ instances use symbols explicitly added to /@builder@/
-- with prior calls to 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol'.
-- If developers want to do that, they are encouraged to create their
-- own scopes for that purpose.
-- 
-- In the case that symbols are not explicitly added; GTK will uses
-- @GModule@’s introspective features (by opening the module 'P.Nothing') to
-- look at the application’s symbol table. From here it tries to match
-- the signal function names given in the interface description with
-- symbols in the application.
-- 
-- Note that unless 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol' is
-- called for all signal callbacks which are referenced by the loaded XML,
-- this functionality will require that @GModule@ be supported on the platform.

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

module GI.Gtk.Objects.BuilderCScope
    ( 

-- * Exported types
    BuilderCScope(..)                       ,
    IsBuilderCScope                         ,
    toBuilderCScope                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addCallbackSymbol]("GI.Gtk.Objects.BuilderCScope#g:method:addCallbackSymbol"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveBuilderCScopeMethod              ,
#endif

-- ** addCallbackSymbol #method:addCallbackSymbol#

#if defined(ENABLE_OVERLOADING)
    BuilderCScopeAddCallbackSymbolMethodInfo,
#endif
    builderCScopeAddCallbackSymbol          ,


-- ** new #method:new#

    builderCScopeNew                        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.BuilderScope as Gtk.BuilderScope

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

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

foreign import ccall "gtk_builder_cscope_get_type"
    c_gtk_builder_cscope_get_type :: IO B.Types.GType

instance B.Types.TypedObject BuilderCScope where
    glibType :: IO GType
glibType = IO GType
c_gtk_builder_cscope_get_type

instance B.Types.GObject BuilderCScope

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

instance O.HasParentTypes BuilderCScope
type instance O.ParentTypes BuilderCScope = '[GObject.Object.Object, Gtk.BuilderScope.BuilderScope]

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

-- | Convert 'BuilderCScope' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe BuilderCScope) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_builder_cscope_get_type
    gvalueSet_ :: Ptr GValue -> Maybe BuilderCScope -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BuilderCScope
P.Nothing = Ptr GValue -> Ptr BuilderCScope -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr BuilderCScope
forall a. Ptr a
FP.nullPtr :: FP.Ptr BuilderCScope)
    gvalueSet_ Ptr GValue
gv (P.Just BuilderCScope
obj) = BuilderCScope -> (Ptr BuilderCScope -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BuilderCScope
obj (Ptr GValue -> Ptr BuilderCScope -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe BuilderCScope)
gvalueGet_ Ptr GValue
gv = do
        Ptr BuilderCScope
ptr <- Ptr GValue -> IO (Ptr BuilderCScope)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr BuilderCScope)
        if Ptr BuilderCScope
ptr Ptr BuilderCScope -> Ptr BuilderCScope -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr BuilderCScope
forall a. Ptr a
FP.nullPtr
        then BuilderCScope -> Maybe BuilderCScope
forall a. a -> Maybe a
P.Just (BuilderCScope -> Maybe BuilderCScope)
-> IO BuilderCScope -> IO (Maybe BuilderCScope)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr BuilderCScope -> BuilderCScope)
-> Ptr BuilderCScope -> IO BuilderCScope
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr BuilderCScope -> BuilderCScope
BuilderCScope Ptr BuilderCScope
ptr
        else Maybe BuilderCScope -> IO (Maybe BuilderCScope)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BuilderCScope
forall a. Maybe a
P.Nothing
        
    

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

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveBuilderCScopeMethod t BuilderCScope, O.OverloadedMethod info BuilderCScope p, R.HasField t BuilderCScope p) => R.HasField t BuilderCScope p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveBuilderCScopeMethod t BuilderCScope, O.OverloadedMethodInfo info BuilderCScope) => OL.IsLabel t (O.MethodProxy info BuilderCScope) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

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

#endif

-- method BuilderCScope::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "BuilderCScope" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_builder_cscope_new" gtk_builder_cscope_new :: 
    IO (Ptr BuilderCScope)

-- | Creates a new @GtkBuilderCScope@ object to use with future
-- @GtkBuilder@ instances.
-- 
-- Calling this function is only necessary if you want to add
-- custom callbacks via 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol'.
builderCScopeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m BuilderCScope
    -- ^ __Returns:__ a new @GtkBuilderCScope@
builderCScopeNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m BuilderCScope
builderCScopeNew  = IO BuilderCScope -> m BuilderCScope
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BuilderCScope -> m BuilderCScope)
-> IO BuilderCScope -> m BuilderCScope
forall a b. (a -> b) -> a -> b
$ do
    Ptr BuilderCScope
result <- IO (Ptr BuilderCScope)
gtk_builder_cscope_new
    Text -> Ptr BuilderCScope -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"builderCScopeNew" Ptr BuilderCScope
result
    BuilderCScope
result' <- ((ManagedPtr BuilderCScope -> BuilderCScope)
-> Ptr BuilderCScope -> IO BuilderCScope
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr BuilderCScope -> BuilderCScope
BuilderCScope) Ptr BuilderCScope
result
    BuilderCScope -> IO BuilderCScope
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BuilderCScope
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method BuilderCScope::add_callback_symbol
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BuilderCScope" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkBuilderCScope`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The name of the callback, as expected in the XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_symbol"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The callback pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_builder_cscope_add_callback_symbol" gtk_builder_cscope_add_callback_symbol :: 
    Ptr BuilderCScope ->                    -- self : TInterface (Name {namespace = "Gtk", name = "BuilderCScope"})
    CString ->                              -- callback_name : TBasicType TUTF8
    FunPtr GObject.Callbacks.C_Callback ->  -- callback_symbol : TInterface (Name {namespace = "GObject", name = "Callback"})
    IO ()

-- | Adds the /@callbackSymbol@/ to the scope of /@builder@/ under the
-- given /@callbackName@/.
-- 
-- Using this function overrides the behavior of
-- 'GI.Gtk.Objects.Builder.builderCreateClosure' for any callback symbols that
-- are added. Using this method allows for better encapsulation as it
-- does not require that callback symbols be declared in the global
-- namespace.
builderCScopeAddCallbackSymbol ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilderCScope a) =>
    a
    -- ^ /@self@/: a @GtkBuilderCScope@
    -> T.Text
    -- ^ /@callbackName@/: The name of the callback, as expected in the XML
    -> GObject.Callbacks.Callback
    -- ^ /@callbackSymbol@/: The callback pointer
    -> m ()
builderCScopeAddCallbackSymbol :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilderCScope a) =>
a -> Text -> IO () -> m ()
builderCScopeAddCallbackSymbol a
self Text
callbackName IO ()
callbackSymbol = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr BuilderCScope
self' <- a -> IO (Ptr BuilderCScope)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
callbackName' <- Text -> IO CString
textToCString Text
callbackName
    Ptr (FunPtr (IO ()))
ptrcallbackSymbol <- IO (Ptr (FunPtr (IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    FunPtr (IO ())
callbackSymbol' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback (Ptr (FunPtr (IO ())) -> Maybe (Ptr (FunPtr (IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrcallbackSymbol) IO ()
callbackSymbol)
    Ptr (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (IO ()))
ptrcallbackSymbol FunPtr (IO ())
callbackSymbol'
    Ptr BuilderCScope -> CString -> FunPtr (IO ()) -> IO ()
gtk_builder_cscope_add_callback_symbol Ptr BuilderCScope
self' CString
callbackName' FunPtr (IO ())
callbackSymbol'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
callbackName'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BuilderCScopeAddCallbackSymbolMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m, IsBuilderCScope a) => O.OverloadedMethod BuilderCScopeAddCallbackSymbolMethodInfo a signature where
    overloadedMethod = builderCScopeAddCallbackSymbol

instance O.OverloadedMethodInfo BuilderCScopeAddCallbackSymbolMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-BuilderCScope.html#v:builderCScopeAddCallbackSymbol"
        })


#endif