{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.OptionContext
(
OptionContext(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveOptionContextMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
OptionContextAddGroupMethodInfo ,
#endif
optionContextAddGroup ,
#if defined(ENABLE_OVERLOADING)
OptionContextAddMainEntriesMethodInfo ,
#endif
optionContextAddMainEntries ,
#if defined(ENABLE_OVERLOADING)
OptionContextFreeMethodInfo ,
#endif
optionContextFree ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetDescriptionMethodInfo ,
#endif
optionContextGetDescription ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetHelpMethodInfo ,
#endif
optionContextGetHelp ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetHelpEnabledMethodInfo ,
#endif
optionContextGetHelpEnabled ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetIgnoreUnknownOptionsMethodInfo,
#endif
optionContextGetIgnoreUnknownOptions ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetMainGroupMethodInfo ,
#endif
optionContextGetMainGroup ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetStrictPosixMethodInfo ,
#endif
optionContextGetStrictPosix ,
#if defined(ENABLE_OVERLOADING)
OptionContextGetSummaryMethodInfo ,
#endif
optionContextGetSummary ,
#if defined(ENABLE_OVERLOADING)
OptionContextParseMethodInfo ,
#endif
optionContextParse ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetDescriptionMethodInfo ,
#endif
optionContextSetDescription ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetHelpEnabledMethodInfo ,
#endif
optionContextSetHelpEnabled ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetIgnoreUnknownOptionsMethodInfo,
#endif
optionContextSetIgnoreUnknownOptions ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetMainGroupMethodInfo ,
#endif
optionContextSetMainGroup ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetStrictPosixMethodInfo ,
#endif
optionContextSetStrictPosix ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetSummaryMethodInfo ,
#endif
optionContextSetSummary ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetTranslateFuncMethodInfo ,
#endif
optionContextSetTranslateFunc ,
#if defined(ENABLE_OVERLOADING)
OptionContextSetTranslationDomainMethodInfo,
#endif
optionContextSetTranslationDomain ,
) 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 GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.OptionEntry as GLib.OptionEntry
import {-# SOURCE #-} qualified GI.GLib.Structs.OptionGroup as GLib.OptionGroup
newtype OptionContext = OptionContext (SP.ManagedPtr OptionContext)
deriving (OptionContext -> OptionContext -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptionContext -> OptionContext -> Bool
$c/= :: OptionContext -> OptionContext -> Bool
== :: OptionContext -> OptionContext -> Bool
$c== :: OptionContext -> OptionContext -> Bool
Eq)
instance SP.ManagedPtrNewtype OptionContext where
toManagedPtr :: OptionContext -> ManagedPtr OptionContext
toManagedPtr (OptionContext ManagedPtr OptionContext
p) = ManagedPtr OptionContext
p
instance BoxedPtr OptionContext where
boxedPtrCopy :: OptionContext -> IO OptionContext
boxedPtrCopy = forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: OptionContext -> IO ()
boxedPtrFree = \OptionContext
_x -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OptionContext
type instance O.AttributeList OptionContext = OptionContextAttributeList
type OptionContextAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_option_context_add_group" g_option_context_add_group ::
Ptr OptionContext ->
Ptr GLib.OptionGroup.OptionGroup ->
IO ()
optionContextAddGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> GLib.OptionGroup.OptionGroup
-> m ()
optionContextAddGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> OptionGroup -> m ()
optionContextAddGroup OptionContext
context OptionGroup
group = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr OptionGroup
group' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed OptionGroup
group
Ptr OptionContext -> Ptr OptionGroup -> IO ()
g_option_context_add_group Ptr OptionContext
context' Ptr OptionGroup
group'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextAddGroupMethodInfo
instance (signature ~ (GLib.OptionGroup.OptionGroup -> m ()), MonadIO m) => O.OverloadedMethod OptionContextAddGroupMethodInfo OptionContext signature where
overloadedMethod = optionContextAddGroup
instance O.OverloadedMethodInfo OptionContextAddGroupMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextAddGroup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextAddGroup"
})
#endif
foreign import ccall "g_option_context_add_main_entries" g_option_context_add_main_entries ::
Ptr OptionContext ->
Ptr (Ptr GLib.OptionEntry.OptionEntry) ->
CString ->
IO ()
optionContextAddMainEntries ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> [GLib.OptionEntry.OptionEntry]
-> Maybe (T.Text)
-> m ()
optionContextAddMainEntries :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> [OptionEntry] -> Maybe Text -> m ()
optionContextAddMainEntries OptionContext
context [OptionEntry]
entries Maybe Text
translationDomain = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
[Ptr OptionEntry]
entries' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [OptionEntry]
entries
Ptr (Ptr OptionEntry)
entries'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr OptionEntry]
entries'
Ptr CChar
maybeTranslationDomain <- case Maybe Text
translationDomain of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jTranslationDomain -> do
Ptr CChar
jTranslationDomain' <- Text -> IO (Ptr CChar)
textToCString Text
jTranslationDomain
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jTranslationDomain'
Ptr OptionContext -> Ptr (Ptr OptionEntry) -> Ptr CChar -> IO ()
g_option_context_add_main_entries Ptr OptionContext
context' Ptr (Ptr OptionEntry)
entries'' Ptr CChar
maybeTranslationDomain
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [OptionEntry]
entries
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr OptionEntry)
entries''
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeTranslationDomain
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextAddMainEntriesMethodInfo
instance (signature ~ ([GLib.OptionEntry.OptionEntry] -> Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod OptionContextAddMainEntriesMethodInfo OptionContext signature where
overloadedMethod = optionContextAddMainEntries
instance O.OverloadedMethodInfo OptionContextAddMainEntriesMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextAddMainEntries",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextAddMainEntries"
})
#endif
foreign import ccall "g_option_context_free" g_option_context_free ::
Ptr OptionContext ->
IO ()
optionContextFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m ()
optionContextFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m ()
optionContextFree OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr OptionContext -> IO ()
g_option_context_free Ptr OptionContext
context'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod OptionContextFreeMethodInfo OptionContext signature where
overloadedMethod = optionContextFree
instance O.OverloadedMethodInfo OptionContextFreeMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextFree"
})
#endif
foreign import ccall "g_option_context_get_description" g_option_context_get_description ::
Ptr OptionContext ->
IO CString
optionContextGetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m T.Text
optionContextGetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m Text
optionContextGetDescription OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr CChar
result <- Ptr OptionContext -> IO (Ptr CChar)
g_option_context_get_description Ptr OptionContext
context'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionContextGetDescription" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
cstringToText Ptr CChar
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod OptionContextGetDescriptionMethodInfo OptionContext signature where
overloadedMethod = optionContextGetDescription
instance O.OverloadedMethodInfo OptionContextGetDescriptionMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetDescription"
})
#endif
foreign import ccall "g_option_context_get_help" g_option_context_get_help ::
Ptr OptionContext ->
CInt ->
Ptr GLib.OptionGroup.OptionGroup ->
IO CString
optionContextGetHelp ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Bool
-> Maybe (GLib.OptionGroup.OptionGroup)
-> m T.Text
optionContextGetHelp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Bool -> Maybe OptionGroup -> m Text
optionContextGetHelp OptionContext
context Bool
mainHelp Maybe OptionGroup
group = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
let mainHelp' :: CInt
mainHelp' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
mainHelp
Ptr OptionGroup
maybeGroup <- case Maybe OptionGroup
group of
Maybe OptionGroup
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just OptionGroup
jGroup -> do
Ptr OptionGroup
jGroup' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionGroup
jGroup
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr OptionGroup
jGroup'
Ptr CChar
result <- Ptr OptionContext -> CInt -> Ptr OptionGroup -> IO (Ptr CChar)
g_option_context_get_help Ptr OptionContext
context' CInt
mainHelp' Ptr OptionGroup
maybeGroup
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionContextGetHelp" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
cstringToText Ptr CChar
result
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe OptionGroup
group forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetHelpMethodInfo
instance (signature ~ (Bool -> Maybe (GLib.OptionGroup.OptionGroup) -> m T.Text), MonadIO m) => O.OverloadedMethod OptionContextGetHelpMethodInfo OptionContext signature where
overloadedMethod = optionContextGetHelp
instance O.OverloadedMethodInfo OptionContextGetHelpMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetHelp",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetHelp"
})
#endif
foreign import ccall "g_option_context_get_help_enabled" g_option_context_get_help_enabled ::
Ptr OptionContext ->
IO CInt
optionContextGetHelpEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m Bool
optionContextGetHelpEnabled :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m Bool
optionContextGetHelpEnabled OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
CInt
result <- Ptr OptionContext -> IO CInt
g_option_context_get_help_enabled Ptr OptionContext
context'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetHelpEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod OptionContextGetHelpEnabledMethodInfo OptionContext signature where
overloadedMethod = optionContextGetHelpEnabled
instance O.OverloadedMethodInfo OptionContextGetHelpEnabledMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetHelpEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetHelpEnabled"
})
#endif
foreign import ccall "g_option_context_get_ignore_unknown_options" g_option_context_get_ignore_unknown_options ::
Ptr OptionContext ->
IO CInt
optionContextGetIgnoreUnknownOptions ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m Bool
optionContextGetIgnoreUnknownOptions :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m Bool
optionContextGetIgnoreUnknownOptions OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
CInt
result <- Ptr OptionContext -> IO CInt
g_option_context_get_ignore_unknown_options Ptr OptionContext
context'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetIgnoreUnknownOptionsMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod OptionContextGetIgnoreUnknownOptionsMethodInfo OptionContext signature where
overloadedMethod = optionContextGetIgnoreUnknownOptions
instance O.OverloadedMethodInfo OptionContextGetIgnoreUnknownOptionsMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetIgnoreUnknownOptions",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetIgnoreUnknownOptions"
})
#endif
foreign import ccall "g_option_context_get_main_group" g_option_context_get_main_group ::
Ptr OptionContext ->
IO (Ptr GLib.OptionGroup.OptionGroup)
optionContextGetMainGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m GLib.OptionGroup.OptionGroup
optionContextGetMainGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m OptionGroup
optionContextGetMainGroup OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr OptionGroup
result <- Ptr OptionContext -> IO (Ptr OptionGroup)
g_option_context_get_main_group Ptr OptionContext
context'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionContextGetMainGroup" Ptr OptionGroup
result
OptionGroup
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr OptionGroup -> OptionGroup
GLib.OptionGroup.OptionGroup) Ptr OptionGroup
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return OptionGroup
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetMainGroupMethodInfo
instance (signature ~ (m GLib.OptionGroup.OptionGroup), MonadIO m) => O.OverloadedMethod OptionContextGetMainGroupMethodInfo OptionContext signature where
overloadedMethod = optionContextGetMainGroup
instance O.OverloadedMethodInfo OptionContextGetMainGroupMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetMainGroup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetMainGroup"
})
#endif
foreign import ccall "g_option_context_get_strict_posix" g_option_context_get_strict_posix ::
Ptr OptionContext ->
IO CInt
optionContextGetStrictPosix ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m Bool
optionContextGetStrictPosix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m Bool
optionContextGetStrictPosix OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
CInt
result <- Ptr OptionContext -> IO CInt
g_option_context_get_strict_posix Ptr OptionContext
context'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetStrictPosixMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod OptionContextGetStrictPosixMethodInfo OptionContext signature where
overloadedMethod = optionContextGetStrictPosix
instance O.OverloadedMethodInfo OptionContextGetStrictPosixMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetStrictPosix",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetStrictPosix"
})
#endif
foreign import ccall "g_option_context_get_summary" g_option_context_get_summary ::
Ptr OptionContext ->
IO CString
optionContextGetSummary ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> m T.Text
optionContextGetSummary :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> m Text
optionContextGetSummary OptionContext
context = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr CChar
result <- Ptr OptionContext -> IO (Ptr CChar)
g_option_context_get_summary Ptr OptionContext
context'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"optionContextGetSummary" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
cstringToText Ptr CChar
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data OptionContextGetSummaryMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod OptionContextGetSummaryMethodInfo OptionContext signature where
overloadedMethod = optionContextGetSummary
instance O.OverloadedMethodInfo OptionContextGetSummaryMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextGetSummary",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextGetSummary"
})
#endif
foreign import ccall "g_option_context_parse" g_option_context_parse ::
Ptr OptionContext ->
Ptr Int32 ->
Ptr (Ptr CString) ->
Ptr (Ptr GError) ->
IO CInt
optionContextParse ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Maybe ([T.Text])
-> m ((Maybe [T.Text]))
optionContextParse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Maybe [Text] -> m (Maybe [Text])
optionContextParse OptionContext
context Maybe [Text]
argv = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let argc :: Int32
argc = case Maybe [Text]
argv of
Maybe [Text]
Nothing -> Int32
0
Just [Text]
jArgv -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
jArgv
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr Int32
argc' <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Int32
argc' Int32
argc
Ptr (Ptr CChar)
maybeArgv <- case Maybe [Text]
argv of
Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just [Text]
jArgv -> do
Ptr (Ptr CChar)
jArgv' <- [Text] -> IO (Ptr (Ptr CChar))
packUTF8CArray [Text]
jArgv
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
jArgv'
Ptr (Ptr (Ptr CChar))
maybeArgv' <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr CString))
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr (Ptr CChar))
maybeArgv' Ptr (Ptr CChar)
maybeArgv
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr OptionContext
-> Ptr Int32
-> Ptr (Ptr (Ptr CChar))
-> Ptr (Ptr GError)
-> IO CInt
g_option_context_parse Ptr OptionContext
context' Ptr Int32
argc' Ptr (Ptr (Ptr CChar))
maybeArgv'
Int32
argc'' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
argc'
Ptr (Ptr CChar)
maybeArgv'' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (Ptr CChar))
maybeArgv'
Maybe [Text]
maybeMaybeArgv'' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (Ptr CChar)
maybeArgv'' forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr CChar)
maybeArgv''' -> do
[Text]
maybeArgv'''' <- (forall a.
(HasCallStack, Integral a) =>
a -> Ptr (Ptr CChar) -> IO [Text]
unpackUTF8CArrayWithLength Int32
argc'') Ptr (Ptr CChar)
maybeArgv'''
(forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Int32
argc'') forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeArgv'''
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeArgv'''
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
maybeArgv''''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. Ptr a -> IO ()
freeMem Ptr Int32
argc'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (Ptr CChar))
maybeArgv'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeMaybeArgv''
) (do
forall a. Ptr a -> IO ()
freeMem Ptr Int32
argc'
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (Ptr CChar))
maybeArgv'
)
#if defined(ENABLE_OVERLOADING)
data OptionContextParseMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ((Maybe [T.Text]))), MonadIO m) => O.OverloadedMethod OptionContextParseMethodInfo OptionContext signature where
overloadedMethod = optionContextParse
instance O.OverloadedMethodInfo OptionContextParseMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextParse",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextParse"
})
#endif
foreign import ccall "g_option_context_set_description" g_option_context_set_description ::
Ptr OptionContext ->
CString ->
IO ()
optionContextSetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Maybe (T.Text)
-> m ()
optionContextSetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Maybe Text -> m ()
optionContextSetDescription OptionContext
context Maybe Text
description = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr CChar
maybeDescription <- case Maybe Text
description of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jDescription -> do
Ptr CChar
jDescription' <- Text -> IO (Ptr CChar)
textToCString Text
jDescription
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDescription'
Ptr OptionContext -> Ptr CChar -> IO ()
g_option_context_set_description Ptr OptionContext
context' Ptr CChar
maybeDescription
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeDescription
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetDescriptionMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetDescriptionMethodInfo OptionContext signature where
overloadedMethod = optionContextSetDescription
instance O.OverloadedMethodInfo OptionContextSetDescriptionMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetDescription"
})
#endif
foreign import ccall "g_option_context_set_help_enabled" g_option_context_set_help_enabled ::
Ptr OptionContext ->
CInt ->
IO ()
optionContextSetHelpEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Bool
-> m ()
optionContextSetHelpEnabled :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Bool -> m ()
optionContextSetHelpEnabled OptionContext
context Bool
helpEnabled = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
let helpEnabled' :: CInt
helpEnabled' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
helpEnabled
Ptr OptionContext -> CInt -> IO ()
g_option_context_set_help_enabled Ptr OptionContext
context' CInt
helpEnabled'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetHelpEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetHelpEnabledMethodInfo OptionContext signature where
overloadedMethod = optionContextSetHelpEnabled
instance O.OverloadedMethodInfo OptionContextSetHelpEnabledMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetHelpEnabled",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetHelpEnabled"
})
#endif
foreign import ccall "g_option_context_set_ignore_unknown_options" g_option_context_set_ignore_unknown_options ::
Ptr OptionContext ->
CInt ->
IO ()
optionContextSetIgnoreUnknownOptions ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Bool
-> m ()
optionContextSetIgnoreUnknownOptions :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Bool -> m ()
optionContextSetIgnoreUnknownOptions OptionContext
context Bool
ignoreUnknown = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
let ignoreUnknown' :: CInt
ignoreUnknown' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
ignoreUnknown
Ptr OptionContext -> CInt -> IO ()
g_option_context_set_ignore_unknown_options Ptr OptionContext
context' CInt
ignoreUnknown'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetIgnoreUnknownOptionsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetIgnoreUnknownOptionsMethodInfo OptionContext signature where
overloadedMethod = optionContextSetIgnoreUnknownOptions
instance O.OverloadedMethodInfo OptionContextSetIgnoreUnknownOptionsMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetIgnoreUnknownOptions",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetIgnoreUnknownOptions"
})
#endif
foreign import ccall "g_option_context_set_main_group" g_option_context_set_main_group ::
Ptr OptionContext ->
Ptr GLib.OptionGroup.OptionGroup ->
IO ()
optionContextSetMainGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> GLib.OptionGroup.OptionGroup
-> m ()
optionContextSetMainGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> OptionGroup -> m ()
optionContextSetMainGroup OptionContext
context OptionGroup
group = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr OptionGroup
group' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed OptionGroup
group
Ptr OptionContext -> Ptr OptionGroup -> IO ()
g_option_context_set_main_group Ptr OptionContext
context' Ptr OptionGroup
group'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionGroup
group
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetMainGroupMethodInfo
instance (signature ~ (GLib.OptionGroup.OptionGroup -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetMainGroupMethodInfo OptionContext signature where
overloadedMethod = optionContextSetMainGroup
instance O.OverloadedMethodInfo OptionContextSetMainGroupMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetMainGroup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetMainGroup"
})
#endif
foreign import ccall "g_option_context_set_strict_posix" g_option_context_set_strict_posix ::
Ptr OptionContext ->
CInt ->
IO ()
optionContextSetStrictPosix ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Bool
-> m ()
optionContextSetStrictPosix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Bool -> m ()
optionContextSetStrictPosix OptionContext
context Bool
strictPosix = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
let strictPosix' :: CInt
strictPosix' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
strictPosix
Ptr OptionContext -> CInt -> IO ()
g_option_context_set_strict_posix Ptr OptionContext
context' CInt
strictPosix'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetStrictPosixMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetStrictPosixMethodInfo OptionContext signature where
overloadedMethod = optionContextSetStrictPosix
instance O.OverloadedMethodInfo OptionContextSetStrictPosixMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetStrictPosix",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetStrictPosix"
})
#endif
foreign import ccall "g_option_context_set_summary" g_option_context_set_summary ::
Ptr OptionContext ->
CString ->
IO ()
optionContextSetSummary ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Maybe (T.Text)
-> m ()
optionContextSetSummary :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Maybe Text -> m ()
optionContextSetSummary OptionContext
context Maybe Text
summary = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr CChar
maybeSummary <- case Maybe Text
summary of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jSummary -> do
Ptr CChar
jSummary' <- Text -> IO (Ptr CChar)
textToCString Text
jSummary
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jSummary'
Ptr OptionContext -> Ptr CChar -> IO ()
g_option_context_set_summary Ptr OptionContext
context' Ptr CChar
maybeSummary
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSummary
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetSummaryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetSummaryMethodInfo OptionContext signature where
overloadedMethod = optionContextSetSummary
instance O.OverloadedMethodInfo OptionContextSetSummaryMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetSummary",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetSummary"
})
#endif
foreign import ccall "g_option_context_set_translate_func" g_option_context_set_translate_func ::
Ptr OptionContext ->
FunPtr GLib.Callbacks.C_TranslateFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
optionContextSetTranslateFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> Maybe (GLib.Callbacks.TranslateFunc)
-> m ()
optionContextSetTranslateFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Maybe TranslateFunc -> m ()
optionContextSetTranslateFunc OptionContext
context Maybe TranslateFunc
func = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
FunPtr C_TranslateFunc
maybeFunc <- case Maybe TranslateFunc
func of
Maybe TranslateFunc
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr 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 -> C_TranslateFunc
GLib.Callbacks.wrap_TranslateFunc forall a. Maybe a
Nothing TranslateFunc
jFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_TranslateFunc
jFunc'
let data_ :: Ptr ()
data_ = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TranslateFunc
maybeFunc
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr OptionContext
-> FunPtr C_TranslateFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
g_option_context_set_translate_func Ptr OptionContext
context' FunPtr C_TranslateFunc
maybeFunc Ptr ()
data_ forall a. FunPtr (Ptr a -> IO ())
destroyNotify
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetTranslateFuncMethodInfo
instance (signature ~ (Maybe (GLib.Callbacks.TranslateFunc) -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetTranslateFuncMethodInfo OptionContext signature where
overloadedMethod = optionContextSetTranslateFunc
instance O.OverloadedMethodInfo OptionContextSetTranslateFuncMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetTranslateFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetTranslateFunc"
})
#endif
foreign import ccall "g_option_context_set_translation_domain" g_option_context_set_translation_domain ::
Ptr OptionContext ->
CString ->
IO ()
optionContextSetTranslationDomain ::
(B.CallStack.HasCallStack, MonadIO m) =>
OptionContext
-> T.Text
-> m ()
optionContextSetTranslationDomain :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OptionContext -> Text -> m ()
optionContextSetTranslationDomain OptionContext
context Text
domain = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr OptionContext
context' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OptionContext
context
Ptr CChar
domain' <- Text -> IO (Ptr CChar)
textToCString Text
domain
Ptr OptionContext -> Ptr CChar -> IO ()
g_option_context_set_translation_domain Ptr OptionContext
context' Ptr CChar
domain'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OptionContext
context
forall a. Ptr a -> IO ()
freeMem Ptr CChar
domain'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OptionContextSetTranslationDomainMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod OptionContextSetTranslationDomainMethodInfo OptionContext signature where
overloadedMethod = optionContextSetTranslationDomain
instance O.OverloadedMethodInfo OptionContextSetTranslationDomainMethodInfo OptionContext where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.OptionContext.optionContextSetTranslationDomain",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-OptionContext.html#v:optionContextSetTranslationDomain"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveOptionContextMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveOptionContextMethod "addGroup" o = OptionContextAddGroupMethodInfo
ResolveOptionContextMethod "addMainEntries" o = OptionContextAddMainEntriesMethodInfo
ResolveOptionContextMethod "free" o = OptionContextFreeMethodInfo
ResolveOptionContextMethod "parse" o = OptionContextParseMethodInfo
ResolveOptionContextMethod "getDescription" o = OptionContextGetDescriptionMethodInfo
ResolveOptionContextMethod "getHelp" o = OptionContextGetHelpMethodInfo
ResolveOptionContextMethod "getHelpEnabled" o = OptionContextGetHelpEnabledMethodInfo
ResolveOptionContextMethod "getIgnoreUnknownOptions" o = OptionContextGetIgnoreUnknownOptionsMethodInfo
ResolveOptionContextMethod "getMainGroup" o = OptionContextGetMainGroupMethodInfo
ResolveOptionContextMethod "getStrictPosix" o = OptionContextGetStrictPosixMethodInfo
ResolveOptionContextMethod "getSummary" o = OptionContextGetSummaryMethodInfo
ResolveOptionContextMethod "setDescription" o = OptionContextSetDescriptionMethodInfo
ResolveOptionContextMethod "setHelpEnabled" o = OptionContextSetHelpEnabledMethodInfo
ResolveOptionContextMethod "setIgnoreUnknownOptions" o = OptionContextSetIgnoreUnknownOptionsMethodInfo
ResolveOptionContextMethod "setMainGroup" o = OptionContextSetMainGroupMethodInfo
ResolveOptionContextMethod "setStrictPosix" o = OptionContextSetStrictPosixMethodInfo
ResolveOptionContextMethod "setSummary" o = OptionContextSetSummaryMethodInfo
ResolveOptionContextMethod "setTranslateFunc" o = OptionContextSetTranslateFuncMethodInfo
ResolveOptionContextMethod "setTranslationDomain" o = OptionContextSetTranslationDomainMethodInfo
ResolveOptionContextMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveOptionContextMethod t OptionContext, O.OverloadedMethod info OptionContext p) => OL.IsLabel t (OptionContext -> 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 ~ ResolveOptionContextMethod t OptionContext, O.OverloadedMethod info OptionContext p, R.HasField t OptionContext p) => R.HasField t OptionContext p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveOptionContextMethod t OptionContext, O.OverloadedMethodInfo info OptionContext) => OL.IsLabel t (O.MethodProxy info OptionContext) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif