{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.IBus.Objects.UnicodeBlock
(
UnicodeBlock(..) ,
IsUnicodeBlock ,
toUnicodeBlock ,
#if defined(ENABLE_OVERLOADING)
ResolveUnicodeBlockMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UnicodeBlockGetEndMethodInfo ,
#endif
unicodeBlockGetEnd ,
#if defined(ENABLE_OVERLOADING)
UnicodeBlockGetNameMethodInfo ,
#endif
unicodeBlockGetName ,
#if defined(ENABLE_OVERLOADING)
UnicodeBlockGetStartMethodInfo ,
#endif
unicodeBlockGetStart ,
unicodeBlockLoad ,
unicodeBlockSave ,
#if defined(ENABLE_OVERLOADING)
UnicodeBlockEndPropertyInfo ,
#endif
constructUnicodeBlockEnd ,
getUnicodeBlockEnd ,
#if defined(ENABLE_OVERLOADING)
unicodeBlockEnd ,
#endif
#if defined(ENABLE_OVERLOADING)
UnicodeBlockNamePropertyInfo ,
#endif
clearUnicodeBlockName ,
constructUnicodeBlockName ,
getUnicodeBlockName ,
setUnicodeBlockName ,
#if defined(ENABLE_OVERLOADING)
unicodeBlockName ,
#endif
#if defined(ENABLE_OVERLOADING)
UnicodeBlockStartPropertyInfo ,
#endif
constructUnicodeBlockStart ,
getUnicodeBlockStart ,
#if defined(ENABLE_OVERLOADING)
unicodeBlockStart ,
#endif
) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.Object as IBus.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.Serializable as IBus.Serializable
newtype UnicodeBlock = UnicodeBlock (SP.ManagedPtr UnicodeBlock)
deriving (UnicodeBlock -> UnicodeBlock -> Bool
(UnicodeBlock -> UnicodeBlock -> Bool)
-> (UnicodeBlock -> UnicodeBlock -> Bool) -> Eq UnicodeBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnicodeBlock -> UnicodeBlock -> Bool
$c/= :: UnicodeBlock -> UnicodeBlock -> Bool
== :: UnicodeBlock -> UnicodeBlock -> Bool
$c== :: UnicodeBlock -> UnicodeBlock -> Bool
Eq)
instance SP.ManagedPtrNewtype UnicodeBlock where
toManagedPtr :: UnicodeBlock -> ManagedPtr UnicodeBlock
toManagedPtr (UnicodeBlock ManagedPtr UnicodeBlock
p) = ManagedPtr UnicodeBlock
p
foreign import ccall "ibus_unicode_block_get_type"
c_ibus_unicode_block_get_type :: IO B.Types.GType
instance B.Types.TypedObject UnicodeBlock where
glibType :: IO GType
glibType = IO GType
c_ibus_unicode_block_get_type
instance B.Types.GObject UnicodeBlock
class (SP.GObject o, O.IsDescendantOf UnicodeBlock o) => IsUnicodeBlock o
instance (SP.GObject o, O.IsDescendantOf UnicodeBlock o) => IsUnicodeBlock o
instance O.HasParentTypes UnicodeBlock
type instance O.ParentTypes UnicodeBlock = '[IBus.Serializable.Serializable, IBus.Object.Object, GObject.Object.Object]
toUnicodeBlock :: (MIO.MonadIO m, IsUnicodeBlock o) => o -> m UnicodeBlock
toUnicodeBlock :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeBlock o) =>
o -> m UnicodeBlock
toUnicodeBlock = IO UnicodeBlock -> m UnicodeBlock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO UnicodeBlock -> m UnicodeBlock)
-> (o -> IO UnicodeBlock) -> o -> m UnicodeBlock
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr UnicodeBlock -> UnicodeBlock) -> o -> IO UnicodeBlock
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr UnicodeBlock -> UnicodeBlock
UnicodeBlock
instance B.GValue.IsGValue (Maybe UnicodeBlock) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_unicode_block_get_type
gvalueSet_ :: Ptr GValue -> Maybe UnicodeBlock -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UnicodeBlock
P.Nothing = Ptr GValue -> Ptr UnicodeBlock -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr UnicodeBlock
forall a. Ptr a
FP.nullPtr :: FP.Ptr UnicodeBlock)
gvalueSet_ Ptr GValue
gv (P.Just UnicodeBlock
obj) = UnicodeBlock -> (Ptr UnicodeBlock -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnicodeBlock
obj (Ptr GValue -> Ptr UnicodeBlock -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe UnicodeBlock)
gvalueGet_ Ptr GValue
gv = do
Ptr UnicodeBlock
ptr <- Ptr GValue -> IO (Ptr UnicodeBlock)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UnicodeBlock)
if Ptr UnicodeBlock
ptr Ptr UnicodeBlock -> Ptr UnicodeBlock -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr UnicodeBlock
forall a. Ptr a
FP.nullPtr
then UnicodeBlock -> Maybe UnicodeBlock
forall a. a -> Maybe a
P.Just (UnicodeBlock -> Maybe UnicodeBlock)
-> IO UnicodeBlock -> IO (Maybe UnicodeBlock)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr UnicodeBlock -> UnicodeBlock)
-> Ptr UnicodeBlock -> IO UnicodeBlock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UnicodeBlock -> UnicodeBlock
UnicodeBlock Ptr UnicodeBlock
ptr
else Maybe UnicodeBlock -> IO (Maybe UnicodeBlock)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UnicodeBlock
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveUnicodeBlockMethod (t :: Symbol) (o :: *) :: * where
ResolveUnicodeBlockMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveUnicodeBlockMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveUnicodeBlockMethod "copy" o = IBus.Serializable.SerializableCopyMethodInfo
ResolveUnicodeBlockMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
ResolveUnicodeBlockMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveUnicodeBlockMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveUnicodeBlockMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveUnicodeBlockMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveUnicodeBlockMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveUnicodeBlockMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveUnicodeBlockMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveUnicodeBlockMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveUnicodeBlockMethod "removeQattachment" o = IBus.Serializable.SerializableRemoveQattachmentMethodInfo
ResolveUnicodeBlockMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveUnicodeBlockMethod "serializeObject" o = IBus.Serializable.SerializableSerializeObjectMethodInfo
ResolveUnicodeBlockMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveUnicodeBlockMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveUnicodeBlockMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveUnicodeBlockMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveUnicodeBlockMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveUnicodeBlockMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveUnicodeBlockMethod "getEnd" o = UnicodeBlockGetEndMethodInfo
ResolveUnicodeBlockMethod "getName" o = UnicodeBlockGetNameMethodInfo
ResolveUnicodeBlockMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveUnicodeBlockMethod "getQattachment" o = IBus.Serializable.SerializableGetQattachmentMethodInfo
ResolveUnicodeBlockMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveUnicodeBlockMethod "getStart" o = UnicodeBlockGetStartMethodInfo
ResolveUnicodeBlockMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveUnicodeBlockMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveUnicodeBlockMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveUnicodeBlockMethod "setQattachment" o = IBus.Serializable.SerializableSetQattachmentMethodInfo
ResolveUnicodeBlockMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUnicodeBlockMethod t UnicodeBlock, O.OverloadedMethod info UnicodeBlock p) => OL.IsLabel t (UnicodeBlock -> 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 ~ ResolveUnicodeBlockMethod t UnicodeBlock, O.OverloadedMethod info UnicodeBlock p, R.HasField t UnicodeBlock p) => R.HasField t UnicodeBlock p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveUnicodeBlockMethod t UnicodeBlock, O.OverloadedMethodInfo info UnicodeBlock) => OL.IsLabel t (O.MethodProxy info UnicodeBlock) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getUnicodeBlockEnd :: (MonadIO m, IsUnicodeBlock o) => o -> m Word32
getUnicodeBlockEnd :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeBlock o) =>
o -> m Word32
getUnicodeBlockEnd o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"end"
constructUnicodeBlockEnd :: (IsUnicodeBlock o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructUnicodeBlockEnd :: forall o (m :: * -> *).
(IsUnicodeBlock o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructUnicodeBlockEnd Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"end" Word32
val
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockEndPropertyInfo
instance AttrInfo UnicodeBlockEndPropertyInfo where
type AttrAllowedOps UnicodeBlockEndPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint UnicodeBlockEndPropertyInfo = IsUnicodeBlock
type AttrSetTypeConstraint UnicodeBlockEndPropertyInfo = (~) Word32
type AttrTransferTypeConstraint UnicodeBlockEndPropertyInfo = (~) Word32
type AttrTransferType UnicodeBlockEndPropertyInfo = Word32
type AttrGetType UnicodeBlockEndPropertyInfo = Word32
type AttrLabel UnicodeBlockEndPropertyInfo = "end"
type AttrOrigin UnicodeBlockEndPropertyInfo = UnicodeBlock
attrGet = getUnicodeBlockEnd
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructUnicodeBlockEnd
attrClear = undefined
#endif
getUnicodeBlockName :: (MonadIO m, IsUnicodeBlock o) => o -> m T.Text
getUnicodeBlockName :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeBlock o) =>
o -> m Text
getUnicodeBlockName o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getUnicodeBlockName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"name"
setUnicodeBlockName :: (MonadIO m, IsUnicodeBlock o) => o -> T.Text -> m ()
setUnicodeBlockName :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeBlock o) =>
o -> Text -> m ()
setUnicodeBlockName o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructUnicodeBlockName :: (IsUnicodeBlock o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructUnicodeBlockName :: forall o (m :: * -> *).
(IsUnicodeBlock o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructUnicodeBlockName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
clearUnicodeBlockName :: (MonadIO m, IsUnicodeBlock o) => o -> m ()
clearUnicodeBlockName :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeBlock o) => o -> m ()
clearUnicodeBlockName o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockNamePropertyInfo
instance AttrInfo UnicodeBlockNamePropertyInfo where
type AttrAllowedOps UnicodeBlockNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint UnicodeBlockNamePropertyInfo = IsUnicodeBlock
type AttrSetTypeConstraint UnicodeBlockNamePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint UnicodeBlockNamePropertyInfo = (~) T.Text
type AttrTransferType UnicodeBlockNamePropertyInfo = T.Text
type AttrGetType UnicodeBlockNamePropertyInfo = T.Text
type AttrLabel UnicodeBlockNamePropertyInfo = "name"
type AttrOrigin UnicodeBlockNamePropertyInfo = UnicodeBlock
attrGet = getUnicodeBlockName
attrSet = setUnicodeBlockName
attrTransfer _ v = do
return v
attrConstruct = constructUnicodeBlockName
attrClear = clearUnicodeBlockName
#endif
getUnicodeBlockStart :: (MonadIO m, IsUnicodeBlock o) => o -> m Word32
getUnicodeBlockStart :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeBlock o) =>
o -> m Word32
getUnicodeBlockStart o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"start"
constructUnicodeBlockStart :: (IsUnicodeBlock o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructUnicodeBlockStart :: forall o (m :: * -> *).
(IsUnicodeBlock o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructUnicodeBlockStart Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"start" Word32
val
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockStartPropertyInfo
instance AttrInfo UnicodeBlockStartPropertyInfo where
type AttrAllowedOps UnicodeBlockStartPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint UnicodeBlockStartPropertyInfo = IsUnicodeBlock
type AttrSetTypeConstraint UnicodeBlockStartPropertyInfo = (~) Word32
type AttrTransferTypeConstraint UnicodeBlockStartPropertyInfo = (~) Word32
type AttrTransferType UnicodeBlockStartPropertyInfo = Word32
type AttrGetType UnicodeBlockStartPropertyInfo = Word32
type AttrLabel UnicodeBlockStartPropertyInfo = "start"
type AttrOrigin UnicodeBlockStartPropertyInfo = UnicodeBlock
attrGet = getUnicodeBlockStart
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructUnicodeBlockStart
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UnicodeBlock
type instance O.AttributeList UnicodeBlock = UnicodeBlockAttributeList
type UnicodeBlockAttributeList = ('[ '("end", UnicodeBlockEndPropertyInfo), '("name", UnicodeBlockNamePropertyInfo), '("start", UnicodeBlockStartPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
unicodeBlockEnd :: AttrLabelProxy "end"
unicodeBlockEnd = AttrLabelProxy
unicodeBlockName :: AttrLabelProxy "name"
unicodeBlockName = AttrLabelProxy
unicodeBlockStart :: AttrLabelProxy "start"
unicodeBlockStart = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UnicodeBlock = UnicodeBlockSignalList
type UnicodeBlockSignalList = ('[ '("destroy", IBus.Object.ObjectDestroySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ibus_unicode_block_get_end" ibus_unicode_block_get_end ::
Ptr UnicodeBlock ->
IO CInt
unicodeBlockGetEnd ::
(B.CallStack.HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a
-> m Char
unicodeBlockGetEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a -> m Char
unicodeBlockGetEnd a
block = 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
Ptr UnicodeBlock
block' <- a -> IO (Ptr UnicodeBlock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
block
CInt
result <- Ptr UnicodeBlock -> IO CInt
ibus_unicode_block_get_end Ptr UnicodeBlock
block'
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
block
Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockGetEndMethodInfo
instance (signature ~ (m Char), MonadIO m, IsUnicodeBlock a) => O.OverloadedMethod UnicodeBlockGetEndMethodInfo a signature where
overloadedMethod = unicodeBlockGetEnd
instance O.OverloadedMethodInfo UnicodeBlockGetEndMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.UnicodeBlock.unicodeBlockGetEnd",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-UnicodeBlock.html#v:unicodeBlockGetEnd"
}
#endif
foreign import ccall "ibus_unicode_block_get_name" ibus_unicode_block_get_name ::
Ptr UnicodeBlock ->
IO CString
unicodeBlockGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a
-> m T.Text
unicodeBlockGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a -> m Text
unicodeBlockGetName a
block = 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
Ptr UnicodeBlock
block' <- a -> IO (Ptr UnicodeBlock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
block
CString
result <- Ptr UnicodeBlock -> IO CString
ibus_unicode_block_get_name Ptr UnicodeBlock
block'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unicodeBlockGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
block
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsUnicodeBlock a) => O.OverloadedMethod UnicodeBlockGetNameMethodInfo a signature where
overloadedMethod = unicodeBlockGetName
instance O.OverloadedMethodInfo UnicodeBlockGetNameMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.UnicodeBlock.unicodeBlockGetName",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-UnicodeBlock.html#v:unicodeBlockGetName"
}
#endif
foreign import ccall "ibus_unicode_block_get_start" ibus_unicode_block_get_start ::
Ptr UnicodeBlock ->
IO CInt
unicodeBlockGetStart ::
(B.CallStack.HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a
-> m Char
unicodeBlockGetStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeBlock a) =>
a -> m Char
unicodeBlockGetStart a
block = 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
Ptr UnicodeBlock
block' <- a -> IO (Ptr UnicodeBlock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
block
CInt
result <- Ptr UnicodeBlock -> IO CInt
ibus_unicode_block_get_start Ptr UnicodeBlock
block'
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
block
Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'
#if defined(ENABLE_OVERLOADING)
data UnicodeBlockGetStartMethodInfo
instance (signature ~ (m Char), MonadIO m, IsUnicodeBlock a) => O.OverloadedMethod UnicodeBlockGetStartMethodInfo a signature where
overloadedMethod = unicodeBlockGetStart
instance O.OverloadedMethodInfo UnicodeBlockGetStartMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.UnicodeBlock.unicodeBlockGetStart",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-UnicodeBlock.html#v:unicodeBlockGetStart"
}
#endif
foreign import ccall "ibus_unicode_block_load" ibus_unicode_block_load ::
CString ->
IO (Ptr (GSList (Ptr UnicodeBlock)))
unicodeBlockLoad ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m [UnicodeBlock]
unicodeBlockLoad :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m [UnicodeBlock]
unicodeBlockLoad Text
path = IO [UnicodeBlock] -> m [UnicodeBlock]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [UnicodeBlock] -> m [UnicodeBlock])
-> IO [UnicodeBlock] -> m [UnicodeBlock]
forall a b. (a -> b) -> a -> b
$ do
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr (GSList (Ptr UnicodeBlock))
result <- CString -> IO (Ptr (GSList (Ptr UnicodeBlock)))
ibus_unicode_block_load CString
path'
[Ptr UnicodeBlock]
result' <- Ptr (GSList (Ptr UnicodeBlock)) -> IO [Ptr UnicodeBlock]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr UnicodeBlock))
result
[UnicodeBlock]
result'' <- (Ptr UnicodeBlock -> IO UnicodeBlock)
-> [Ptr UnicodeBlock] -> IO [UnicodeBlock]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr UnicodeBlock -> UnicodeBlock)
-> Ptr UnicodeBlock -> IO UnicodeBlock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnicodeBlock -> UnicodeBlock
UnicodeBlock) [Ptr UnicodeBlock]
result'
Ptr (GSList (Ptr UnicodeBlock)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr UnicodeBlock))
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
[UnicodeBlock] -> IO [UnicodeBlock]
forall (m :: * -> *) a. Monad m => a -> m a
return [UnicodeBlock]
result''
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ibus_unicode_block_save" ibus_unicode_block_save ::
CString ->
Ptr (GSList (Ptr UnicodeBlock)) ->
IO ()
unicodeBlockSave ::
(B.CallStack.HasCallStack, MonadIO m, IsUnicodeBlock a) =>
T.Text
-> [a]
-> m ()
unicodeBlockSave :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeBlock a) =>
Text -> [a] -> m ()
unicodeBlockSave Text
path [a]
list = 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
[Ptr UnicodeBlock]
list' <- (a -> IO (Ptr UnicodeBlock)) -> [a] -> IO [Ptr UnicodeBlock]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> IO (Ptr UnicodeBlock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [a]
list
Ptr (GSList (Ptr UnicodeBlock))
list'' <- [Ptr UnicodeBlock] -> IO (Ptr (GSList (Ptr UnicodeBlock)))
forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr UnicodeBlock]
list'
CString -> Ptr (GSList (Ptr UnicodeBlock)) -> IO ()
ibus_unicode_block_save CString
path' Ptr (GSList (Ptr UnicodeBlock))
list''
(a -> IO ()) -> [a] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [a]
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Ptr (GSList (Ptr UnicodeBlock)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr UnicodeBlock))
list''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif