{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Unicode data likes code, name, alias, block-name.
-- You can get extended values with g_object_get_properties.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.IBus.Objects.UnicodeData
    ( 
#if defined(ENABLE_OVERLOADING)
    UnicodeDataLoadAsyncMethodInfo          ,
#endif

-- * Exported types
    UnicodeData(..)                         ,
    IsUnicodeData                           ,
    toUnicodeData                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [copy]("GI.IBus.Objects.Serializable#g:method:copy"), [destroy]("GI.IBus.Objects.Object#g:method:destroy"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeQattachment]("GI.IBus.Objects.Serializable#g:method:removeQattachment"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [serializeObject]("GI.IBus.Objects.Serializable#g:method:serializeObject"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAlias]("GI.IBus.Objects.UnicodeData#g:method:getAlias"), [getBlockName]("GI.IBus.Objects.UnicodeData#g:method:getBlockName"), [getCode]("GI.IBus.Objects.UnicodeData#g:method:getCode"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.IBus.Objects.UnicodeData#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQattachment]("GI.IBus.Objects.Serializable#g:method:getQattachment"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setBlockName]("GI.IBus.Objects.UnicodeData#g:method:setBlockName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setQattachment]("GI.IBus.Objects.Serializable#g:method:setQattachment").

#if defined(ENABLE_OVERLOADING)
    ResolveUnicodeDataMethod                ,
#endif

-- ** getAlias #method:getAlias#

#if defined(ENABLE_OVERLOADING)
    UnicodeDataGetAliasMethodInfo           ,
#endif
    unicodeDataGetAlias                     ,


-- ** getBlockName #method:getBlockName#

#if defined(ENABLE_OVERLOADING)
    UnicodeDataGetBlockNameMethodInfo       ,
#endif
    unicodeDataGetBlockName                 ,


-- ** getCode #method:getCode#

#if defined(ENABLE_OVERLOADING)
    UnicodeDataGetCodeMethodInfo            ,
#endif
    unicodeDataGetCode                      ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    UnicodeDataGetNameMethodInfo            ,
#endif
    unicodeDataGetName                      ,


-- ** load #method:load#

    unicodeDataLoad                         ,


-- ** save #method:save#

    unicodeDataSave                         ,


-- ** setBlockName #method:setBlockName#

#if defined(ENABLE_OVERLOADING)
    UnicodeDataSetBlockNameMethodInfo       ,
#endif
    unicodeDataSetBlockName                 ,




 -- * Properties


-- ** alias #attr:alias#
-- | The Uniode alias name

#if defined(ENABLE_OVERLOADING)
    UnicodeDataAliasPropertyInfo            ,
#endif
    clearUnicodeDataAlias                   ,
    constructUnicodeDataAlias               ,
    getUnicodeDataAlias                     ,
    setUnicodeDataAlias                     ,
#if defined(ENABLE_OVERLOADING)
    unicodeDataAlias                        ,
#endif


-- ** blockName #attr:blockName#
-- | The Uniode block name

#if defined(ENABLE_OVERLOADING)
    UnicodeDataBlockNamePropertyInfo        ,
#endif
    constructUnicodeDataBlockName           ,
    getUnicodeDataBlockName                 ,
    setUnicodeDataBlockName                 ,
#if defined(ENABLE_OVERLOADING)
    unicodeDataBlockName                    ,
#endif


-- ** code #attr:code#
-- | The Uniode code point

#if defined(ENABLE_OVERLOADING)
    UnicodeDataCodePropertyInfo             ,
#endif
    constructUnicodeDataCode                ,
    getUnicodeDataCode                      ,
#if defined(ENABLE_OVERLOADING)
    unicodeDataCode                         ,
#endif


-- ** name #attr:name#
-- | The Uniode name

#if defined(ENABLE_OVERLOADING)
    UnicodeDataNamePropertyInfo             ,
#endif
    clearUnicodeDataName                    ,
    constructUnicodeDataName                ,
    getUnicodeDataName                      ,
    setUnicodeDataName                      ,
#if defined(ENABLE_OVERLOADING)
    unicodeDataName                         ,
#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.Coerce as Coerce
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

-- | Memory-managed wrapper type.
newtype UnicodeData = UnicodeData (SP.ManagedPtr UnicodeData)
    deriving (UnicodeData -> UnicodeData -> Bool
(UnicodeData -> UnicodeData -> Bool)
-> (UnicodeData -> UnicodeData -> Bool) -> Eq UnicodeData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnicodeData -> UnicodeData -> Bool
$c/= :: UnicodeData -> UnicodeData -> Bool
== :: UnicodeData -> UnicodeData -> Bool
$c== :: UnicodeData -> UnicodeData -> Bool
Eq)

instance SP.ManagedPtrNewtype UnicodeData where
    toManagedPtr :: UnicodeData -> ManagedPtr UnicodeData
toManagedPtr (UnicodeData ManagedPtr UnicodeData
p) = ManagedPtr UnicodeData
p

foreign import ccall "ibus_unicode_data_get_type"
    c_ibus_unicode_data_get_type :: IO B.Types.GType

instance B.Types.TypedObject UnicodeData where
    glibType :: IO GType
glibType = IO GType
c_ibus_unicode_data_get_type

instance B.Types.GObject UnicodeData

-- | Type class for types which can be safely cast to `UnicodeData`, for instance with `toUnicodeData`.
class (SP.GObject o, O.IsDescendantOf UnicodeData o) => IsUnicodeData o
instance (SP.GObject o, O.IsDescendantOf UnicodeData o) => IsUnicodeData o

instance O.HasParentTypes UnicodeData
type instance O.ParentTypes UnicodeData = '[IBus.Serializable.Serializable, IBus.Object.Object, GObject.Object.Object]

-- | Cast to `UnicodeData`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toUnicodeData :: (MIO.MonadIO m, IsUnicodeData o) => o -> m UnicodeData
toUnicodeData :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeData o) =>
o -> m UnicodeData
toUnicodeData = IO UnicodeData -> m UnicodeData
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO UnicodeData -> m UnicodeData)
-> (o -> IO UnicodeData) -> o -> m UnicodeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr UnicodeData -> UnicodeData) -> o -> IO UnicodeData
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr UnicodeData -> UnicodeData
UnicodeData

-- | Convert 'UnicodeData' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe UnicodeData) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_unicode_data_get_type
    gvalueSet_ :: Ptr GValue -> Maybe UnicodeData -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UnicodeData
