{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.SettingsBackend
(
#if defined(ENABLE_OVERLOADING)
SettingsBackendFlattenTreeMethodInfo ,
#endif
SettingsBackend(..) ,
IsSettingsBackend ,
toSettingsBackend ,
#if defined(ENABLE_OVERLOADING)
ResolveSettingsBackendMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SettingsBackendChangedMethodInfo ,
#endif
settingsBackendChanged ,
#if defined(ENABLE_OVERLOADING)
SettingsBackendChangedTreeMethodInfo ,
#endif
settingsBackendChangedTree ,
settingsBackendGetDefault ,
#if defined(ENABLE_OVERLOADING)
SettingsBackendKeysChangedMethodInfo ,
#endif
settingsBackendKeysChanged ,
#if defined(ENABLE_OVERLOADING)
SettingsBackendPathChangedMethodInfo ,
#endif
settingsBackendPathChanged ,
#if defined(ENABLE_OVERLOADING)
SettingsBackendPathWritableChangedMethodInfo,
#endif
settingsBackendPathWritableChanged ,
#if defined(ENABLE_OVERLOADING)
SettingsBackendWritableChangedMethodInfo,
#endif
settingsBackendWritableChanged ,
) 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
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Structs.Tree as GLib.Tree
import qualified GI.GObject.Objects.Object as GObject.Object
#else
import qualified GI.GLib.Structs.Tree as GLib.Tree
import qualified GI.GObject.Objects.Object as GObject.Object
#endif
newtype SettingsBackend = SettingsBackend (SP.ManagedPtr SettingsBackend)
deriving (SettingsBackend -> SettingsBackend -> Bool
(SettingsBackend -> SettingsBackend -> Bool)
-> (SettingsBackend -> SettingsBackend -> Bool)
-> Eq SettingsBackend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingsBackend -> SettingsBackend -> Bool
== :: SettingsBackend -> SettingsBackend -> Bool
$c/= :: SettingsBackend -> SettingsBackend -> Bool
/= :: SettingsBackend -> SettingsBackend -> Bool
Eq)
instance SP.ManagedPtrNewtype SettingsBackend where
toManagedPtr :: SettingsBackend -> ManagedPtr SettingsBackend
toManagedPtr (SettingsBackend ManagedPtr SettingsBackend
p) = ManagedPtr SettingsBackend
p
foreign import ccall "g_settings_backend_get_type"
c_g_settings_backend_get_type :: IO B.Types.GType
instance B.Types.TypedObject SettingsBackend where
glibType :: IO GType
glibType = IO GType
c_g_settings_backend_get_type
instance B.Types.GObject SettingsBackend
class (SP.GObject o, O.IsDescendantOf SettingsBackend o) => IsSettingsBackend o
instance (SP.GObject o, O.IsDescendantOf SettingsBackend o) => IsSettingsBackend o
instance O.HasParentTypes SettingsBackend
type instance O.ParentTypes SettingsBackend = '[GObject.Object.Object]
toSettingsBackend :: (MIO.MonadIO m, IsSettingsBackend o) => o -> m SettingsBackend
toSettingsBackend :: forall (m :: * -> *) o.
(MonadIO m, IsSettingsBackend o) =>
o -> m SettingsBackend
toSettingsBackend = IO SettingsBackend -> m SettingsBackend
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SettingsBackend -> m SettingsBackend)
-> (o -> IO SettingsBackend) -> o -> m SettingsBackend
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SettingsBackend -> SettingsBackend)
-> o -> IO SettingsBackend
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr SettingsBackend -> SettingsBackend
SettingsBackend
instance B.GValue.IsGValue (Maybe SettingsBackend) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_settings_backend_get_type
gvalueSet_ :: Ptr GValue -> Maybe SettingsBackend -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SettingsBackend
P.Nothing = Ptr GValue -> Ptr SettingsBackend -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SettingsBackend
forall a. Ptr a
FP.nullPtr :: FP.Ptr SettingsBackend)
gvalueSet_ Ptr GValue
gv (P.Just SettingsBackend
obj) = SettingsBackend -> (Ptr SettingsBackend -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SettingsBackend
obj (Ptr GValue -> Ptr SettingsBackend -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe SettingsBackend)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr SettingsBackend)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SettingsBackend)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject SettingsBackend ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveSettingsBackendMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveSettingsBackendMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSettingsBackendMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSettingsBackendMethod "changed" o = SettingsBackendChangedMethodInfo
ResolveSettingsBackendMethod "changedTree" o = SettingsBackendChangedTreeMethodInfo
ResolveSettingsBackendMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSettingsBackendMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSettingsBackendMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSettingsBackendMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSettingsBackendMethod "keysChanged" o = SettingsBackendKeysChangedMethodInfo
ResolveSettingsBackendMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSettingsBackendMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSettingsBackendMethod "pathChanged" o = SettingsBackendPathChangedMethodInfo
ResolveSettingsBackendMethod "pathWritableChanged" o = SettingsBackendPathWritableChangedMethodInfo
ResolveSettingsBackendMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSettingsBackendMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSettingsBackendMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSettingsBackendMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSettingsBackendMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSettingsBackendMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSettingsBackendMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSettingsBackendMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSettingsBackendMethod "writableChanged" o = SettingsBackendWritableChangedMethodInfo
ResolveSettingsBackendMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSettingsBackendMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSettingsBackendMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSettingsBackendMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSettingsBackendMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveSettingsBackendMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSettingsBackendMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSettingsBackendMethod t SettingsBackend, O.OverloadedMethod info SettingsBackend p) => OL.IsLabel t (SettingsBackend -> 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 ~ ResolveSettingsBackendMethod t SettingsBackend, O.OverloadedMethod info SettingsBackend p, R.HasField t SettingsBackend p) => R.HasField t SettingsBackend p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSettingsBackendMethod t SettingsBackend, O.OverloadedMethodInfo info SettingsBackend) => OL.IsLabel t (O.MethodProxy info SettingsBackend) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SettingsBackend
type instance O.AttributeList SettingsBackend = SettingsBackendAttributeList
type SettingsBackendAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SettingsBackend = SettingsBackendSignalList
type SettingsBackendSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_settings_backend_changed" g_settings_backend_changed ::
Ptr SettingsBackend ->
CString ->
Ptr () ->
IO ()
settingsBackendChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> T.Text
-> Ptr ()
-> m ()
settingsBackendChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Text -> Ptr () -> m ()
settingsBackendChanged a
backend Text
key Ptr ()
originTag = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
key' <- textToCString key
g_settings_backend_changed backend' key' originTag
touchManagedPtr backend
freeMem key'
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendChangedMethodInfo
instance (signature ~ (T.Text -> Ptr () -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendChangedMethodInfo a signature where
overloadedMethod = settingsBackendChanged
instance O.OverloadedMethodInfo SettingsBackendChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendChanged"
})
#endif
foreign import ccall "g_settings_backend_changed_tree" g_settings_backend_changed_tree ::
Ptr SettingsBackend ->
Ptr GLib.Tree.Tree ->
Ptr () ->
IO ()
settingsBackendChangedTree ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> GLib.Tree.Tree
-> Ptr ()
-> m ()
settingsBackendChangedTree :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Tree -> Ptr () -> m ()
settingsBackendChangedTree a
backend Tree
tree Ptr ()
originTag = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
tree' <- unsafeManagedPtrGetPtr tree
g_settings_backend_changed_tree backend' tree' originTag
touchManagedPtr backend
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendChangedTreeMethodInfo
instance (signature ~ (GLib.Tree.Tree -> Ptr () -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendChangedTreeMethodInfo a signature where
overloadedMethod = settingsBackendChangedTree
instance O.OverloadedMethodInfo SettingsBackendChangedTreeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendChangedTree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendChangedTree"
})
#endif
foreign import ccall "g_settings_backend_keys_changed" g_settings_backend_keys_changed ::
Ptr SettingsBackend ->
CString ->
Ptr CString ->
Ptr () ->
IO ()
settingsBackendKeysChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> T.Text
-> [T.Text]
-> Ptr ()
-> m ()
settingsBackendKeysChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Text -> [Text] -> Ptr () -> m ()
settingsBackendKeysChanged a
backend Text
path [Text]
items Ptr ()
originTag = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
path' <- textToCString path
items' <- packZeroTerminatedUTF8CArray items
g_settings_backend_keys_changed backend' path' items' originTag
touchManagedPtr backend
freeMem path'
mapZeroTerminatedCArray freeMem items'
freeMem items'
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendKeysChangedMethodInfo
instance (signature ~ (T.Text -> [T.Text] -> Ptr () -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendKeysChangedMethodInfo a signature where
overloadedMethod = settingsBackendKeysChanged
instance O.OverloadedMethodInfo SettingsBackendKeysChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendKeysChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendKeysChanged"
})
#endif
foreign import ccall "g_settings_backend_path_changed" g_settings_backend_path_changed ::
Ptr SettingsBackend ->
CString ->
Ptr () ->
IO ()
settingsBackendPathChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> T.Text
-> Ptr ()
-> m ()
settingsBackendPathChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Text -> Ptr () -> m ()
settingsBackendPathChanged a
backend Text
path Ptr ()
originTag = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
path' <- textToCString path
g_settings_backend_path_changed backend' path' originTag
touchManagedPtr backend
freeMem path'
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendPathChangedMethodInfo
instance (signature ~ (T.Text -> Ptr () -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendPathChangedMethodInfo a signature where
overloadedMethod = settingsBackendPathChanged
instance O.OverloadedMethodInfo SettingsBackendPathChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendPathChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendPathChanged"
})
#endif
foreign import ccall "g_settings_backend_path_writable_changed" g_settings_backend_path_writable_changed ::
Ptr SettingsBackend ->
CString ->
IO ()
settingsBackendPathWritableChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> T.Text
-> m ()
settingsBackendPathWritableChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Text -> m ()
settingsBackendPathWritableChanged a
backend Text
path = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
path' <- textToCString path
g_settings_backend_path_writable_changed backend' path'
touchManagedPtr backend
freeMem path'
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendPathWritableChangedMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendPathWritableChangedMethodInfo a signature where
overloadedMethod = settingsBackendPathWritableChanged
instance O.OverloadedMethodInfo SettingsBackendPathWritableChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendPathWritableChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendPathWritableChanged"
})
#endif
foreign import ccall "g_settings_backend_writable_changed" g_settings_backend_writable_changed ::
Ptr SettingsBackend ->
CString ->
IO ()
settingsBackendWritableChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsSettingsBackend a) =>
a
-> T.Text
-> m ()
settingsBackendWritableChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingsBackend a) =>
a -> Text -> m ()
settingsBackendWritableChanged a
backend Text
key = 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
backend' <- a -> IO (Ptr SettingsBackend)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backend
key' <- textToCString key
g_settings_backend_writable_changed backend' key'
touchManagedPtr backend
freeMem key'
return ()
#if defined(ENABLE_OVERLOADING)
data SettingsBackendWritableChangedMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettingsBackend a) => O.OverloadedMethod SettingsBackendWritableChangedMethodInfo a signature where
overloadedMethod = settingsBackendWritableChanged
instance O.OverloadedMethodInfo SettingsBackendWritableChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.SettingsBackend.settingsBackendWritableChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-SettingsBackend.html#v:settingsBackendWritableChanged"
})
#endif
#if defined(ENABLE_OVERLOADING)
data SettingsBackendFlattenTreeMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "flattenTree" SettingsBackend) => O.OverloadedMethod SettingsBackendFlattenTreeMethodInfo o p where
overloadedMethod = undefined
instance (o ~ O.UnsupportedMethodError "flattenTree" SettingsBackend) => O.OverloadedMethodInfo SettingsBackendFlattenTreeMethodInfo o where
overloadedMethodInfo = undefined
#endif
foreign import ccall "g_settings_backend_get_default" g_settings_backend_get_default ::
IO (Ptr SettingsBackend)
settingsBackendGetDefault ::
(B.CallStack.HasCallStack, MonadIO m) =>
m SettingsBackend
settingsBackendGetDefault :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m SettingsBackend
settingsBackendGetDefault = IO SettingsBackend -> m SettingsBackend
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SettingsBackend -> m SettingsBackend)
-> IO SettingsBackend -> m SettingsBackend
forall a b. (a -> b) -> a -> b
$ do
result <- IO (Ptr SettingsBackend)
g_settings_backend_get_default
checkUnexpectedReturnNULL "settingsBackendGetDefault" result
result' <- (wrapObject SettingsBackend) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif