#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.IBus.Functions
(
acceleratorName ,
acceleratorParse ,
acceleratorValid ,
attrBackgroundNew ,
attrForegroundNew ,
emojiDictLoad ,
emojiDictSave ,
freeStrv ,
getAddress ,
getDaemonUid ,
getLanguageName ,
getLocalMachineId ,
getSocketPath ,
getTimeout ,
getUntranslatedLanguageName ,
getUserName ,
init ,
keyEventFromString ,
keyEventToString ,
keyvalConvertCase ,
keyvalFromName ,
keyvalName ,
keyvalToLower ,
keyvalToUnicode ,
keyvalToUpper ,
main ,
quit ,
setDisplay ,
setLogHandler ,
unicodeToKeyval ,
unsetLogHandler ,
writeAddress ,
) 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 {-# SOURCE #-} qualified GI.IBus.Flags as IBus.Flags
import {-# SOURCE #-} qualified GI.IBus.Objects.Attribute as IBus.Attribute
foreign import ccall "ibus_write_address" ibus_write_address ::
CString ->
IO ()
writeAddress ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
writeAddress :: Text -> m ()
writeAddress Text
address = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
address' <- Text -> IO CString
textToCString Text
address
CString -> IO ()
ibus_write_address CString
address'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
address'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_unset_log_handler" ibus_unset_log_handler ::
IO ()
unsetLogHandler ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
unsetLogHandler :: m ()
unsetLogHandler = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
ibus_unset_log_handler
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_unicode_to_keyval" ibus_unicode_to_keyval ::
CInt ->
IO Word32
unicodeToKeyval ::
(B.CallStack.HasCallStack, MonadIO m) =>
Char
-> m Word32
unicodeToKeyval :: Char -> m Word32
unicodeToKeyval Char
wc = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
let wc' :: CInt
wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) Char
wc
Word32
result <- CInt -> IO Word32
ibus_unicode_to_keyval CInt
wc'
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ibus_set_log_handler" ibus_set_log_handler ::
CInt ->
IO ()
setLogHandler ::
(B.CallStack.HasCallStack, MonadIO m) =>
Bool
-> m ()
setLogHandler :: Bool -> m ()
setLogHandler Bool
verbose = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let verbose' :: CInt
verbose' = (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
verbose
CInt -> IO ()
ibus_set_log_handler CInt
verbose'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_set_display" ibus_set_display ::
CString ->
IO ()
setDisplay ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
setDisplay :: Text -> m ()
setDisplay Text
display = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
display' <- Text -> IO CString
textToCString Text
display
CString -> IO ()
ibus_set_display CString
display'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
display'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_quit" ibus_quit ::
IO ()
quit ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
quit :: m ()
quit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
ibus_quit
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_main" ibus_main ::
IO ()
main ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
main :: m ()
main = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
ibus_main
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_keyval_to_upper" ibus_keyval_to_upper ::
Word32 ->
IO Word32
keyvalToUpper ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
keyvalToUpper :: Word32 -> m Word32
keyvalToUpper Word32
keyval = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
ibus_keyval_to_upper Word32
keyval
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ibus_keyval_to_unicode" ibus_keyval_to_unicode ::
Word32 ->
IO CInt
keyvalToUnicode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Char
keyvalToUnicode :: Word32 -> m Char
keyvalToUnicode Word32
keyval = IO Char -> m Char
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ do
CInt
result <- Word32 -> IO CInt
ibus_keyval_to_unicode Word32
keyval
let result' :: Char
result' = (Int -> Char
chr (Int -> Char) -> (CInt -> Int) -> CInt -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'
foreign import ccall "ibus_keyval_to_lower" ibus_keyval_to_lower ::
Word32 ->
IO Word32
keyvalToLower ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Word32
keyvalToLower :: Word32 -> m Word32
keyvalToLower Word32
keyval = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- Word32 -> IO Word32
ibus_keyval_to_lower Word32
keyval
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ibus_keyval_name" ibus_keyval_name ::
Word32 ->
IO CString
keyvalName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m T.Text
keyvalName :: Word32 -> m Text
keyvalName Word32
keyval = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- Word32 -> IO CString
ibus_keyval_name Word32
keyval
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keyvalName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_keyval_from_name" ibus_keyval_from_name ::
CString ->
IO Word32
keyvalFromName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Word32
keyvalFromName :: Text -> m Word32
keyvalFromName Text
keyvalName = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
CString
keyvalName' <- Text -> IO CString
textToCString Text
keyvalName
Word32
result <- CString -> IO Word32
ibus_keyval_from_name CString
keyvalName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
keyvalName'
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "ibus_keyval_convert_case" ibus_keyval_convert_case ::
Word32 ->
Ptr Word32 ->
Ptr Word32 ->
IO ()
keyvalConvertCase ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m ((Word32, Word32))
keyvalConvertCase :: Word32 -> m (Word32, Word32)
keyvalConvertCase Word32
symbol = IO (Word32, Word32) -> m (Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, Word32) -> m (Word32, Word32))
-> IO (Word32, Word32) -> m (Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Word32
lower <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
upper <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Word32 -> Ptr Word32 -> Ptr Word32 -> IO ()
ibus_keyval_convert_case Word32
symbol Ptr Word32
lower Ptr Word32
upper
Word32
lower' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
lower
Word32
upper' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
upper
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
lower
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
upper
(Word32, Word32) -> IO (Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
lower', Word32
upper')
foreign import ccall "ibus_key_event_to_string" ibus_key_event_to_string ::
Word32 ->
Word32 ->
IO CString
keyEventToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Word32
-> m T.Text
keyEventToString :: Word32 -> Word32 -> m Text
keyEventToString Word32
keyval Word32
modifiers = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- Word32 -> Word32 -> IO CString
ibus_key_event_to_string Word32
keyval Word32
modifiers
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keyEventToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_key_event_from_string" ibus_key_event_from_string ::
CString ->
Word32 ->
Word32 ->
IO CInt
keyEventFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Word32
-> Word32
-> m Bool
keyEventFromString :: Text -> Word32 -> Word32 -> m Bool
keyEventFromString Text
string Word32
keyval Word32
modifiers = 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
CString
string' <- Text -> IO CString
textToCString Text
string
CInt
result <- CString -> Word32 -> Word32 -> IO CInt
ibus_key_event_from_string CString
string' Word32
keyval Word32
modifiers
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
string'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "ibus_init" ibus_init ::
IO ()
init ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
init :: m ()
init = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
ibus_init
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_get_user_name" ibus_get_user_name ::
IO CString
getUserName ::
(B.CallStack.HasCallStack, MonadIO m) =>
m T.Text
getUserName :: m Text
getUserName = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- IO CString
ibus_get_user_name
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getUserName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_get_untranslated_language_name" ibus_get_untranslated_language_name ::
CString ->
IO CString
getUntranslatedLanguageName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m T.Text
getUntranslatedLanguageName :: Text -> m Text
getUntranslatedLanguageName Text
_locale = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
_locale' <- Text -> IO CString
textToCString Text
_locale
CString
result <- CString -> IO CString
ibus_get_untranslated_language_name CString
_locale'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getUntranslatedLanguageName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
_locale'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_get_timeout" ibus_get_timeout ::
IO Int32
getTimeout ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int32
getTimeout :: m Int32
getTimeout = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Int32
result <- IO Int32
ibus_get_timeout
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "ibus_get_socket_path" ibus_get_socket_path ::
IO CString
getSocketPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
m T.Text
getSocketPath :: m Text
getSocketPath = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- IO CString
ibus_get_socket_path
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getSocketPath" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_get_local_machine_id" ibus_get_local_machine_id ::
IO CString
getLocalMachineId ::
(B.CallStack.HasCallStack, MonadIO m) =>
m T.Text
getLocalMachineId :: m Text
getLocalMachineId = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- IO CString
ibus_get_local_machine_id
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getLocalMachineId" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_get_language_name" ibus_get_language_name ::
CString ->
IO CString
getLanguageName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m T.Text
getLanguageName :: Text -> m Text
getLanguageName Text
_locale = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
_locale' <- Text -> IO CString
textToCString Text
_locale
CString
result <- CString -> IO CString
ibus_get_language_name CString
_locale'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getLanguageName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
_locale'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_get_daemon_uid" ibus_get_daemon_uid ::
IO CLong
{-# DEPRECATED getDaemonUid ["This function has been deprecated and should","not be used in newly written code."] #-}
getDaemonUid ::
(B.CallStack.HasCallStack, MonadIO m) =>
m CLong
getDaemonUid :: m CLong
getDaemonUid = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ do
CLong
result <- IO CLong
ibus_get_daemon_uid
CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
result
foreign import ccall "ibus_get_address" ibus_get_address ::
IO CString
getAddress ::
(B.CallStack.HasCallStack, MonadIO m) =>
m T.Text
getAddress :: m Text
getAddress = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
CString
result <- IO CString
ibus_get_address
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"getAddress" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "ibus_free_strv" ibus_free_strv ::
CString ->
IO ()
{-# DEPRECATED freeStrv ["This function has been deprecated and should","not be used in newly written code."] #-}
freeStrv ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ()
freeStrv :: Text -> m ()
freeStrv Text
strv = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
strv' <- Text -> IO CString
textToCString Text
strv
CString -> IO ()
ibus_free_strv CString
strv'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
strv'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_emoji_dict_save" ibus_emoji_dict_save ::
CString ->
Ptr (GHashTable CString (Ptr ())) ->
IO ()
emojiDictSave ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Map.Map T.Text (Ptr ())
-> m ()
emojiDictSave :: Text -> Map Text (Ptr ()) -> m ()
emojiDictSave Text
path Map Text (Ptr ())
dict = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
let dict' :: [(Text, Ptr ())]
dict' = Map Text (Ptr ()) -> [(Text, Ptr ())]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text (Ptr ())
dict
[(CString, Ptr ())]
dict'' <- (Text -> IO CString) -> [(Text, Ptr ())] -> IO [(CString, Ptr ())]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Ptr ())]
dict'
let dict''' :: [(PtrWrapped CString, Ptr ())]
dict''' = (CString -> PtrWrapped CString)
-> [(CString, Ptr ())] -> [(PtrWrapped CString, Ptr ())]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, Ptr ())]
dict''
let dict'''' :: [(PtrWrapped CString, PtrWrapped (Ptr ()))]
dict'''' = (Ptr () -> PtrWrapped (Ptr ()))
-> [(PtrWrapped CString, Ptr ())]
-> [(PtrWrapped CString, PtrWrapped (Ptr ()))]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond Ptr () -> PtrWrapped (Ptr ())
forall a. Ptr a -> PtrWrapped (Ptr a)
ptrPackPtr [(PtrWrapped CString, Ptr ())]
dict'''
Ptr (GHashTable CString (Ptr ()))
dict''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify (Ptr ()))
-> [(PtrWrapped CString, PtrWrapped (Ptr ()))]
-> IO (Ptr (GHashTable CString (Ptr ())))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) Maybe (GDestroyNotify (Ptr ()))
forall a. Maybe a
Nothing [(PtrWrapped CString, PtrWrapped (Ptr ()))]
dict''''
CString -> Ptr (GHashTable CString (Ptr ())) -> IO ()
ibus_emoji_dict_save CString
path' Ptr (GHashTable CString (Ptr ()))
dict'''''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Ptr (GHashTable CString (Ptr ())) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString (Ptr ()))
dict'''''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "ibus_emoji_dict_load" ibus_emoji_dict_load ::
CString ->
IO (Ptr (GHashTable CString (Ptr ())))
emojiDictLoad ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Map.Map T.Text (Ptr ()))
emojiDictLoad :: Text -> m (Map Text (Ptr ()))
emojiDictLoad Text
path = IO (Map Text (Ptr ())) -> m (Map Text (Ptr ()))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Map Text (Ptr ())) -> m (Map Text (Ptr ())))
-> IO (Map Text (Ptr ())) -> m (Map Text (Ptr ()))
forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr (GHashTable CString (Ptr ()))
result <- CString -> IO (Ptr (GHashTable CString (Ptr ())))
ibus_emoji_dict_load CString
path'
Text -> Ptr (GHashTable CString (Ptr ())) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"emojiDictLoad" Ptr (GHashTable CString (Ptr ()))
result
[(PtrWrapped CString, PtrWrapped (Ptr ()))]
result' <- Ptr (GHashTable CString (Ptr ()))
-> IO [(PtrWrapped CString, PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString (Ptr ()))
result
let result'' :: [(CString, PtrWrapped (Ptr ()))]
result'' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped (Ptr ()))]
-> [(CString, PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped (Ptr ()))]
result'
[(Text, PtrWrapped (Ptr ()))]
result''' <- (CString -> IO Text)
-> [(CString, PtrWrapped (Ptr ()))]
-> IO [(Text, PtrWrapped (Ptr ()))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped (Ptr ()))]
result''
let result'''' :: [(Text, Ptr ())]
result'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Text, PtrWrapped (Ptr ()))] -> [(Text, Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(Text, PtrWrapped (Ptr ()))]
result'''
let result''''' :: Map Text (Ptr ())
result''''' = [(Text, Ptr ())] -> Map Text (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Ptr ())]
result''''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Map Text (Ptr ()) -> IO (Map Text (Ptr ()))
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text (Ptr ())
result'''''
foreign import ccall "ibus_attr_foreground_new" ibus_attr_foreground_new ::
Word32 ->
Word32 ->
Word32 ->
IO (Ptr IBus.Attribute.Attribute)
attrForegroundNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Word32
-> Word32
-> m IBus.Attribute.Attribute
attrForegroundNew :: Word32 -> Word32 -> Word32 -> m Attribute
attrForegroundNew Word32
color Word32
startIndex Word32
endIndex = IO Attribute -> m Attribute
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
result <- Word32 -> Word32 -> Word32 -> IO (Ptr Attribute)
ibus_attr_foreground_new Word32
color Word32
startIndex Word32
endIndex
Text -> Ptr Attribute -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"attrForegroundNew" Ptr Attribute
result
Attribute
result' <- ((ManagedPtr Attribute -> Attribute)
-> Ptr Attribute -> IO Attribute
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Attribute -> Attribute
IBus.Attribute.Attribute) Ptr Attribute
result
Attribute -> IO Attribute
forall (m :: * -> *) a. Monad m => a -> m a
return Attribute
result'
foreign import ccall "ibus_attr_background_new" ibus_attr_background_new ::
Word32 ->
Word32 ->
Word32 ->
IO (Ptr IBus.Attribute.Attribute)
attrBackgroundNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Word32
-> Word32
-> m IBus.Attribute.Attribute
attrBackgroundNew :: Word32 -> Word32 -> Word32 -> m Attribute
attrBackgroundNew Word32
color Word32
startIndex Word32
endIndex = IO Attribute -> m Attribute
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
result <- Word32 -> Word32 -> Word32 -> IO (Ptr Attribute)
ibus_attr_background_new Word32
color Word32
startIndex Word32
endIndex
Text -> Ptr Attribute -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"attrBackgroundNew" Ptr Attribute
result
Attribute
result' <- ((ManagedPtr Attribute -> Attribute)
-> Ptr Attribute -> IO Attribute
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Attribute -> Attribute
IBus.Attribute.Attribute) Ptr Attribute
result
Attribute -> IO Attribute
forall (m :: * -> *) a. Monad m => a -> m a
return Attribute
result'
foreign import ccall "ibus_accelerator_valid" ibus_accelerator_valid ::
Word32 ->
CUInt ->
IO CInt
acceleratorValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> [IBus.Flags.ModifierType]
-> m Bool
acceleratorValid :: Word32 -> [ModifierType] -> m Bool
acceleratorValid Word32
keyval [ModifierType]
modifiers = 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
let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
CInt
result <- Word32 -> CUInt -> IO CInt
ibus_accelerator_valid Word32
keyval CUInt
modifiers'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "ibus_accelerator_parse" ibus_accelerator_parse ::
CString ->
Ptr Word32 ->
Ptr CUInt ->
IO ()
acceleratorParse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Word32, [IBus.Flags.ModifierType]))
acceleratorParse :: Text -> m (Word32, [ModifierType])
acceleratorParse Text
accelerator = IO (Word32, [ModifierType]) -> m (Word32, [ModifierType])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, [ModifierType]) -> m (Word32, [ModifierType]))
-> IO (Word32, [ModifierType]) -> m (Word32, [ModifierType])
forall a b. (a -> b) -> a -> b
$ do
CString
accelerator' <- Text -> IO CString
textToCString Text
accelerator
Ptr Word32
acceleratorKey <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr CUInt
acceleratorMods <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CString -> Ptr Word32 -> Ptr CUInt -> IO ()
ibus_accelerator_parse CString
accelerator' Ptr Word32
acceleratorKey Ptr CUInt
acceleratorMods
Word32
acceleratorKey' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
acceleratorKey
CUInt
acceleratorMods' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
acceleratorMods
let acceleratorMods'' :: [ModifierType]
acceleratorMods'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
acceleratorMods'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
accelerator'
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
acceleratorKey
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
acceleratorMods
(Word32, [ModifierType]) -> IO (Word32, [ModifierType])
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
acceleratorKey', [ModifierType]
acceleratorMods'')
foreign import ccall "ibus_accelerator_name" ibus_accelerator_name ::
Word32 ->
CUInt ->
IO CString
acceleratorName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> [IBus.Flags.ModifierType]
-> m T.Text
acceleratorName :: Word32 -> [ModifierType] -> m Text
acceleratorName Word32
acceleratorKey [ModifierType]
acceleratorMods = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let acceleratorMods' :: CUInt
acceleratorMods' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
acceleratorMods
CString
result <- Word32 -> CUInt -> IO CString
ibus_accelerator_name Word32
acceleratorKey CUInt
acceleratorMods'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"acceleratorName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'