P.Nothing = Ptr GValue -> Ptr UnicodeData -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr UnicodeData
forall a. Ptr a
FP.nullPtr :: FP.Ptr UnicodeData)
    gvalueSet_ Ptr GValue
gv (P.Just UnicodeData
obj) = UnicodeData -> (Ptr UnicodeData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnicodeData
obj (Ptr GValue -> Ptr UnicodeData -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe UnicodeData)
gvalueGet_ Ptr GValue
gv = do
        Ptr UnicodeData
ptr <- Ptr GValue -> IO (Ptr UnicodeData)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UnicodeData)
        if Ptr UnicodeData
ptr Ptr UnicodeData -> Ptr UnicodeData -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr UnicodeData
forall a. Ptr a
FP.nullPtr
        then UnicodeData -> Maybe UnicodeData
forall a. a -> Maybe a
P.Just (UnicodeData -> Maybe UnicodeData)
-> IO UnicodeData -> IO (Maybe UnicodeData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr UnicodeData -> UnicodeData)
-> Ptr UnicodeData -> IO UnicodeData
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UnicodeData -> UnicodeData
UnicodeData Ptr UnicodeData
ptr
        else Maybe UnicodeData -> IO (Maybe UnicodeData)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UnicodeData
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveUnicodeDataMethod (t :: Symbol) (o :: *) :: * where
    ResolveUnicodeDataMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveUnicodeDataMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveUnicodeDataMethod "copy" o = IBus.Serializable.SerializableCopyMethodInfo
    ResolveUnicodeDataMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
    ResolveUnicodeDataMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveUnicodeDataMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveUnicodeDataMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveUnicodeDataMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveUnicodeDataMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveUnicodeDataMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveUnicodeDataMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveUnicodeDataMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveUnicodeDataMethod "removeQattachment" o = IBus.Serializable.SerializableRemoveQattachmentMethodInfo
    ResolveUnicodeDataMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveUnicodeDataMethod "serializeObject" o = IBus.Serializable.SerializableSerializeObjectMethodInfo
    ResolveUnicodeDataMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveUnicodeDataMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveUnicodeDataMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveUnicodeDataMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveUnicodeDataMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveUnicodeDataMethod "getAlias" o = UnicodeDataGetAliasMethodInfo
    ResolveUnicodeDataMethod "getBlockName" o = UnicodeDataGetBlockNameMethodInfo
    ResolveUnicodeDataMethod "getCode" o = UnicodeDataGetCodeMethodInfo
    ResolveUnicodeDataMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveUnicodeDataMethod "getName" o = UnicodeDataGetNameMethodInfo
    ResolveUnicodeDataMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveUnicodeDataMethod "getQattachment" o = IBus.Serializable.SerializableGetQattachmentMethodInfo
    ResolveUnicodeDataMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveUnicodeDataMethod "setBlockName" o = UnicodeDataSetBlockNameMethodInfo
    ResolveUnicodeDataMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveUnicodeDataMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveUnicodeDataMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUnicodeDataMethod "setQattachment" o = IBus.Serializable.SerializableSetQattachmentMethodInfo
    ResolveUnicodeDataMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveUnicodeDataMethod t UnicodeData, O.OverloadedMethod info UnicodeData p) => OL.IsLabel t (UnicodeData -> 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 ~ ResolveUnicodeDataMethod t UnicodeData, O.OverloadedMethod info UnicodeData p, R.HasField t UnicodeData p) => R.HasField t UnicodeData p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveUnicodeDataMethod t UnicodeData, O.OverloadedMethodInfo info UnicodeData) => OL.IsLabel t (O.MethodProxy info UnicodeData) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "alias"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@alias@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' unicodeData #alias
