#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.IBus.Flags
(
BusNameFlag(..) ,
Capabilite(..) ,
InputHints(..) ,
ModifierType(..) ,
ObjectFlags(..) ,
) 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
data ObjectFlags =
ObjectFlagsInDestruction
| ObjectFlagsDestroyed
| ObjectFlagsReserved1
| ObjectFlagsReserved2
| AnotherObjectFlags Int
deriving (Int -> ObjectFlags -> ShowS
[ObjectFlags] -> ShowS
ObjectFlags -> String
(Int -> ObjectFlags -> ShowS)
-> (ObjectFlags -> String)
-> ([ObjectFlags] -> ShowS)
-> Show ObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectFlags] -> ShowS
$cshowList :: [ObjectFlags] -> ShowS
show :: ObjectFlags -> String
$cshow :: ObjectFlags -> String
showsPrec :: Int -> ObjectFlags -> ShowS
$cshowsPrec :: Int -> ObjectFlags -> ShowS
Show, ObjectFlags -> ObjectFlags -> Bool
(ObjectFlags -> ObjectFlags -> Bool)
-> (ObjectFlags -> ObjectFlags -> Bool) -> Eq ObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectFlags -> ObjectFlags -> Bool
$c/= :: ObjectFlags -> ObjectFlags -> Bool
== :: ObjectFlags -> ObjectFlags -> Bool
$c== :: ObjectFlags -> ObjectFlags -> Bool
Eq)
instance P.Enum ObjectFlags where
fromEnum :: ObjectFlags -> Int
fromEnum ObjectFlags
ObjectFlagsInDestruction = Int
1
fromEnum ObjectFlags
ObjectFlagsDestroyed = Int
2
fromEnum ObjectFlags
ObjectFlagsReserved1 = Int
4
fromEnum ObjectFlags
ObjectFlagsReserved2 = Int
8
fromEnum (AnotherObjectFlags Int
k) = Int
k
toEnum :: Int -> ObjectFlags
toEnum Int
1 = ObjectFlags
ObjectFlagsInDestruction
toEnum Int
2 = ObjectFlags
ObjectFlagsDestroyed
toEnum Int
4 = ObjectFlags
ObjectFlagsReserved1
toEnum Int
8 = ObjectFlags
ObjectFlagsReserved2
toEnum Int
k = Int -> ObjectFlags
AnotherObjectFlags Int
k
instance P.Ord ObjectFlags where
compare :: ObjectFlags -> ObjectFlags -> Ordering
compare ObjectFlags
a ObjectFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
a) (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
b)
type instance O.ParentTypes ObjectFlags = '[]
instance O.HasParentTypes ObjectFlags
foreign import ccall "ibus_object_flags_get_type" c_ibus_object_flags_get_type ::
IO GType
instance B.Types.TypedObject ObjectFlags where
glibType :: IO GType
glibType = IO GType
c_ibus_object_flags_get_type
instance B.Types.BoxedFlags ObjectFlags
instance IsGFlag ObjectFlags
data ModifierType =
ModifierTypeShiftMask
| ModifierTypeLockMask
| ModifierTypeControlMask
| ModifierTypeMod1Mask
| ModifierTypeMod2Mask
| ModifierTypeMod3Mask
| ModifierTypeMod4Mask
| ModifierTypeMod5Mask
| ModifierTypeButton1Mask
| ModifierTypeButton2Mask
| ModifierTypeButton3Mask
| ModifierTypeButton4Mask
| ModifierTypeButton5Mask
| ModifierTypeHandledMask
| ModifierTypeForwardMask
| ModifierTypeIgnoredMask
| ModifierTypeSuperMask
| ModifierTypeHyperMask
| ModifierTypeMetaMask
| ModifierTypeReleaseMask
| ModifierTypeModifierMask
| AnotherModifierType Int
deriving (Int -> ModifierType -> ShowS
[ModifierType] -> ShowS
ModifierType -> String
(Int -> ModifierType -> ShowS)
-> (ModifierType -> String)
-> ([ModifierType] -> ShowS)
-> Show ModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifierType] -> ShowS
$cshowList :: [ModifierType] -> ShowS
show :: ModifierType -> String
$cshow :: ModifierType -> String
showsPrec :: Int -> ModifierType -> ShowS
$cshowsPrec :: Int -> ModifierType -> ShowS
Show, ModifierType -> ModifierType -> Bool
(ModifierType -> ModifierType -> Bool)
-> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifierType -> ModifierType -> Bool
$c/= :: ModifierType -> ModifierType -> Bool
== :: ModifierType -> ModifierType -> Bool
$c== :: ModifierType -> ModifierType -> Bool
Eq)
instance P.Enum ModifierType where
fromEnum :: ModifierType -> Int
fromEnum ModifierType
ModifierTypeShiftMask = Int
1
fromEnum ModifierType
ModifierTypeLockMask = Int
2
fromEnum ModifierType
ModifierTypeControlMask = Int
4
fromEnum ModifierType
ModifierTypeMod1Mask = Int
8
fromEnum ModifierType
ModifierTypeMod2Mask = Int
16
fromEnum ModifierType
ModifierTypeMod3Mask = Int
32
fromEnum ModifierType
ModifierTypeMod4Mask = Int
64
fromEnum ModifierType
ModifierTypeMod5Mask = Int
128
fromEnum ModifierType
ModifierTypeButton1Mask = Int
256
fromEnum ModifierType
ModifierTypeButton2Mask = Int
512
fromEnum ModifierType
ModifierTypeButton3Mask = Int
1024
fromEnum ModifierType
ModifierTypeButton4Mask = Int
2048
fromEnum ModifierType
ModifierTypeButton5Mask = Int
4096
fromEnum ModifierType
ModifierTypeHandledMask = Int
16777216
fromEnum ModifierType
ModifierTypeForwardMask = Int
33554432
fromEnum ModifierType
ModifierTypeIgnoredMask = Int
33554432
fromEnum ModifierType
ModifierTypeSuperMask = Int
67108864
fromEnum ModifierType
ModifierTypeHyperMask = Int
134217728
fromEnum ModifierType
ModifierTypeMetaMask = Int
268435456
fromEnum ModifierType
ModifierTypeReleaseMask = Int
1073741824
fromEnum ModifierType
ModifierTypeModifierMask = Int
1593843711
fromEnum (AnotherModifierType Int
k) = Int
k
toEnum :: Int -> ModifierType
toEnum Int
1 = ModifierType
ModifierTypeShiftMask
toEnum Int
2 = ModifierType
ModifierTypeLockMask
toEnum Int
4 = ModifierType
ModifierTypeControlMask
toEnum Int
8 = ModifierType
ModifierTypeMod1Mask
toEnum Int
16 = ModifierType
ModifierTypeMod2Mask
toEnum Int
32 = ModifierType
ModifierTypeMod3Mask
toEnum Int
64 = ModifierType
ModifierTypeMod4Mask
toEnum Int
128 = ModifierType
ModifierTypeMod5Mask
toEnum Int
256 = ModifierType
ModifierTypeButton1Mask
toEnum Int
512 = ModifierType
ModifierTypeButton2Mask
toEnum Int
1024 = ModifierType
ModifierTypeButton3Mask
toEnum Int
2048 = ModifierType
ModifierTypeButton4Mask
toEnum Int
4096 = ModifierType
ModifierTypeButton5Mask
toEnum Int
16777216 = ModifierType
ModifierTypeHandledMask
toEnum Int
33554432 = ModifierType
ModifierTypeForwardMask
toEnum Int
67108864 = ModifierType
ModifierTypeSuperMask
toEnum Int
134217728 = ModifierType
ModifierTypeHyperMask
toEnum Int
268435456 = ModifierType
ModifierTypeMetaMask
toEnum Int
1073741824 = ModifierType
ModifierTypeReleaseMask
toEnum Int
1593843711 = ModifierType
ModifierTypeModifierMask
toEnum Int
k = Int -> ModifierType
AnotherModifierType Int
k
instance P.Ord ModifierType where
compare :: ModifierType -> ModifierType -> Ordering
compare ModifierType
a ModifierType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
a) (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
b)
type instance O.ParentTypes ModifierType = '[]
instance O.HasParentTypes ModifierType
foreign import ccall "ibus_modifier_type_get_type" c_ibus_modifier_type_get_type ::
IO GType
instance B.Types.TypedObject ModifierType where
glibType :: IO GType
glibType = IO GType
c_ibus_modifier_type_get_type
instance B.Types.BoxedFlags ModifierType
instance IsGFlag ModifierType
data InputHints =
InputHintsNone
| InputHintsSpellcheck
| InputHintsNoSpellcheck
| InputHintsWordCompletion
| InputHintsLowercase
| InputHintsUppercaseChars
| InputHintsUppercaseWords
| InputHintsUppercaseSentences
| InputHintsInhibitOsk
| InputHintsVerticalWriting
| InputHintsEmoji
| InputHintsNoEmoji
| AnotherInputHints Int
deriving (Int -> InputHints -> ShowS
[InputHints] -> ShowS
InputHints -> String
(Int -> InputHints -> ShowS)
-> (InputHints -> String)
-> ([InputHints] -> ShowS)
-> Show InputHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputHints] -> ShowS
$cshowList :: [InputHints] -> ShowS
show :: InputHints -> String
$cshow :: InputHints -> String
showsPrec :: Int -> InputHints -> ShowS
$cshowsPrec :: Int -> InputHints -> ShowS
Show, InputHints -> InputHints -> Bool
(InputHints -> InputHints -> Bool)
-> (InputHints -> InputHints -> Bool) -> Eq InputHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputHints -> InputHints -> Bool
$c/= :: InputHints -> InputHints -> Bool
== :: InputHints -> InputHints -> Bool
$c== :: InputHints -> InputHints -> Bool
Eq)
instance P.Enum InputHints where
fromEnum :: InputHints -> Int
fromEnum InputHints
InputHintsNone = Int
0
fromEnum InputHints
InputHintsSpellcheck = Int
1
fromEnum InputHints
InputHintsNoSpellcheck = Int
2
fromEnum InputHints
InputHintsWordCompletion = Int
4
fromEnum InputHints
InputHintsLowercase = Int
8
fromEnum InputHints
InputHintsUppercaseChars = Int
16
fromEnum InputHints
InputHintsUppercaseWords = Int
32
fromEnum InputHints
InputHintsUppercaseSentences = Int
64
fromEnum InputHints
InputHintsInhibitOsk = Int
128
fromEnum InputHints
InputHintsVerticalWriting = Int
256
fromEnum InputHints
InputHintsEmoji = Int
512
fromEnum InputHints
InputHintsNoEmoji = Int
1024
fromEnum (AnotherInputHints Int
k) = Int
k
toEnum :: Int -> InputHints
toEnum Int
0 = InputHints
InputHintsNone
toEnum Int
1 = InputHints
InputHintsSpellcheck
toEnum Int
2 = InputHints
InputHintsNoSpellcheck
toEnum Int
4 = InputHints
InputHintsWordCompletion
toEnum Int
8 = InputHints
InputHintsLowercase
toEnum Int
16 = InputHints
InputHintsUppercaseChars
toEnum Int
32 = InputHints
InputHintsUppercaseWords
toEnum Int
64 = InputHints
InputHintsUppercaseSentences
toEnum Int
128 = InputHints
InputHintsInhibitOsk
toEnum Int
256 = InputHints
InputHintsVerticalWriting
toEnum Int
512 = InputHints
InputHintsEmoji
toEnum Int
1024 = InputHints
InputHintsNoEmoji
toEnum Int
k = Int -> InputHints
AnotherInputHints Int
k
instance P.Ord InputHints where
compare :: InputHints -> InputHints -> Ordering
compare InputHints
a InputHints
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputHints -> Int
forall a. Enum a => a -> Int
P.fromEnum InputHints
a) (InputHints -> Int
forall a. Enum a => a -> Int
P.fromEnum InputHints
b)
type instance O.ParentTypes InputHints = '[]
instance O.HasParentTypes InputHints
foreign import ccall "ibus_input_hints_get_type" c_ibus_input_hints_get_type ::
IO GType
instance B.Types.TypedObject InputHints where
glibType :: IO GType
glibType = IO GType
c_ibus_input_hints_get_type
instance B.Types.BoxedFlags InputHints
instance IsGFlag InputHints
data Capabilite =
CapabilitePreeditText
| CapabiliteAuxiliaryText
| CapabiliteLookupTable
| CapabiliteFocus
| CapabiliteProperty
| CapabiliteSurroundingText
| AnotherCapabilite Int
deriving (Int -> Capabilite -> ShowS
[Capabilite] -> ShowS
Capabilite -> String
(Int -> Capabilite -> ShowS)
-> (Capabilite -> String)
-> ([Capabilite] -> ShowS)
-> Show Capabilite
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Capabilite] -> ShowS
$cshowList :: [Capabilite] -> ShowS
show :: Capabilite -> String
$cshow :: Capabilite -> String
showsPrec :: Int -> Capabilite -> ShowS
$cshowsPrec :: Int -> Capabilite -> ShowS
Show, Capabilite -> Capabilite -> Bool
(Capabilite -> Capabilite -> Bool)
-> (Capabilite -> Capabilite -> Bool) -> Eq Capabilite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Capabilite -> Capabilite -> Bool
$c/= :: Capabilite -> Capabilite -> Bool
== :: Capabilite -> Capabilite -> Bool
$c== :: Capabilite -> Capabilite -> Bool
Eq)
instance P.Enum Capabilite where
fromEnum :: Capabilite -> Int
fromEnum Capabilite
CapabilitePreeditText = Int
1
fromEnum Capabilite
CapabiliteAuxiliaryText = Int
2
fromEnum Capabilite
CapabiliteLookupTable = Int
4
fromEnum Capabilite
CapabiliteFocus = Int
8
fromEnum Capabilite
CapabiliteProperty = Int
16
fromEnum Capabilite
CapabiliteSurroundingText = Int
32
fromEnum (AnotherCapabilite Int
k) = Int
k
toEnum :: Int -> Capabilite
toEnum Int
1 = Capabilite
CapabilitePreeditText
toEnum Int
2 = Capabilite
CapabiliteAuxiliaryText
toEnum Int
4 = Capabilite
CapabiliteLookupTable
toEnum Int
8 = Capabilite
CapabiliteFocus
toEnum Int
16 = Capabilite
CapabiliteProperty
toEnum Int
32 = Capabilite
CapabiliteSurroundingText
toEnum Int
k = Int -> Capabilite
AnotherCapabilite Int
k
instance P.Ord Capabilite where
compare :: Capabilite -> Capabilite -> Ordering
compare Capabilite
a Capabilite
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Capabilite -> Int
forall a. Enum a => a -> Int
P.fromEnum Capabilite
a) (Capabilite -> Int
forall a. Enum a => a -> Int
P.fromEnum Capabilite
b)
type instance O.ParentTypes Capabilite = '[]
instance O.HasParentTypes Capabilite
foreign import ccall "ibus_capabilite_get_type" c_ibus_capabilite_get_type ::
IO GType
instance B.Types.TypedObject Capabilite where
glibType :: IO GType
glibType = IO GType
c_ibus_capabilite_get_type
instance B.Types.BoxedFlags Capabilite
instance IsGFlag Capabilite
data BusNameFlag =
BusNameFlagAllowReplacement
| BusNameFlagReplaceExisting
| BusNameFlagDoNotQueue
| AnotherBusNameFlag Int
deriving (Int -> BusNameFlag -> ShowS
[BusNameFlag] -> ShowS
BusNameFlag -> String
(Int -> BusNameFlag -> ShowS)
-> (BusNameFlag -> String)
-> ([BusNameFlag] -> ShowS)
-> Show BusNameFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BusNameFlag] -> ShowS
$cshowList :: [BusNameFlag] -> ShowS
show :: BusNameFlag -> String
$cshow :: BusNameFlag -> String
showsPrec :: Int -> BusNameFlag -> ShowS
$cshowsPrec :: Int -> BusNameFlag -> ShowS
Show, BusNameFlag -> BusNameFlag -> Bool
(BusNameFlag -> BusNameFlag -> Bool)
-> (BusNameFlag -> BusNameFlag -> Bool) -> Eq BusNameFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BusNameFlag -> BusNameFlag -> Bool
$c/= :: BusNameFlag -> BusNameFlag -> Bool
== :: BusNameFlag -> BusNameFlag -> Bool
$c== :: BusNameFlag -> BusNameFlag -> Bool
Eq)
instance P.Enum BusNameFlag where
fromEnum :: BusNameFlag -> Int
fromEnum BusNameFlag
BusNameFlagAllowReplacement = Int
1
fromEnum BusNameFlag
BusNameFlagReplaceExisting = Int
2
fromEnum BusNameFlag
BusNameFlagDoNotQueue = Int
4
fromEnum (AnotherBusNameFlag Int
k) = Int
k
toEnum :: Int -> BusNameFlag
toEnum Int
1 = BusNameFlag
BusNameFlagAllowReplacement
toEnum Int
2 = BusNameFlag
BusNameFlagReplaceExisting
toEnum Int
4 = BusNameFlag
BusNameFlagDoNotQueue
toEnum Int
k = Int -> BusNameFlag
AnotherBusNameFlag Int
k
instance P.Ord BusNameFlag where
compare :: BusNameFlag -> BusNameFlag -> Ordering
compare BusNameFlag
a BusNameFlag
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BusNameFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameFlag
a) (BusNameFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameFlag
b)
type instance O.ParentTypes BusNameFlag = '[]
instance O.HasParentTypes BusNameFlag
foreign import ccall "ibus_bus_name_flag_get_type" c_ibus_bus_name_flag_get_type ::
IO GType
instance B.Types.TypedObject BusNameFlag where
glibType :: IO GType
glibType = IO GType
c_ibus_bus_name_flag_get_type
instance B.Types.BoxedFlags BusNameFlag
instance IsGFlag BusNameFlag