{-# 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.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.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 GHC.Records as R
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 (SP.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)
instance SP.ManagedPtrNewtype Registry where
toManagedPtr :: Registry -> ManagedPtr Registry
toManagedPtr (Registry ManagedPtr Registry
p) = ManagedPtr Registry
p
foreign import ccall "ibus_registry_get_type"
c_ibus_registry_get_type :: IO B.Types.GType
instance B.Types.TypedObject Registry where
glibType :: IO GType
glibType = IO GType
c_ibus_registry_get_type
instance B.Types.GObject Registry
class (SP.GObject o, O.IsDescendantOf Registry o) => IsRegistry o
instance (SP.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 :: (MIO.MonadIO m, IsRegistry o) => o -> m Registry
toRegistry :: forall (m :: * -> *) o.
(MonadIO m, IsRegistry o) =>
o -> m Registry
toRegistry = IO Registry -> m Registry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Registry -> Registry
Registry
instance B.GValue.IsGValue (Maybe Registry) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_registry_get_type
gvalueSet_ :: Ptr GValue -> Maybe Registry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Registry
P.Nothing = Ptr GValue -> Ptr Registry -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Registry
forall a. Ptr a
FP.nullPtr :: FP.Ptr Registry)
gvalueSet_ Ptr GValue
gv (P.Just Registry
obj) = Registry -> (Ptr Registry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Registry
obj (Ptr GValue -> Ptr Registry -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Registry)
gvalueGet_ Ptr GValue
gv = do
Ptr Registry
ptr <- Ptr GValue -> IO (Ptr Registry)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Registry)
if Ptr Registry
ptr Ptr Registry -> Ptr Registry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Registry
forall a. Ptr a
FP.nullPtr
then Registry -> Maybe Registry
forall a. a -> Maybe a
P.Just (Registry -> Maybe Registry) -> IO Registry -> IO (Maybe Registry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
else Maybe Registry -> IO (Maybe Registry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Registry
forall a. Maybe a
P.Nothing
#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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRegistryMethod t Registry, O.OverloadedMethod info Registry p, R.HasField t Registry p) => R.HasField t Registry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRegistryMethod t Registry, O.OverloadedMethodInfo info Registry) => OL.IsLabel t (O.MethodProxy info Registry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *).
MonadIO m =>
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 :: forall a (m :: * -> *).
(IsRegistry a, MonadIO m) =>
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 :: forall a (m :: * -> *).
(IsRegistry a, MonadIO m) =>
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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryCheckModificationMethodInfo a signature where
overloadedMethod = registryCheckModification
instance O.OverloadedMethodInfo RegistryCheckModificationMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryCheckModification",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryGetComponentsMethodInfo a signature where
overloadedMethod = registryGetComponents
instance O.OverloadedMethodInfo RegistryGetComponentsMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryGetComponents",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryGetObservedPathsMethodInfo a signature where
overloadedMethod = registryGetObservedPaths
instance O.OverloadedMethodInfo RegistryGetObservedPathsMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryGetObservedPaths",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryLoadMethodInfo a signature where
overloadedMethod = registryLoad
instance O.OverloadedMethodInfo RegistryLoadMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryLoad",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryLoadCacheMethodInfo a signature where
overloadedMethod = registryLoadCache
instance O.OverloadedMethodInfo RegistryLoadCacheMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryLoadCache",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryLoadCacheFileMethodInfo a signature where
overloadedMethod = registryLoadCacheFile
instance O.OverloadedMethodInfo RegistryLoadCacheFileMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryLoadCacheFile",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryLoadInDirMethodInfo a signature where
overloadedMethod = registryLoadInDir
instance O.OverloadedMethodInfo RegistryLoadInDirMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryLoadInDir",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryOutputMethodInfo a signature where
overloadedMethod = registryOutput
instance O.OverloadedMethodInfo RegistryOutputMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryOutput",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistrySaveCacheMethodInfo a signature where
overloadedMethod = registrySaveCache
instance O.OverloadedMethodInfo RegistrySaveCacheMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registrySaveCache",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistrySaveCacheFileMethodInfo a signature where
overloadedMethod = registrySaveCacheFile
instance O.OverloadedMethodInfo RegistrySaveCacheFileMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registrySaveCacheFile",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRegistry a) =>
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.OverloadedMethod RegistryStartMonitorChangesMethodInfo a signature where
overloadedMethod = registryStartMonitorChanges
instance O.OverloadedMethodInfo RegistryStartMonitorChangesMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Registry.registryStartMonitorChanges",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Registry.html#v:registryStartMonitorChanges"
}
#endif