-- @
getUnicodeDataAlias :: (MonadIO m, IsUnicodeData o) => o -> m T.Text
getUnicodeDataAlias :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeData o) => o -> m Text
getUnicodeDataAlias 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
"getUnicodeDataAlias" (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
"alias"

-- | Set the value of the “@alias@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' unicodeData [ #alias 'Data.GI.Base.Attributes.:=' value ]
-- @
setUnicodeDataAlias :: (MonadIO m, IsUnicodeData o) => o -> T.Text -> m ()
setUnicodeDataAlias :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeData o) =>
o -> Text -> m ()
setUnicodeDataAlias 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
"alias" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@alias@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUnicodeDataAlias :: (IsUnicodeData o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructUnicodeDataAlias :: forall o (m :: * -> *).
(IsUnicodeData o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructUnicodeDataAlias 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
"alias" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@alias@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #alias
-- @
clearUnicodeDataAlias :: (MonadIO m, IsUnicodeData o) => o -> m ()
clearUnicodeDataAlias :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeData o) => o -> m ()
clearUnicodeDataAlias 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
"alias" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data UnicodeDataAliasPropertyInfo
instance AttrInfo UnicodeDataAliasPropertyInfo where
    type AttrAllowedOps UnicodeDataAliasPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint UnicodeDataAliasPropertyInfo = IsUnicodeData
    type AttrSetTypeConstraint UnicodeDataAliasPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint UnicodeDataAliasPropertyInfo = (~) T.Text
    type AttrTransferType UnicodeDataAliasPropertyInfo = T.Text
    type AttrGetType UnicodeDataAliasPropertyInfo = T.Text
    type AttrLabel UnicodeDataAliasPropertyInfo = "alias"
    type AttrOrigin UnicodeDataAliasPropertyInfo = UnicodeData
    attrGet = getUnicodeDataAlias
    attrSet = setUnicodeDataAlias
    attrTransfer _ v = do
        return v
    attrConstruct = constructUnicodeDataAlias
    attrClear = clearUnicodeDataAlias
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.alias"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#g:attr:alias"
        })
