{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GOptionGroup@ struct defines the options in a single
-- group. The struct has only private fields and should not be directly accessed.
-- 
-- All options in a group share the same translation function. Libraries which
-- need to parse commandline options are expected to provide a function for
-- getting a @GOptionGroup@ holding their options, which
-- the application can then add to its t'GI.GLib.Structs.OptionContext.OptionContext'.

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

module GI.GLib.Structs.OptionGroup
    ( 

-- * Exported types
    OptionGroup(..)                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addEntries]("GI.GLib.Structs.OptionGroup#g:method:addEntries"), [free]("GI.GLib.Structs.OptionGroup#g:method:free"), [ref]("GI.GLib.Structs.OptionGroup#g:method:ref"), [unref]("GI.GLib.Structs.OptionGroup#g:method:unref").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- [setTranslateFunc]("GI.GLib.Structs.OptionGroup#g:method:setTranslateFunc"), [setTranslationDomain]("GI.GLib.Structs.OptionGroup#g:method:setTranslationDomain").

#if defined(ENABLE_OVERLOADING)
    ResolveOptionGroupMethod                ,
#endif

-- ** addEntries #method:addEntries#

#if defined(ENABLE_OVERLOADING)
    OptionGroupAddEntriesMethodInfo         ,
#endif
    optionGroupAddEntries                   ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    OptionGroupFreeMethodInfo               ,
#endif
    optionGroupFree                         ,


-- ** new #method:new#

    optionGroupNew                          ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    OptionGroupRefMethodInfo                ,
#endif
    optionGroupRef                          ,


-- ** setTranslateFunc #method:setTranslateFunc#

#if defined(ENABLE_OVERLOADING)
    OptionGroupSetTranslateFuncMethodInfo   ,
#endif
    optionGroupSetTranslateFunc             ,


-- ** setTranslationDomain #method:setTranslationDomain#

#if defined(ENABLE_OVERLOADING)
    OptionGroupSetTranslationDomainMethodInfo,
#endif
    optionGroupSetTranslationDomain         ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    OptionGroupUnrefMethodInfo              ,
#endif
    optionGroupUnref                        ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
import {-# SOURCE #-} qualified GI.GLib.Structs.OptionEntry as GLib.OptionEntry

#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.OptionEntry as GLib.OptionEntry

#endif

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

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

foreign import ccall "g_option_group_get_type" c_g_option_group_get_type :: 
    IO GType

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

instance B.Types.TypedObject OptionGroup where
    glibType :: IO GType
glibType = IO GType
c_g_option_group_get_type

instance B.Types.GBoxed OptionGroup

-- | Convert 'OptionGroup' 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 OptionGroup) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_option_group_get_type
    gvalueSet_ :: Ptr GValue -> Maybe OptionGroup -> IO ()
gvalueSet_ Ptr GValue
gv Maybe OptionGroup
P.Nothing = Ptr GValue -> Ptr OptionGroup -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr OptionGroup
forall a. Ptr a
FP.nullPtr :: FP.Ptr OptionGroup)
    gvalueSet_ Ptr GValue
gv (P.Just OptionGroup
obj) = OptionGroup -> (Ptr OptionGroup -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr OptionGroup
obj (Ptr GValue -> Ptr OptionGroup -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe OptionGroup)
gvalueGet_ Ptr GValue
gv = do
        Ptr OptionGroup
ptr <- Ptr GValue -> IO (Ptr OptionGroup)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr OptionGroup)
        if Ptr OptionGroup
ptr Ptr OptionGroup -> Ptr OptionGroup -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr OptionGroup
forall a. Ptr a
FP.nullPtr
        then OptionGroup -> Maybe OptionGroup
