{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.IBus.Objects.Registry
(
Registry(..) ,
IsRegistry ,
toRegistry ,
#if defined(ENABLE_OVERLOADING)
ResolveRegistryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RegistryCheckModificationMethodInfo ,
#endif
registryCheckModification ,
#if defined(ENABLE_OVERLOADING)
RegistryGetComponentsMethodInfo ,
#endif
registryGetComponents ,
#if defined(ENABLE_OVERLOADING)
RegistryGetObservedPathsMethodInfo ,
#endif
registryGetObservedPaths ,
#if defined(ENABLE_OVERLOADING)
RegistryLoadMethodInfo ,
#endif
registryLoad ,
#if defined(ENABLE_OVERLOADING)
RegistryLoadCacheMethodInfo ,
#endif
registryLoadCache ,
#if defined(ENABLE_OVERLOADING)
RegistryLoadCacheFileMethodInfo ,
#endif
registryLoadCacheFile ,
#if defined(ENABLE_OVERLOADING)
RegistryLoadInDirMethodInfo ,
#endif
registryLoadInDir ,
registryNew ,
#if defined(ENABLE_OVERLOADING)
RegistryOutputMethodInfo ,
#endif
registryOutput ,
#if defined(ENABLE_OVERLOADING)
RegistrySaveCacheMethodInfo ,
#endif
registrySaveCache ,
#if defined(ENABLE_OVERLOADING)
RegistrySaveCacheFileMethodInfo ,
#endif
registrySaveCacheFile ,
#if defined(ENABLE_OVERLOADING)
RegistryStartMonitorChangesMethodInfo ,
#endif
registryStartMonitorChanges ,
C_RegistryChangedCallback ,
RegistryChangedCallback ,
#if defined(ENABLE_OVERLOADING)
RegistryChangedSignalInfo ,
#endif
afterRegistryChanged ,
genClosure_RegistryChanged ,
mk_RegistryChangedCallback ,
noRegistryChangedCallback ,
onRegistryChanged ,
wrap_RegistryChangedCallback ,
) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.Component as IBus.Component
import {-# SOURCE #-} qualified GI.IBus.Objects.Object as IBus.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.ObservedPath as IBus.ObservedPath
import {-# SOURCE #-} qualified GI.IBus.Objects.Serializable as IBus.Serializable
newtype Registry = Registry (ManagedPtr Registry)
deriving (Registry -> Registry -> Bool
(Registry -> Registry -> Bool)
-> (Registry -> Registry -> Bool) -> Eq Registry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Registry -> Registry -> Bool
$c/= :: Registry -> Registry -> Bool
== :: Registry -> Registry -> Bool
$c== :: Registry -> Registry -> Bool
Eq)
foreign import ccall "ibus_registry_get_type"
c_ibus_registry_get_type :: IO GType
instance GObject Registry where
gobjectType :: IO GType
gobjectType = IO GType
c_ibus_registry_get_type
instance B.GValue.IsGValue Registry where
toGValue :: Registry -> IO GValue
toGValue Registry
o = do
GType
gtype <- IO GType
c_ibus_registry_get_type
Registry -> (Ptr Registry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Registry
o (GType
-> (GValue -> Ptr Registry -> IO ()) -> Ptr Registry -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Registry -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Registry
fromGValue GValue
gv = do
Ptr Registry
ptr <- GValue -> IO (Ptr Registry)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Registry)
(ManagedPtr Registry -> Registry) -> Ptr Registry -> IO Registry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Registry -> Registry
Registry Ptr Registry
ptr
class (GObject o, O.IsDescendantOf Registry o) => IsRegistry o
instance (GObject o, O.IsDescendantOf Registry o) => IsRegistry o
instance O.HasParentTypes Registry
type instance O.ParentTypes Registry = '[IBus.Serializable.Serializable, IBus.Object.Object, GObject.Object.Object]
toRegistry :: (MonadIO m, IsRegistry o) => o -> m Registry
toRegistry :: o -> m Registry
toRegistry = IO Registry -> m Registry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Registry -> m Registry)
-> (o -> IO Registry) -> o -> m Registry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Registry -> Registry) -> o -> IO Registry
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Registry -> Registry
Registry
#if defined(ENABLE_OVERLOADING)
type family ResolveRegistryMethod (t :: Symbol) (o :: *) :: * where
ResolveRegistryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRegistryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRegistryMethod "checkModification" o = RegistryCheckModificationMethodInfo
ResolveRegistryMethod "copy" o = IBus.Serializable.SerializableCopyMethodInfo
ResolveRegistryMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
ResolveRegistryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRegistryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRegistryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRegistryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRegistryMethod "load" o = RegistryLoadMethodInfo
ResolveRegistryMethod "loadCache" o = RegistryLoadCacheMethodInfo
ResolveRegistryMethod "loadCacheFile" o = RegistryLoadCacheFileMethodInfo
ResolveRegistryMethod "loadInDir" o = RegistryLoadInDirMethodInfo
ResolveRegistryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRegistryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRegistryMethod "output" o = RegistryOutputMethodInfo
ResolveRegistryMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRegistryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRegistryMethod "removeQattachment" o = IBus.Serializable.SerializableRemoveQattachmentMethodInfo
ResolveRegistryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRegistryMethod "saveCache" o = RegistrySaveCacheMethodInfo
ResolveRegistryMethod "saveCacheFile" o = RegistrySaveCacheFileMethodInfo
ResolveRegistryMethod "serializeObject" o = IBus.Serializable.SerializableSerializeObjectMethodInfo
ResolveRegistryMethod "startMonitorChanges" o = RegistryStartMonitorChangesMethodInfo
ResolveRegistryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRegistryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRegistryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRegistryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRegistryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRegistryMethod "getComponents" o = RegistryGetComponentsMethodInfo
ResolveRegistryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRegistryMethod "getObservedPaths" o = RegistryGetObservedPathsMethodInfo
ResolveRegistryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRegistryMethod "getQattachment" o = IBus.Serializable.SerializableGetQattachmentMethodInfo
ResolveRegistryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRegistryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRegistryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRegistryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRegistryMethod "setQattachment" o = IBus.Serializable.SerializableSetQattachmentMethodInfo
ResolveRegistryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRegistryMethod t Registry, O.MethodInfo info Registry p) => OL.IsLabel t (Registry -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type RegistryChangedCallback =
IO ()
noRegistryChangedCallback :: Maybe RegistryChangedCallback
noRegistryChangedCallback :: Maybe (IO ())
noRegistryChangedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_RegistryChangedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_RegistryChangedCallback :: C_RegistryChangedCallback -> IO (FunPtr C_RegistryChangedCallback)
genClosure_RegistryChanged :: MonadIO m => RegistryChangedCallback -> m (GClosure C_RegistryChangedCallback)
genClosure_RegistryChanged :: IO () -> m (GClosure C_RegistryChangedCallback)
genClosure_RegistryChanged IO ()
cb = IO (GClosure C_RegistryChangedCallback)
-> m (GClosure C_RegistryChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RegistryChangedCallback)
-> m (GClosure C_RegistryChangedCallback))
-> IO (GClosure C_RegistryChangedCallback)
-> m (GClosure C_RegistryChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryChangedCallback
cb' = IO () -> C_RegistryChangedCallback
wrap_RegistryChangedCallback IO ()
cb
C_RegistryChangedCallback -> IO (FunPtr C_RegistryChangedCallback)
mk_RegistryChangedCallback C_RegistryChangedCallback
cb' IO (FunPtr C_RegistryChangedCallback)
-> (FunPtr C_RegistryChangedCallback
-> IO (GClosure C_RegistryChangedCallback))
-> IO (GClosure C_RegistryChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RegistryChangedCallback
-> IO (GClosure C_RegistryChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RegistryChangedCallback ::
RegistryChangedCallback ->
C_RegistryChangedCallback
wrap_RegistryChangedCallback :: IO () -> C_RegistryChangedCallback
wrap_RegistryChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onRegistryChanged :: (IsRegistry a, MonadIO m) => a -> RegistryChangedCallback -> m SignalHandlerId
onRegistryChanged :: a -> IO () -> m SignalHandlerId
onRegistryChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryChangedCallback
cb' = IO () -> C_RegistryChangedCallback
wrap_RegistryChangedCallback IO ()
cb
FunPtr C_RegistryChangedCallback
cb'' <- C_RegistryChangedCallback -> IO (FunPtr C_RegistryChangedCallback)
mk_RegistryChangedCallback C_RegistryChangedCallback
cb'
a
-> Text
-> FunPtr C_RegistryChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_RegistryChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterRegistryChanged :: (IsRegistry a, MonadIO m) => a -> RegistryChangedCallback -> m SignalHandlerId
afterRegistryChanged :: a -> IO () -> m SignalHandlerId
afterRegistryChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryChangedCallback
cb' = IO () -> C_RegistryChangedCallback
wrap_RegistryChangedCallback IO ()
cb
FunPtr C_RegistryChangedCallback
cb'' <- C_RegistryChangedCallback -> IO (FunPtr C_RegistryChangedCallback)
mk_RegistryChangedCallback C_RegistryChangedCallback
cb'
a
-> Text
-> FunPtr C_RegistryChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_RegistryChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data RegistryChangedSignalInfo
instance SignalInfo RegistryChangedSignalInfo where
type HaskellCallbackType RegistryChangedSignalInfo = RegistryChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_RegistryChangedCallback cb
cb'' <- mk_RegistryChangedCallback cb'
connectSignalFunPtr obj "changed" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Registry
type instance O.AttributeList Registry = RegistryAttributeList
type RegistryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Registry = RegistrySignalList
type RegistrySignalList = ('[ '("changed", RegistryChangedSignalInfo), '("destroy", IBus.Object.ObjectDestroySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ibus_registry_new" ibus_registry_new ::
IO (Ptr Registry)
registryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Registry
registryNew :: m Registry
registryNew = IO Registry -> m Registry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Registry -> m Registry) -> IO Registry -> m Registry
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
result <- IO (Ptr Registry)
ibus_registry_new
Text -> Ptr Registry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"registryNew" Ptr Registry
result
Registry
result' <- ((ManagedPtr Registry -> Registry) -> Ptr Registry -> IO Registry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Registry -> Registry
Registry) Ptr Registry
result
Registry -> IO Registry
forall (m :: * -> *) a. Monad m => a -> m a
return Registry
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ibus_registry_check_modification" ibus_registry_check_modification ::
Ptr Registry ->
IO CInt
registryCheckModification ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m Bool
registryCheckModification :: a -> m Bool
registryCheckModification a
registry = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CInt
result <- Ptr Registry -> IO CInt
ibus_registry_check_modification Ptr Registry
registry'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryCheckModificationMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryCheckModificationMethodInfo a signature where
overloadedMethod = registryCheckModification
#endif
foreign import ccall "ibus_registry_get_components" ibus_registry_get_components ::
Ptr Registry ->
IO (Ptr (GList (Ptr IBus.Component.Component)))
registryGetComponents ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m [IBus.Component.Component]
registryGetComponents :: a -> m [Component]
registryGetComponents a
registry = IO [Component] -> m [Component]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Component] -> m [Component])
-> IO [Component] -> m [Component]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr (GList (Ptr Component))
result <- Ptr Registry -> IO (Ptr (GList (Ptr Component)))
ibus_registry_get_components Ptr Registry
registry'
[Ptr Component]
result' <- Ptr (GList (Ptr Component)) -> IO [Ptr Component]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Component))
result
[Component]
result'' <- (Ptr Component -> IO Component)
-> [Ptr Component] -> IO [Component]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Component -> Component)
-> Ptr Component -> IO Component
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Component -> Component
IBus.Component.Component) [Ptr Component]
result'
Ptr (GList (Ptr Component)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Component))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[Component] -> IO [Component]
forall (m :: * -> *) a. Monad m => a -> m a
return [Component]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryGetComponentsMethodInfo
instance (signature ~ (m [IBus.Component.Component]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetComponentsMethodInfo a signature where
overloadedMethod = registryGetComponents
#endif
foreign import ccall "ibus_registry_get_observed_paths" ibus_registry_get_observed_paths ::
Ptr Registry ->
IO (Ptr (GList (Ptr IBus.ObservedPath.ObservedPath)))
registryGetObservedPaths ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m [IBus.ObservedPath.ObservedPath]
registryGetObservedPaths :: a -> m [ObservedPath]
registryGetObservedPaths a
registry = IO [ObservedPath] -> m [ObservedPath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ObservedPath] -> m [ObservedPath])
-> IO [ObservedPath] -> m [ObservedPath]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr (GList (Ptr ObservedPath))
result <- Ptr Registry -> IO (Ptr (GList (Ptr ObservedPath)))
ibus_registry_get_observed_paths Ptr Registry
registry'
[Ptr ObservedPath]
result' <- Ptr (GList (Ptr ObservedPath)) -> IO [Ptr ObservedPath]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ObservedPath))
result
[ObservedPath]
result'' <- (Ptr ObservedPath -> IO ObservedPath)
-> [Ptr ObservedPath] -> IO [ObservedPath]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr ObservedPath -> ObservedPath)
-> Ptr ObservedPath -> IO ObservedPath
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ObservedPath -> ObservedPath
IBus.ObservedPath.ObservedPath) [Ptr ObservedPath]
result'
Ptr (GList (Ptr ObservedPath)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr ObservedPath))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[ObservedPath] -> IO [ObservedPath]
forall (m :: * -> *) a. Monad m => a -> m a
return [ObservedPath]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryGetObservedPathsMethodInfo
instance (signature ~ (m [IBus.ObservedPath.ObservedPath]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetObservedPathsMethodInfo a signature where
overloadedMethod = registryGetObservedPaths
#endif
foreign import ccall "ibus_registry_load" ibus_registry_load ::
Ptr Registry ->
IO ()
registryLoad ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m ()
registryLoad :: a -> m ()
registryLoad a
registry = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr Registry -> IO ()
ibus_registry_load Ptr Registry
registry'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryLoadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLoadMethodInfo a signature where
overloadedMethod = registryLoad
#endif
foreign import ccall "ibus_registry_load_cache" ibus_registry_load_cache ::
Ptr Registry ->
CInt ->
IO CInt
registryLoadCache ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> Bool
-> m Bool
registryLoadCache :: a -> Bool -> m Bool
registryLoadCache a
registry Bool
isUser = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
let isUser' :: CInt
isUser' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isUser
CInt
result <- Ptr Registry -> CInt -> IO CInt
ibus_registry_load_cache Ptr Registry
registry' CInt
isUser'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryLoadCacheMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLoadCacheMethodInfo a signature where
overloadedMethod = registryLoadCache
#endif
foreign import ccall "ibus_registry_load_cache_file" ibus_registry_load_cache_file ::
Ptr Registry ->
CString ->
IO CInt
registryLoadCacheFile ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m Bool
registryLoadCacheFile :: a -> Text -> m Bool
registryLoadCacheFile a
registry Text
filename = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
filename' <- Text -> IO CString
textToCString Text
filename
CInt
result <- Ptr Registry -> CString -> IO CInt
ibus_registry_load_cache_file Ptr Registry
registry' CString
filename'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryLoadCacheFileMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLoadCacheFileMethodInfo a signature where
overloadedMethod = registryLoadCacheFile
#endif
foreign import ccall "ibus_registry_load_in_dir" ibus_registry_load_in_dir ::
Ptr Registry ->
CString ->
IO ()
registryLoadInDir ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m ()
registryLoadInDir :: a -> Text -> m ()
registryLoadInDir a
registry Text
dirname = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
dirname' <- Text -> IO CString
textToCString Text
dirname
Ptr Registry -> CString -> IO ()
ibus_registry_load_in_dir Ptr Registry
registry' CString
dirname'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
dirname'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryLoadInDirMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLoadInDirMethodInfo a signature where
overloadedMethod = registryLoadInDir
#endif
foreign import ccall "ibus_registry_output" ibus_registry_output ::
Ptr Registry ->
Ptr GLib.String.String ->
Int32 ->
IO ()
registryOutput ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> GLib.String.String
-> Int32
-> m ()
registryOutput :: a -> String -> Int32 -> m ()
registryOutput a
registry String
output Int32
indent = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr String
output' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
output
Ptr Registry -> Ptr String -> Int32 -> IO ()
ibus_registry_output Ptr Registry
registry' Ptr String
output' Int32
indent
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
output
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryOutputMethodInfo
instance (signature ~ (GLib.String.String -> Int32 -> m ()), MonadIO m, IsRegistry a) => O.MethodInfo RegistryOutputMethodInfo a signature where
overloadedMethod = registryOutput
#endif
foreign import ccall "ibus_registry_save_cache" ibus_registry_save_cache ::
Ptr Registry ->
CInt ->
IO CInt
registrySaveCache ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> Bool
-> m Bool
registrySaveCache :: a -> Bool -> m Bool
registrySaveCache a
registry Bool
isUser = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
let isUser' :: CInt
isUser' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isUser
CInt
result <- Ptr Registry -> CInt -> IO CInt
ibus_registry_save_cache Ptr Registry
registry' CInt
isUser'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistrySaveCacheMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistrySaveCacheMethodInfo a signature where
overloadedMethod = registrySaveCache
#endif
foreign import ccall "ibus_registry_save_cache_file" ibus_registry_save_cache_file ::
Ptr Registry ->
CString ->
IO CInt
registrySaveCacheFile ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m Bool
registrySaveCacheFile :: a -> Text -> m Bool
registrySaveCacheFile a
registry Text
filename = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
filename' <- Text -> IO CString
textToCString Text
filename
CInt
result <- Ptr Registry -> CString -> IO CInt
ibus_registry_save_cache_file Ptr Registry
registry' CString
filename'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistrySaveCacheFileMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistrySaveCacheFileMethodInfo a signature where
overloadedMethod = registrySaveCacheFile
#endif
foreign import ccall "ibus_registry_start_monitor_changes" ibus_registry_start_monitor_changes ::
Ptr Registry ->
IO ()
registryStartMonitorChanges ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m ()
registryStartMonitorChanges :: a -> m ()
registryStartMonitorChanges a
registry = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr Registry -> IO ()
ibus_registry_start_monitor_changes Ptr Registry
registry'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryStartMonitorChangesMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRegistry a) => O.MethodInfo RegistryStartMonitorChangesMethodInfo a signature where
overloadedMethod = registryStartMonitorChanges
#endif