#endif

-- VVV Prop "block-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@block-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' unicodeData #blockName
-- @
getUnicodeDataBlockName :: (MonadIO m, IsUnicodeData o) => o -> m T.Text
getUnicodeDataBlockName :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeData o) => o -> m Text
getUnicodeDataBlockName 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
"getUnicodeDataBlockName" (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
"block-name"

-- | Set the value of the “@block-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' unicodeData [ #blockName 'Data.GI.Base.Attributes.:=' value ]
-- @
setUnicodeDataBlockName :: (MonadIO m, IsUnicodeData o) => o -> T.Text -> m ()
setUnicodeDataBlockName :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeData o) =>
o -> Text -> m ()
setUnicodeDataBlockName 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
"block-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@block-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUnicodeDataBlockName :: (IsUnicodeData o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructUnicodeDataBlockName :: forall o (m :: * -> *).
(IsUnicodeData o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructUnicodeDataBlockName 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
"block-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data UnicodeDataBlockNamePropertyInfo
instance AttrInfo UnicodeDataBlockNamePropertyInfo where
    type AttrAllowedOps UnicodeDataBlockNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UnicodeDataBlockNamePropertyInfo = IsUnicodeData
    type AttrSetTypeConstraint UnicodeDataBlockNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint UnicodeDataBlockNamePropertyInfo = (~) T.Text
    type AttrTransferType UnicodeDataBlockNamePropertyInfo = T.Text
    type AttrGetType UnicodeDataBlockNamePropertyInfo = T.Text
    type AttrLabel UnicodeDataBlockNamePropertyInfo = "block-name"
    type AttrOrigin UnicodeDataBlockNamePropertyInfo = UnicodeData
    attrGet = getUnicodeDataBlockName
    attrSet = setUnicodeDataBlockName
    attrTransfer _ v = do
        return v
    attrConstruct = constructUnicodeDataBlockName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.blockName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#g:attr:blockName"
        })
#endif

-- VVV Prop "code"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@code@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' unicodeData #code
-- @
getUnicodeDataCode :: (MonadIO m, IsUnicodeData o) => o -> m Word32
getUnicodeDataCode :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeData o) =>
o -> m Word32
getUnicodeDataCode 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
"code"

-- | Construct a `GValueConstruct` with valid value for the “@code@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUnicodeDataCode :: (IsUnicodeData o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructUnicodeDataCode :: forall o (m :: * -> *).
(IsUnicodeData o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructUnicodeDataCode 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
"code" Word32
val

#if defined(ENABLE_OVERLOADING)
data UnicodeDataCodePropertyInfo
instance AttrInfo UnicodeDataCodePropertyInfo where
    type AttrAllowedOps UnicodeDataCodePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UnicodeDataCodePropertyInfo = IsUnicodeData
    type AttrSetTypeConstraint UnicodeDataCodePropertyInfo = (~) Word32
    type AttrTransferTypeConstraint UnicodeDataCodePropertyInfo = (~) Word32
    type AttrTransferType UnicodeDataCodePropertyInfo = Word32
    type AttrGetType UnicodeDataCodePropertyInfo = Word32
    type AttrLabel UnicodeDataCodePropertyInfo = "code"
    type AttrOrigin UnicodeDataCodePropertyInfo = UnicodeData
    attrGet = getUnicodeDataCode
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructUnicodeDataCode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.code"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#g:attr:code"
        })
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' unicodeData #name
-- @
getUnicodeDataName :: (MonadIO m, IsUnicodeData o) => o -> m T.Text
getUnicodeDataName :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeData o) => o -> m Text
getUnicodeDataName 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
"getUnicodeDataName" (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"

-- | Set the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' unicodeData [ #name 'Data.GI.Base.Attributes.:=' value ]
-- @
setUnicodeDataName :: (MonadIO m, IsUnicodeData o) => o -> T.Text -> m ()
setUnicodeDataName :: forall (m :: * -> *) o.
(MonadIO m, IsUnicodeData o) =>
o -> Text -> m ()
setUnicodeDataName 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)

-- | Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUnicodeDataName :: (IsUnicodeData o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructUnicodeDataName :: forall o (m :: * -> *).
(IsUnicodeData o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructUnicodeDataName 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)

-- | Set the value of the “@name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #name
-- @
clearUnicodeDataName :: (MonadIO m, IsUnicodeData o) => o -> m ()
clearUnicodeDataName :: forall (m :: * -> *) o. (MonadIO m, IsUnicodeData o) => o -> m ()
clearUnicodeDataName 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 UnicodeDataNamePropertyInfo
instance AttrInfo UnicodeDataNamePropertyInfo where
    type AttrAllowedOps UnicodeDataNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint UnicodeDataNamePropertyInfo = IsUnicodeData
    type AttrSetTypeConstraint UnicodeDataNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint UnicodeDataNamePropertyInfo = (~) T.Text
    type AttrTransferType UnicodeDataNamePropertyInfo = T.Text
    type AttrGetType UnicodeDataNamePropertyInfo = T.Text
    type AttrLabel UnicodeDataNamePropertyInfo = "name"
    type AttrOrigin UnicodeDataNamePropertyInfo = UnicodeData
    attrGet = getUnicodeDataName
    attrSet = setUnicodeDataName
    attrTransfer _ v = do
        return v
    attrConstruct = constructUnicodeDataName
    attrClear = clearUnicodeDataName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#g:attr:name"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UnicodeData
type instance O.AttributeList UnicodeData = UnicodeDataAttributeList
type UnicodeDataAttributeList = ('[ '("alias", UnicodeDataAliasPropertyInfo), '("blockName", UnicodeDataBlockNamePropertyInfo), '("code", UnicodeDataCodePropertyInfo), '("name", UnicodeDataNamePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
unicodeDataAlias :: AttrLabelProxy "alias"
unicodeDataAlias = AttrLabelProxy

unicodeDataBlockName :: AttrLabelProxy "blockName"
unicodeDataBlockName = AttrLabelProxy

unicodeDataCode :: AttrLabelProxy "code"
unicodeDataCode = AttrLabelProxy

unicodeDataName :: AttrLabelProxy "name"
unicodeDataName = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UnicodeData = UnicodeDataSignalList
type UnicodeDataSignalList = ('[ '("destroy", IBus.Object.ObjectDestroySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method UnicodeData::get_alias
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "unicode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "UnicodeData" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusUnicodeData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_get_alias" ibus_unicode_data_get_alias :: 
    Ptr UnicodeData ->                      -- unicode : TInterface (Name {namespace = "IBus", name = "UnicodeData"})
    IO CString

-- | Gets the alias in t'GI.IBus.Objects.UnicodeData.UnicodeData'. It should not be freed.
unicodeDataGetAlias ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    a
    -- ^ /@unicode@/: An t'GI.IBus.Objects.UnicodeData.UnicodeData'
    -> m T.Text
    -- ^ __Returns:__ alias property in t'GI.IBus.Objects.UnicodeData.UnicodeData'
unicodeDataGetAlias :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
a -> m Text
unicodeDataGetAlias a
unicode = 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 UnicodeData
unicode' <- a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
unicode
    CString
result <- Ptr UnicodeData -> IO CString
ibus_unicode_data_get_alias Ptr UnicodeData
unicode'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unicodeDataGetAlias" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
unicode
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnicodeDataGetAliasMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsUnicodeData a) => O.OverloadedMethod UnicodeDataGetAliasMethodInfo a signature where
    overloadedMethod = unicodeDataGetAlias

instance O.OverloadedMethodInfo UnicodeDataGetAliasMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.unicodeDataGetAlias",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#v:unicodeDataGetAlias"
        })


#endif

-- method UnicodeData::get_block_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "unicode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "UnicodeData" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusUnicodeData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_get_block_name" ibus_unicode_data_get_block_name :: 
    Ptr UnicodeData ->                      -- unicode : TInterface (Name {namespace = "IBus", name = "UnicodeData"})
    IO CString

-- | Gets the block name in t'GI.IBus.Objects.UnicodeData.UnicodeData'. It should not be freed.
unicodeDataGetBlockName ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    a
    -- ^ /@unicode@/: An t'GI.IBus.Objects.UnicodeData.UnicodeData'
    -> m T.Text
    -- ^ __Returns:__ block-name property in t'GI.IBus.Objects.UnicodeData.UnicodeData'
unicodeDataGetBlockName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
a -> m Text
unicodeDataGetBlockName a
unicode = 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 UnicodeData
unicode' <- a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
unicode
    CString
result <- Ptr UnicodeData -> IO CString
ibus_unicode_data_get_block_name Ptr UnicodeData
unicode'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unicodeDataGetBlockName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
unicode
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnicodeDataGetBlockNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsUnicodeData a) => O.OverloadedMethod UnicodeDataGetBlockNameMethodInfo a signature where
    overloadedMethod = unicodeDataGetBlockName