forall a. a -> Maybe a
P.Just (OptionGroup -> Maybe OptionGroup)
-> IO OptionGroup -> IO (Maybe OptionGroup)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr OptionGroup -> OptionGroup)
-> Ptr OptionGroup -> IO OptionGroup
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr OptionGroup -> OptionGroup
OptionGroup Ptr OptionGroup
ptr
        else Maybe OptionGroup -> IO (Maybe OptionGroup)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OptionGroup
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OptionGroup
type instance O.AttributeList OptionGroup = OptionGroupAttributeList
type OptionGroupAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

-- method OptionGroup::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the name for the option group, this is used to provide\n  help for the options in this group with `--help-`@name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "description"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a description for this group to be shown in\n  `--help`. This string is translated using the translation\n  domain or translation function of the group"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "help_description"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a description for the `--help-`@name option.\n  This string is translated using the translation domain or translation function\n  of the group"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "user data that will be passed to the pre- and post-parse hooks,\n  the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a function that will be called to free @user_data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GLib" , name = "OptionGroup" })
-- throws : False
-- Skip return : False

foreign import ccall "g_option_group_new" g_option_group_new :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- description : TBasicType TUTF8
    CString ->                              -- help_description : TBasicType TUTF8
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO (Ptr OptionGroup)

-- | Creates a new t'GI.GLib.Structs.OptionGroup.OptionGroup'.
-- 
-- /@description@/ is typically used to provide a title for the group. If so, it
-- is recommended that it’s written in title case, and has a trailing colon so
-- that it matches the style of built-in GLib group titles such as
-- ‘Application Options:’.
-- 
-- /Since: 2.6/
optionGroupNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: the name for the option group, this is used to provide
    --   help for the options in this group with @--help-@/@name@/
    -> T.Text
    -- ^ /@description@/: a description for this group to be shown in
    --   @--help@. This string is translated using the translation
    --   domain or translation function of the group
    -> T.Text
    -- ^ /@helpDescription@/: a description for the @--help-@/@name@/ option.
    --   This string is translated using the translation domain or translation function
    --   of the group
    -> Ptr ()
    -- ^ /@userData@/: user data that will be passed to the pre- and post-parse hooks,
    --   the error hook and to callbacks of 'GI.GLib.Enums.OptionArgCallback' options, or 'P.Nothing'
    -> Maybe (GLib.Callbacks.DestroyNotify)
    -- ^ /@destroy@/: a function that will be called to free /@userData@/, or 'P.Nothing'
    -> m OptionGroup
    -- ^ __Returns:__ a newly created option group. It should be added
    --   to a t'GI.GLib.Structs.OptionContext.OptionContext' or freed with 'GI.GLib.Structs.OptionGroup.optionGroupUnref'.
optionGroupNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> Text -> Ptr () -> Maybe (IO ()) -> m OptionGroup
optionGroupNew Text
name Text
description Text
helpDescription Ptr ()
userData Maybe (IO ())
destroy = IO OptionGroup -> m OptionGroup
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OptionGroup -> m OptionGroup)
-> IO OptionGroup -> m OptionGroup
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
description' <- Text -> IO CString
textToCString Text
description
    CString
helpDescription' <- Text -> IO CString
textToCString Text
helpDescription
    FunPtr C_DestroyNotify
maybeDestroy <- case Maybe (IO ())
destroy of
        Maybe (IO ())
Nothing -> FunPtr C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_DestroyNotify
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just IO ()
jDestroy -> do
            Ptr (FunPtr C_DestroyNotify)
ptrdestroy <- IO (Ptr (FunPtr C_DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
            FunPtr C_DestroyNotify
jDestroy' <- C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr C_DestroyNotify))
-> C_DestroyNotify -> C_DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr C_DestroyNotify)
-> Maybe (Ptr (FunPtr C_DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr C_DestroyNotify)
ptrdestroy) (IO () -> C_DestroyNotify
GLib.Callbacks.drop_closures_DestroyNotify IO ()
jDestroy))
            Ptr (FunPtr C_DestroyNotify) -> FunPtr C_DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_DestroyNotify)
ptrdestroy FunPtr C_DestroyNotify
jDestroy'
            FunPtr C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_DestroyNotify
jDestroy'
    Ptr OptionGroup
result <- CString
-> CString
-> CString
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO (Ptr OptionGroup)
g_option_group_new CString
name' CString
description' CString
helpDescription' Ptr ()
userData FunPtr C_DestroyNotify
maybeDestroy
    Text -> Ptr OptionGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionGroupNew" Ptr OptionGroup
result
    OptionGroup
result' <- ((ManagedPtr OptionGroup -> OptionGroup)
-> Ptr OptionGroup -> IO OptionGroup
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OptionGroup -> OptionGroup
OptionGroup) Ptr OptionGroup
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
helpDescription'
    OptionGroup -> IO OptionGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return OptionGroup
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method OptionGroup::add_entries
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "group"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "OptionGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOptionGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "entries"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "GLib" , name = "OptionEntry" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a %NULL-terminated array of #GOptionEntrys"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_option_group_add_entries" g_option_group_add_entries :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    Ptr (Ptr GLib.OptionEntry.OptionEntry) -> -- entries : TCArray True (-1) (-1) (TInterface (Name {namespace = "GLib", name = "OptionEntry"}))
    IO ()

-- | Adds the options specified in /@entries@/ to /@group@/.
-- 
-- /Since: 2.6/
optionGroupAddEntries ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> [GLib.OptionEntry.OptionEntry]
    -- ^ /@entries@/: a 'P.Nothing'-terminated array of @/GOptionEntrys/@
    -> m ()
optionGroupAddEntries :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> [OptionEntry] -> m ()
optionGroupAddEntries OptionGroup
group [OptionEntry]
entries = 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 OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    [Ptr OptionEntry]
entries' <- (OptionEntry -> IO (Ptr OptionEntry))
-> [OptionEntry] -> IO [Ptr OptionEntry]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM OptionEntry -> IO (Ptr OptionEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [OptionEntry]
entries
    Ptr (Ptr OptionEntry)
entries'' <- [Ptr OptionEntry] -> IO (Ptr (Ptr OptionEntry))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr OptionEntry]
entries'
    Ptr OptionGroup -> Ptr (Ptr OptionEntry) -> IO ()
g_option_group_add_entries Ptr OptionGroup
group' Ptr (Ptr OptionEntry)
entries''
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    (OptionEntry -> IO ()) -> [OptionEntry] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ OptionEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [OptionEntry]
entries
    Ptr (Ptr OptionEntry) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr OptionEntry)
entries''
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionGroupAddEntriesMethodInfo
instance (signature ~ ([GLib.OptionEntry.OptionEntry] -> m ()), MonadIO m) => O.OverloadedMethod OptionGroupAddEntriesMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupAddEntries

instance O.OverloadedMethodInfo OptionGroupAddEntriesMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupAddEntries",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupAddEntries"
        })


#endif

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

foreign import ccall "g_option_group_free" g_option_group_free :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    IO ()

{-# DEPRECATED optionGroupFree ["(Since version 2.44)","Use 'GI.GLib.Structs.OptionGroup.optionGroupUnref' instead."] #-}
-- | Frees a t'GI.GLib.Structs.OptionGroup.OptionGroup'. Note that you must not free groups
-- which have been added to a t'GI.GLib.Structs.OptionContext.OptionContext'.
-- 
-- /Since: 2.6/
optionGroupFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> m ()
optionGroupFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> m ()
optionGroupFree OptionGroup
group = 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 OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    Ptr OptionGroup -> IO ()
g_option_group_free Ptr OptionGroup
group'
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionGroupFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod OptionGroupFreeMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupFree

instance O.OverloadedMethodInfo OptionGroupFreeMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupFree"
        })


#endif

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

foreign import ccall "g_option_group_ref" g_option_group_ref :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    IO (Ptr OptionGroup)

-- | Increments the reference count of /@group@/ by one.
-- 
-- /Since: 2.44/
optionGroupRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> m OptionGroup
    -- ^ __Returns:__ a t'GI.GLib.Structs.OptionGroup.OptionGroup'
optionGroupRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> m OptionGroup
optionGroupRef OptionGroup
group = IO OptionGroup -> m OptionGroup
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OptionGroup -> m OptionGroup)
-> IO OptionGroup -> m OptionGroup
forall a b. (a -> b) -> a -> b
$ do
    Ptr OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    Ptr OptionGroup
result <- Ptr OptionGroup -> IO (Ptr OptionGroup)
g_option_group_ref Ptr OptionGroup
group'
    Text -> Ptr OptionGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionGroupRef" Ptr OptionGroup
result
    OptionGroup
result' <- ((ManagedPtr OptionGroup -> OptionGroup)
-> Ptr OptionGroup -> IO OptionGroup
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OptionGroup -> OptionGroup
OptionGroup) Ptr OptionGroup
result
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    OptionGroup -> IO OptionGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return OptionGroup
result'

#if defined(ENABLE_OVERLOADING)
data OptionGroupRefMethodInfo
instance (signature ~ (m OptionGroup), MonadIO m) => O.OverloadedMethod OptionGroupRefMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupRef

instance O.OverloadedMethodInfo OptionGroupRefMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupRef"
        })


#endif

-- method OptionGroup::set_translate_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "group"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "OptionGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOptionGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "TranslateFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GTranslateFunc, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to pass to @func, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy_notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a function which gets called to free @data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_option_group_set_translate_func" g_option_group_set_translate_func :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    FunPtr GLib.Callbacks.C_TranslateFunc -> -- func : TInterface (Name {namespace = "GLib", name = "TranslateFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Sets the function which is used to translate user-visible strings,
-- for @--help@ output. Different groups can use different
-- @/GTranslateFuncs/@. If /@func@/ is 'P.Nothing', strings are not translated.
-- 
-- If you are using @/gettext()/@, you only need to set the translation
-- domain, see 'GI.GLib.Structs.OptionGroup.optionGroupSetTranslationDomain'.
-- 
-- /Since: 2.6/
optionGroupSetTranslateFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> Maybe (GLib.Callbacks.TranslateFunc)
    -- ^ /@func@/: the t'GI.GLib.Callbacks.TranslateFunc', or 'P.Nothing'
    -> m ()
optionGroupSetTranslateFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> Maybe TranslateFunc -> m ()
optionGroupSetTranslateFunc OptionGroup
group Maybe TranslateFunc
func = 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 OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    FunPtr C_TranslateFunc
maybeFunc <- case Maybe TranslateFunc
func of
        Maybe TranslateFunc
Nothing -> FunPtr C_TranslateFunc -> IO (FunPtr C_TranslateFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_TranslateFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just TranslateFunc
jFunc -> do
            FunPtr C_TranslateFunc
jFunc' <- C_TranslateFunc -> IO (FunPtr C_TranslateFunc)
GLib.Callbacks.mk_TranslateFunc (Maybe (Ptr (FunPtr C_TranslateFunc))
-> TranslateFunc_WithClosures -> C_TranslateFunc
GLib.Callbacks.wrap_TranslateFunc Maybe (Ptr (FunPtr C_TranslateFunc))
forall a. Maybe a
Nothing (TranslateFunc -> TranslateFunc_WithClosures
GLib.Callbacks.drop_closures_TranslateFunc TranslateFunc
jFunc))
            FunPtr C_TranslateFunc -> IO (FunPtr C_TranslateFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TranslateFunc
jFunc'
    let data_ :: Ptr ()
data_ = FunPtr C_TranslateFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TranslateFunc
maybeFunc
    let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr OptionGroup
-> FunPtr C_TranslateFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
g_option_group_set_translate_func Ptr OptionGroup
group' FunPtr C_TranslateFunc
maybeFunc Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionGroupSetTranslateFuncMethodInfo
instance (signature ~ (Maybe (GLib.Callbacks.TranslateFunc) -> m ()), MonadIO m) => O.OverloadedMethod OptionGroupSetTranslateFuncMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupSetTranslateFunc

instance O.OverloadedMethodInfo OptionGroupSetTranslateFuncMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupSetTranslateFunc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupSetTranslateFunc"
        })


