#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Wnck.Enums
(
ClientType(..) ,
LayoutCorner_(..) ,
LayoutOrientation_(..) ,
MotionDirection(..) ,
PagerDisplayMode(..) ,
TasklistGroupingType(..) ,
WindowGravity(..) ,
WindowType(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified 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
data LayoutOrientation_ =
LayoutOrientationHorizontal_
| LayoutOrientationVertical_
| AnotherLayoutOrientation_ Int
deriving (Int -> LayoutOrientation_ -> ShowS
[LayoutOrientation_] -> ShowS
LayoutOrientation_ -> String
(Int -> LayoutOrientation_ -> ShowS)
-> (LayoutOrientation_ -> String)
-> ([LayoutOrientation_] -> ShowS)
-> Show LayoutOrientation_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LayoutOrientation_] -> ShowS
$cshowList :: [LayoutOrientation_] -> ShowS
show :: LayoutOrientation_ -> String
$cshow :: LayoutOrientation_ -> String
showsPrec :: Int -> LayoutOrientation_ -> ShowS
$cshowsPrec :: Int -> LayoutOrientation_ -> ShowS
Show, LayoutOrientation_ -> LayoutOrientation_ -> Bool
(LayoutOrientation_ -> LayoutOrientation_ -> Bool)
-> (LayoutOrientation_ -> LayoutOrientation_ -> Bool)
-> Eq LayoutOrientation_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LayoutOrientation_ -> LayoutOrientation_ -> Bool
$c/= :: LayoutOrientation_ -> LayoutOrientation_ -> Bool
== :: LayoutOrientation_ -> LayoutOrientation_ -> Bool
$c== :: LayoutOrientation_ -> LayoutOrientation_ -> Bool
Eq)
instance P.Enum LayoutOrientation_ where
fromEnum :: LayoutOrientation_ -> Int
fromEnum LayoutOrientationHorizontal_ = 0
fromEnum LayoutOrientationVertical_ = 1
fromEnum (AnotherLayoutOrientation_ k :: Int
k) = Int
k
toEnum :: Int -> LayoutOrientation_
toEnum 0 = LayoutOrientation_
LayoutOrientationHorizontal_
toEnum 1 = LayoutOrientation_
LayoutOrientationVertical_
toEnum k :: Int
k = Int -> LayoutOrientation_
AnotherLayoutOrientation_ Int
k
instance P.Ord LayoutOrientation_ where
compare :: LayoutOrientation_ -> LayoutOrientation_ -> Ordering
compare a :: LayoutOrientation_
a b :: LayoutOrientation_
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LayoutOrientation_ -> Int
forall a. Enum a => a -> Int
P.fromEnum LayoutOrientation_
a) (LayoutOrientation_ -> Int
forall a. Enum a => a -> Int
P.fromEnum LayoutOrientation_
b)
data LayoutCorner_ =
LayoutCornerTopleft_
| LayoutCornerTopright_
| LayoutCornerBottomright_
| LayoutCornerBottomleft_
| AnotherLayoutCorner_ Int
deriving (Int -> LayoutCorner_ -> ShowS
[LayoutCorner_] -> ShowS
LayoutCorner_ -> String
(Int -> LayoutCorner_ -> ShowS)
-> (LayoutCorner_ -> String)
-> ([LayoutCorner_] -> ShowS)
-> Show LayoutCorner_
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LayoutCorner_] -> ShowS
$cshowList :: [LayoutCorner_] -> ShowS
show :: LayoutCorner_ -> String
$cshow :: LayoutCorner_ -> String
showsPrec :: Int -> LayoutCorner_ -> ShowS
$cshowsPrec :: Int -> LayoutCorner_ -> ShowS
Show, LayoutCorner_ -> LayoutCorner_ -> Bool
(LayoutCorner_ -> LayoutCorner_ -> Bool)
-> (LayoutCorner_ -> LayoutCorner_ -> Bool) -> Eq LayoutCorner_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LayoutCorner_ -> LayoutCorner_ -> Bool
$c/= :: LayoutCorner_ -> LayoutCorner_ -> Bool
== :: LayoutCorner_ -> LayoutCorner_ -> Bool
$c== :: LayoutCorner_ -> LayoutCorner_ -> Bool
Eq)
instance P.Enum LayoutCorner_ where
fromEnum :: LayoutCorner_ -> Int
fromEnum LayoutCornerTopleft_ = 0
fromEnum LayoutCornerTopright_ = 1
fromEnum LayoutCornerBottomright_ = 2
fromEnum LayoutCornerBottomleft_ = 3
fromEnum (AnotherLayoutCorner_ k :: Int
k) = Int
k
toEnum :: Int -> LayoutCorner_
toEnum 0 = LayoutCorner_
LayoutCornerTopleft_
toEnum 1 = LayoutCorner_
LayoutCornerTopright_
toEnum 2 = LayoutCorner_
LayoutCornerBottomright_
toEnum 3 = LayoutCorner_
LayoutCornerBottomleft_
toEnum k :: Int
k = Int -> LayoutCorner_
AnotherLayoutCorner_ Int
k
instance P.Ord LayoutCorner_ where
compare :: LayoutCorner_ -> LayoutCorner_ -> Ordering
compare a :: LayoutCorner_
a b :: LayoutCorner_
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LayoutCorner_ -> Int
forall a. Enum a => a -> Int
P.fromEnum LayoutCorner_
a) (LayoutCorner_ -> Int
forall a. Enum a => a -> Int
P.fromEnum LayoutCorner_
b)
data WindowType =
WindowTypeNormal
| WindowTypeDesktop
| WindowTypeDock
| WindowTypeDialog
| WindowTypeToolbar
|
| WindowTypeUtility
| WindowTypeSplashscreen
| AnotherWindowType Int
deriving (Int -> WindowType -> ShowS
[WindowType] -> ShowS
WindowType -> String
(Int -> WindowType -> ShowS)
-> (WindowType -> String)
-> ([WindowType] -> ShowS)
-> Show WindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowType] -> ShowS
$cshowList :: [WindowType] -> ShowS
show :: WindowType -> String
$cshow :: WindowType -> String
showsPrec :: Int -> WindowType -> ShowS
$cshowsPrec :: Int -> WindowType -> ShowS
Show, WindowType -> WindowType -> Bool
(WindowType -> WindowType -> Bool)
-> (WindowType -> WindowType -> Bool) -> Eq WindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowType -> WindowType -> Bool
$c/= :: WindowType -> WindowType -> Bool
== :: WindowType -> WindowType -> Bool
$c== :: WindowType -> WindowType -> Bool
Eq)
instance P.Enum WindowType where
fromEnum :: WindowType -> Int
fromEnum WindowTypeNormal = 0
fromEnum WindowTypeDesktop = 1
fromEnum WindowTypeDock = 2
fromEnum WindowTypeDialog = 3
fromEnum WindowTypeToolbar = 4
fromEnum WindowTypeMenu = 5
fromEnum WindowTypeUtility = 6
fromEnum WindowTypeSplashscreen = 7
fromEnum (AnotherWindowType k :: Int
k) = Int
k
toEnum :: Int -> WindowType
toEnum 0 = WindowType
WindowTypeNormal
toEnum 1 = WindowType
WindowTypeDesktop
toEnum 2 = WindowType
WindowTypeDock
toEnum 3 = WindowType
WindowTypeDialog
toEnum 4 = WindowType
WindowTypeToolbar
toEnum 5 = WindowType
WindowTypeMenu
toEnum 6 = WindowType
WindowTypeUtility
toEnum 7 = WindowType
WindowTypeSplashscreen
toEnum k :: Int
k = Int -> WindowType
AnotherWindowType Int
k
instance P.Ord WindowType where
compare :: WindowType -> WindowType -> Ordering
compare a :: WindowType
a b :: WindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
a) (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
b)
foreign import ccall "wnck_window_type_get_type" c_wnck_window_type_get_type ::
IO GType
instance BoxedEnum WindowType where
boxedEnumType :: WindowType -> IO GType
boxedEnumType _ = IO GType
c_wnck_window_type_get_type
data WindowGravity =
WindowGravityCurrent
| WindowGravityNorthwest
| WindowGravityNorth
| WindowGravityNortheast
| WindowGravityWest
| WindowGravityCenter
| WindowGravityEast
| WindowGravitySouthwest
| WindowGravitySouth
| WindowGravitySoutheast
| WindowGravityStatic
| AnotherWindowGravity Int
deriving (Int -> WindowGravity -> ShowS
[WindowGravity] -> ShowS
WindowGravity -> String
(Int -> WindowGravity -> ShowS)
-> (WindowGravity -> String)
-> ([WindowGravity] -> ShowS)
-> Show WindowGravity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowGravity] -> ShowS
$cshowList :: [WindowGravity] -> ShowS
show :: WindowGravity -> String
$cshow :: WindowGravity -> String
showsPrec :: Int -> WindowGravity -> ShowS
$cshowsPrec :: Int -> WindowGravity -> ShowS
Show, WindowGravity -> WindowGravity -> Bool
(WindowGravity -> WindowGravity -> Bool)
-> (WindowGravity -> WindowGravity -> Bool) -> Eq WindowGravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowGravity -> WindowGravity -> Bool
$c/= :: WindowGravity -> WindowGravity -> Bool
== :: WindowGravity -> WindowGravity -> Bool
$c== :: WindowGravity -> WindowGravity -> Bool
Eq)
instance P.Enum WindowGravity where
fromEnum :: WindowGravity -> Int
fromEnum WindowGravityCurrent = 0
fromEnum WindowGravityNorthwest = 1
fromEnum WindowGravityNorth = 2
fromEnum WindowGravityNortheast = 3
fromEnum WindowGravityWest = 4
fromEnum WindowGravityCenter = 5
fromEnum WindowGravityEast = 6
fromEnum WindowGravitySouthwest = 7
fromEnum WindowGravitySouth = 8
fromEnum WindowGravitySoutheast = 9
fromEnum WindowGravityStatic = 10
fromEnum (AnotherWindowGravity k :: Int
k) = Int
k
toEnum :: Int -> WindowGravity
toEnum 0 = WindowGravity
WindowGravityCurrent
toEnum 1 = WindowGravity
WindowGravityNorthwest
toEnum 2 = WindowGravity
WindowGravityNorth
toEnum 3 = WindowGravity
WindowGravityNortheast
toEnum 4 = WindowGravity
WindowGravityWest
toEnum 5 = WindowGravity
WindowGravityCenter
toEnum 6 = WindowGravity
WindowGravityEast
toEnum 7 = WindowGravity
WindowGravitySouthwest
toEnum 8 = WindowGravity
WindowGravitySouth
toEnum 9 = WindowGravity
WindowGravitySoutheast
toEnum 10 = WindowGravity
WindowGravityStatic
toEnum k :: Int
k = Int -> WindowGravity
AnotherWindowGravity Int
k
instance P.Ord WindowGravity where
compare :: WindowGravity -> WindowGravity -> Ordering
compare a :: WindowGravity
a b :: WindowGravity
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowGravity -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowGravity
a) (WindowGravity -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowGravity
b)
foreign import ccall "wnck_window_gravity_get_type" c_wnck_window_gravity_get_type ::
IO GType
instance BoxedEnum WindowGravity where
boxedEnumType :: WindowGravity -> IO GType
boxedEnumType _ = IO GType
c_wnck_window_gravity_get_type
data TasklistGroupingType =
TasklistGroupingTypeNeverGroup
| TasklistGroupingTypeAutoGroup
| TasklistGroupingTypeAlwaysGroup
| AnotherTasklistGroupingType Int
deriving (Int -> TasklistGroupingType -> ShowS
[TasklistGroupingType] -> ShowS
TasklistGroupingType -> String
(Int -> TasklistGroupingType -> ShowS)
-> (TasklistGroupingType -> String)
-> ([TasklistGroupingType] -> ShowS)
-> Show TasklistGroupingType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TasklistGroupingType] -> ShowS
$cshowList :: [TasklistGroupingType] -> ShowS
show :: TasklistGroupingType -> String
$cshow :: TasklistGroupingType -> String
showsPrec :: Int -> TasklistGroupingType -> ShowS
$cshowsPrec :: Int -> TasklistGroupingType -> ShowS
Show, TasklistGroupingType -> TasklistGroupingType -> Bool
(TasklistGroupingType -> TasklistGroupingType -> Bool)
-> (TasklistGroupingType -> TasklistGroupingType -> Bool)
-> Eq TasklistGroupingType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TasklistGroupingType -> TasklistGroupingType -> Bool
$c/= :: TasklistGroupingType -> TasklistGroupingType -> Bool
== :: TasklistGroupingType -> TasklistGroupingType -> Bool
$c== :: TasklistGroupingType -> TasklistGroupingType -> Bool
Eq)
instance P.Enum TasklistGroupingType where
fromEnum :: TasklistGroupingType -> Int
fromEnum TasklistGroupingTypeNeverGroup = 0
fromEnum TasklistGroupingTypeAutoGroup = 1
fromEnum TasklistGroupingTypeAlwaysGroup = 2
fromEnum (AnotherTasklistGroupingType k :: Int
k) = Int
k
toEnum :: Int -> TasklistGroupingType
toEnum 0 = TasklistGroupingType
TasklistGroupingTypeNeverGroup
toEnum 1 = TasklistGroupingType
TasklistGroupingTypeAutoGroup
toEnum 2 = TasklistGroupingType
TasklistGroupingTypeAlwaysGroup
toEnum k :: Int
k = Int -> TasklistGroupingType
AnotherTasklistGroupingType Int
k
instance P.Ord TasklistGroupingType where
compare :: TasklistGroupingType -> TasklistGroupingType -> Ordering
compare a :: TasklistGroupingType
a b :: TasklistGroupingType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TasklistGroupingType -> Int
forall a. Enum a => a -> Int
P.fromEnum TasklistGroupingType
a) (TasklistGroupingType -> Int
forall a. Enum a => a -> Int
P.fromEnum TasklistGroupingType
b)
foreign import ccall "wnck_tasklist_grouping_type_get_type" c_wnck_tasklist_grouping_type_get_type ::
IO GType
instance BoxedEnum TasklistGroupingType where
boxedEnumType :: TasklistGroupingType -> IO GType
boxedEnumType _ = IO GType
c_wnck_tasklist_grouping_type_get_type
data =
|
| Int
deriving (Int -> PagerDisplayMode -> ShowS
[PagerDisplayMode] -> ShowS
PagerDisplayMode -> String
(Int -> PagerDisplayMode -> ShowS)
-> (PagerDisplayMode -> String)
-> ([PagerDisplayMode] -> ShowS)
-> Show PagerDisplayMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PagerDisplayMode] -> ShowS
$cshowList :: [PagerDisplayMode] -> ShowS
show :: PagerDisplayMode -> String
$cshow :: PagerDisplayMode -> String
showsPrec :: Int -> PagerDisplayMode -> ShowS
$cshowsPrec :: Int -> PagerDisplayMode -> ShowS
Show, PagerDisplayMode -> PagerDisplayMode -> Bool
(PagerDisplayMode -> PagerDisplayMode -> Bool)
-> (PagerDisplayMode -> PagerDisplayMode -> Bool)
-> Eq PagerDisplayMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PagerDisplayMode -> PagerDisplayMode -> Bool
$c/= :: PagerDisplayMode -> PagerDisplayMode -> Bool
== :: PagerDisplayMode -> PagerDisplayMode -> Bool
$c== :: PagerDisplayMode -> PagerDisplayMode -> Bool
Eq)
instance P.Enum PagerDisplayMode where
fromEnum :: PagerDisplayMode -> Int
fromEnum PagerDisplayModeName = 0
fromEnum PagerDisplayModeContent = 1
fromEnum (AnotherPagerDisplayMode k :: Int
k) = Int
k
toEnum :: Int -> PagerDisplayMode
toEnum 0 = PagerDisplayMode
PagerDisplayModeName
toEnum 1 = PagerDisplayMode
PagerDisplayModeContent
toEnum k :: Int
k = Int -> PagerDisplayMode
AnotherPagerDisplayMode Int
k
instance P.Ord PagerDisplayMode where
compare :: PagerDisplayMode -> PagerDisplayMode -> Ordering
compare a :: PagerDisplayMode
a b :: PagerDisplayMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PagerDisplayMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PagerDisplayMode
a) (PagerDisplayMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PagerDisplayMode
b)
foreign import ccall "wnck_pager_display_mode_get_type" ::
IO GType
instance BoxedEnum PagerDisplayMode where
boxedEnumType :: PagerDisplayMode -> IO GType
boxedEnumType _ = IO GType
c_wnck_pager_display_mode_get_type
data MotionDirection =
MotionDirectionUp
| MotionDirectionDown
| MotionDirectionLeft
| MotionDirectionRight
| AnotherMotionDirection Int
deriving (Int -> MotionDirection -> ShowS
[MotionDirection] -> ShowS
MotionDirection -> String
(Int -> MotionDirection -> ShowS)
-> (MotionDirection -> String)
-> ([MotionDirection] -> ShowS)
-> Show MotionDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MotionDirection] -> ShowS
$cshowList :: [MotionDirection] -> ShowS
show :: MotionDirection -> String
$cshow :: MotionDirection -> String
showsPrec :: Int -> MotionDirection -> ShowS
$cshowsPrec :: Int -> MotionDirection -> ShowS
Show, MotionDirection -> MotionDirection -> Bool
(MotionDirection -> MotionDirection -> Bool)
-> (MotionDirection -> MotionDirection -> Bool)
-> Eq MotionDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MotionDirection -> MotionDirection -> Bool
$c/= :: MotionDirection -> MotionDirection -> Bool
== :: MotionDirection -> MotionDirection -> Bool
$c== :: MotionDirection -> MotionDirection -> Bool
Eq)
instance P.Enum MotionDirection where
fromEnum :: MotionDirection -> Int
fromEnum MotionDirectionUp = -1
fromEnum MotionDirectionDown = -2
fromEnum MotionDirectionLeft = -3
fromEnum MotionDirectionRight = -4
fromEnum (AnotherMotionDirection k :: Int
k) = Int
k
toEnum :: Int -> MotionDirection
toEnum -1 = MotionDirection
MotionDirectionUp
toEnum -2 = MotionDirection
MotionDirectionDown
toEnum -3 = MotionDirection
MotionDirectionLeft
toEnum -4 = MotionDirection
MotionDirectionRight
toEnum k :: Int
k = Int -> MotionDirection
AnotherMotionDirection Int
k
instance P.Ord MotionDirection where
compare :: MotionDirection -> MotionDirection -> Ordering
compare a :: MotionDirection
a b :: MotionDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MotionDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum MotionDirection
a) (MotionDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum MotionDirection
b)
foreign import ccall "wnck_motion_direction_get_type" c_wnck_motion_direction_get_type ::
IO GType
instance BoxedEnum MotionDirection where
boxedEnumType :: MotionDirection -> IO GType
boxedEnumType _ = IO GType
c_wnck_motion_direction_get_type
data ClientType =
ClientTypeApplication
|
| AnotherClientType Int
deriving (Int -> ClientType -> ShowS
[ClientType] -> ShowS
ClientType -> String
(Int -> ClientType -> ShowS)
-> (ClientType -> String)
-> ([ClientType] -> ShowS)
-> Show ClientType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClientType] -> ShowS
$cshowList :: [ClientType] -> ShowS
show :: ClientType -> String
$cshow :: ClientType -> String
showsPrec :: Int -> ClientType -> ShowS
$cshowsPrec :: Int -> ClientType -> ShowS
Show, ClientType -> ClientType -> Bool
(ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> Bool) -> Eq ClientType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClientType -> ClientType -> Bool
$c/= :: ClientType -> ClientType -> Bool
== :: ClientType -> ClientType -> Bool
$c== :: ClientType -> ClientType -> Bool
Eq)
instance P.Enum ClientType where
fromEnum :: ClientType -> Int
fromEnum ClientTypeApplication = 1
fromEnum ClientTypePager = 2
fromEnum (AnotherClientType k :: Int
k) = Int
k
toEnum :: Int -> ClientType
toEnum 1 = ClientType
ClientTypeApplication
toEnum 2 = ClientType
ClientTypePager
toEnum k :: Int
k = Int -> ClientType
AnotherClientType Int
k
instance P.Ord ClientType where
compare :: ClientType -> ClientType -> Ordering
compare a :: ClientType
a b :: ClientType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ClientType -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientType
a) (ClientType -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientType
b)
foreign import ccall "wnck_client_type_get_type" c_wnck_client_type_get_type ::
IO GType
instance BoxedEnum ClientType where
boxedEnumType :: ClientType -> IO GType
boxedEnumType _ = IO GType
c_wnck_client_type_get_type