instance O.OverloadedMethodInfo UnicodeDataGetBlockNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.unicodeDataGetBlockName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#v:unicodeDataGetBlockName"
        })


#endif

-- method UnicodeData::get_code
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "unicode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "UnicodeData" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusUnicodeData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUniChar)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_get_code" ibus_unicode_data_get_code :: 
    Ptr UnicodeData ->                      -- unicode : TInterface (Name {namespace = "IBus", name = "UnicodeData"})
    IO CInt

-- | Gets the code point in t'GI.IBus.Objects.UnicodeData.UnicodeData'.
unicodeDataGetCode ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    a
    -- ^ /@unicode@/: An t'GI.IBus.Objects.UnicodeData.UnicodeData'
    -> m Char
    -- ^ __Returns:__ code property in t'GI.IBus.Objects.UnicodeData.UnicodeData'
unicodeDataGetCode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
a -> m Char
unicodeDataGetCode a
unicode = 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 UnicodeData
unicode' <- a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
unicode
    CInt
result <- Ptr UnicodeData -> IO CInt
ibus_unicode_data_get_code Ptr UnicodeData
unicode'
    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
unicode
    Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'

#if defined(ENABLE_OVERLOADING)
data UnicodeDataGetCodeMethodInfo
instance (signature ~ (m Char), MonadIO m, IsUnicodeData a) => O.OverloadedMethod UnicodeDataGetCodeMethodInfo a signature where
    overloadedMethod = unicodeDataGetCode

instance O.OverloadedMethodInfo UnicodeDataGetCodeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.unicodeDataGetCode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#v:unicodeDataGetCode"
        })


#endif

-- method UnicodeData::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "unicode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "UnicodeData" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusUnicodeData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_get_name" ibus_unicode_data_get_name :: 
    Ptr UnicodeData ->                      -- unicode : TInterface (Name {namespace = "IBus", name = "UnicodeData"})
    IO CString

-- | Gets the name in t'GI.IBus.Objects.UnicodeData.UnicodeData'. It should not be freed.
unicodeDataGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    a
    -- ^ /@unicode@/: An t'GI.IBus.Objects.UnicodeData.UnicodeData'
    -> m T.Text
    -- ^ __Returns:__ name property in t'GI.IBus.Objects.UnicodeData.UnicodeData'
unicodeDataGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
a -> m Text
unicodeDataGetName a
unicode = 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 UnicodeData
unicode' <- a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
unicode
    CString