#endif

-- method OptionGroup::set_translation_domain
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "group"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "OptionGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOptionGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "domain"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the domain to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_option_group_set_translation_domain" g_option_group_set_translation_domain :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    CString ->                              -- domain : TBasicType TUTF8
    IO ()

-- | A convenience function to use @/gettext()/@ for translating
-- user-visible strings.
-- 
-- /Since: 2.6/
optionGroupSetTranslationDomain ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> T.Text
    -- ^ /@domain@/: the domain to use
    -> m ()
optionGroupSetTranslationDomain :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> Text -> m ()
optionGroupSetTranslationDomain OptionGroup
group Text
domain = 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 OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    Ptr OptionGroup -> CString -> IO ()
g_option_group_set_translation_domain Ptr OptionGroup
group' CString
domain'
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
domain'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionGroupSetTranslationDomainMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod OptionGroupSetTranslationDomainMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupSetTranslationDomain

instance O.OverloadedMethodInfo OptionGroupSetTranslationDomainMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupSetTranslationDomain",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupSetTranslationDomain"
        })


#endif

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

foreign import ccall "g_option_group_unref" g_option_group_unref :: 
    Ptr OptionGroup ->                      -- group : TInterface (Name {namespace = "GLib", name = "OptionGroup"})
    IO ()

-- | Decrements the reference count of /@group@/ by one.
-- If the reference count drops to 0, the /@group@/ will be freed.
-- and all memory allocated by the /@group@/ is released.
-- 
-- /Since: 2.44/
optionGroupUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    OptionGroup
    -- ^ /@group@/: a t'GI.GLib.Structs.OptionGroup.OptionGroup'
    -> m ()
optionGroupUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionGroup -> m ()
optionGroupUnref OptionGroup
group = 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 OptionGroup
group' <- OptionGroup -> IO (Ptr OptionGroup)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
group
    Ptr OptionGroup -> IO ()
g_option_group_unref Ptr OptionGroup
group'
    OptionGroup -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionGroupUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod OptionGroupUnrefMethodInfo OptionGroup signature where
    overloadedMethod = optionGroupUnref

instance O.OverloadedMethodInfo OptionGroupUnrefMethodInfo OptionGroup where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.OptionGroup.optionGroupUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-OptionGroup.html#v:optionGroupUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveOptionGroupMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveOptionGroupMethod "addEntries" o = OptionGroupAddEntriesMethodInfo
    ResolveOptionGroupMethod "free" o = OptionGroupFreeMethodInfo
    ResolveOptionGroupMethod "ref" o = OptionGroupRefMethodInfo
    ResolveOptionGroupMethod "unref" o = OptionGroupUnrefMethodInfo
    ResolveOptionGroupMethod "setTranslateFunc" o = OptionGroupSetTranslateFuncMethodInfo
    ResolveOptionGroupMethod "setTranslationDomain" o = OptionGroupSetTranslationDomainMethodInfo
    ResolveOptionGroupMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveOptionGroupMethod t OptionGroup, O.OverloadedMethod info OptionGroup p) => OL.IsLabel t (OptionGroup -> 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 ~ ResolveOptionGroupMethod t OptionGroup, O.OverloadedMethod info OptionGroup p, R.HasField t OptionGroup p) => R.HasField t OptionGroup p where
    getField = O.overloadedMethod @info

#endif

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

#endif