result <- Ptr UnicodeData -> IO CString
ibus_unicode_data_get_name Ptr UnicodeData
unicode'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unicodeDataGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
unicode
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UnicodeDataGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsUnicodeData a) => O.OverloadedMethod UnicodeDataGetNameMethodInfo a signature where
    overloadedMethod = unicodeDataGetName

instance O.OverloadedMethodInfo UnicodeDataGetNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.unicodeDataGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#v:unicodeDataGetName"
        })


#endif

-- method UnicodeData::set_block_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "unicode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "UnicodeData" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusUnicodeData"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "block_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A block name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_set_block_name" ibus_unicode_data_set_block_name :: 
    Ptr UnicodeData ->                      -- unicode : TInterface (Name {namespace = "IBus", name = "UnicodeData"})
    CString ->                              -- block_name : TBasicType TUTF8
    IO ()

-- | Sets the block name in t'GI.IBus.Objects.UnicodeData.UnicodeData'.
unicodeDataSetBlockName ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    a
    -- ^ /@unicode@/: An t'GI.IBus.Objects.UnicodeData.UnicodeData'
    -> T.Text
    -- ^ /@blockName@/: A block name
    -> m ()
unicodeDataSetBlockName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
a -> Text -> m ()
unicodeDataSetBlockName a
unicode Text
blockName = 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 UnicodeData
unicode' <- a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
unicode
    CString
blockName' <- Text -> IO CString
textToCString Text
blockName
    Ptr UnicodeData -> CString -> IO ()
ibus_unicode_data_set_block_name Ptr UnicodeData
unicode' CString
blockName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
unicode
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
blockName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UnicodeDataSetBlockNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsUnicodeData a) => O.OverloadedMethod UnicodeDataSetBlockNameMethodInfo a signature where
    overloadedMethod = unicodeDataSetBlockName

instance O.OverloadedMethodInfo UnicodeDataSetBlockNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.UnicodeData.unicodeDataSetBlockName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.4/docs/GI-IBus-Objects-UnicodeData.html#v:unicodeDataSetBlockName"
        })


#endif

-- method UnicodeData::load
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A path of the saved dictionary file."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "If the #GObject has \"unicode-deserialize-progress\"\n   signal, this function will emit (the number of desrialized\n   #IBusUnicodeData, * the total number of #IBusUnicodeData) of uint values\n   with that signal by 100 times. Otherwise %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGSList
--                  (TInterface Name { namespace = "IBus" , name = "UnicodeData" }))
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_load" ibus_unicode_data_load :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr GObject.Object.Object ->            -- object : TInterface (Name {namespace = "GObject", name = "Object"})
    IO (Ptr (GSList (Ptr UnicodeData)))

-- | /No description available in the introspection data./
unicodeDataLoad ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    T.Text
    -- ^ /@path@/: A path of the saved dictionary file.
    -> Maybe (a)
    -- ^ /@object@/: If the t'GI.GObject.Objects.Object.Object' has \"unicode-deserialize-progress\"
    --    signal, this function will emit (the number of desrialized
    --    t'GI.IBus.Objects.UnicodeData.UnicodeData', * the total number of t'GI.IBus.Objects.UnicodeData.UnicodeData') of uint values
    --    with that signal by 100 times. Otherwise 'P.Nothing'.
    -> m [UnicodeData]
    -- ^ __Returns:__ 
    -- An t'GI.IBus.Objects.UnicodeData.UnicodeData' list loaded from the saved cache file.
unicodeDataLoad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
Text -> Maybe a -> m [UnicodeData]
unicodeDataLoad Text
path Maybe a
object = IO [UnicodeData] -> m [UnicodeData]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [UnicodeData] -> m [UnicodeData])
-> IO [UnicodeData] -> m [UnicodeData]
forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr Object
maybeObject <- case Maybe a
object of
        Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just a
jObject -> do
            Ptr Object
jObject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jObject
            Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jObject'
    Ptr (GSList (Ptr UnicodeData))
result <- CString -> Ptr Object -> IO (Ptr (GSList (Ptr UnicodeData)))
ibus_unicode_data_load CString
path' Ptr Object
maybeObject
    [Ptr UnicodeData]
result' <- Ptr (GSList (Ptr UnicodeData)) -> IO [Ptr UnicodeData]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr UnicodeData))
result
    [UnicodeData]
result'' <- (Ptr UnicodeData -> IO UnicodeData)
-> [Ptr UnicodeData] -> IO [UnicodeData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr UnicodeData -> UnicodeData)
-> Ptr UnicodeData -> IO UnicodeData
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnicodeData -> UnicodeData
UnicodeData) [Ptr UnicodeData]
result'
    Ptr (GSList (Ptr UnicodeData)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr UnicodeData))
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
object a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    [UnicodeData] -> IO [UnicodeData]
forall (m :: * -> *) a. Monad m => a -> m a
return [UnicodeData]
result''

#if defined(ENABLE_OVERLOADING)
#endif

-- XXX Could not generate method UnicodeData::load_async
{-  Bad introspection data: ScopeTypeNotified without destructor! Callable
      { returnType = Nothing
      , returnMayBeNull = False
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , args =
          [ Arg
              { argCName = "path"
              , argType = TBasicType TUTF8
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "A path of the saved dictionary file."
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "object"
              , argType =
                  TInterface Name { namespace = "GObject" , name = "Object" }
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText =
                        Just
                          "If the #GObject has \"unicode-deserialize-progress\"\n   signal, this function will emit (the number of desrialized\n   #IBusUnicodeData, * the total number of #IBusUnicodeData) of uint values\n   with that signal by 100 times. Otherwise %NULL."
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "cancellable"
              , argType =
                  TInterface Name { namespace = "Gio" , name = "Cancellable" }
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "cancellable." , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "callback"
              , argType =
                  TInterface
                    Name { namespace = "IBus" , name = "UnicodeDataLoadAsyncFinish" }
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "IBusUnicodeDataLoadAsyncFinish."
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeNotified
              , argClosure = 4
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "user_data"
              , argType = TBasicType TPtr
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "User data." , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation
            { rawDocText =
                Just
                  "IBusUnicodeDataLoadAsyncFinish can receive the list of #IBusUnicodeData."
            , sinceVersion = Nothing
            }
      , callableResolvable = Just True
      }
-}
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data UnicodeDataLoadAsyncMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "loadAsync" UnicodeData) => O.OverloadedMethod UnicodeDataLoadAsyncMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "loadAsync" UnicodeData) => O.OverloadedMethodInfo UnicodeDataLoadAsyncMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method UnicodeData::save
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A path of the saved Unicode data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "list"
--           , argType =
--               TGSList
--                 (TInterface Name { namespace = "IBus" , name = "UnicodeData" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A list of unicode\n data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_unicode_data_save" ibus_unicode_data_save :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr (GSList (Ptr UnicodeData)) ->       -- list : TGSList (TInterface (Name {namespace = "IBus", name = "UnicodeData"}))
    IO ()

-- | Save the list of t'GI.IBus.Objects.UnicodeData.UnicodeData' to the cache file.
unicodeDataSave ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnicodeData a) =>
    T.Text
    -- ^ /@path@/: A path of the saved Unicode data.
    -> [a]
    -- ^ /@list@/: A list of unicode
    --  data.
    -> m ()
unicodeDataSave :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnicodeData a) =>
Text -> [a] -> m ()
unicodeDataSave 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 UnicodeData]
list' <- (a -> IO (Ptr UnicodeData)) -> [a] -> IO [Ptr UnicodeData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> IO (Ptr UnicodeData)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [a]
list
    Ptr (GSList (Ptr UnicodeData))
list'' <- [Ptr UnicodeData] -> IO (Ptr (GSList (Ptr UnicodeData)))
forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr UnicodeData]
list'
    CString -> Ptr (GSList (Ptr UnicodeData)) -> IO ()
ibus_unicode_data_save CString
path' Ptr (GSList (Ptr UnicodeData))
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 UnicodeData)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr UnicodeData))
list''
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif