-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Wnck.Enums
    ( 

 -- * Enumerations
-- ** ClientType #enum:ClientType#

    ClientType(..)                          ,


-- ** LayoutCorner_ #enum:LayoutCorner_#

    LayoutCorner_(..)                       ,


-- ** LayoutOrientation_ #enum:LayoutOrientation_#

    LayoutOrientation_(..)                  ,


-- ** MotionDirection #enum:MotionDirection#

    MotionDirection(..)                     ,


-- ** PagerDisplayMode #enum:PagerDisplayMode#

    PagerDisplayMode(..)                    ,


-- ** PagerScrollMode #enum:PagerScrollMode#

    PagerScrollMode(..)                     ,


-- ** TasklistGroupingType #enum:TasklistGroupingType#

    TasklistGroupingType(..)                ,


-- ** WindowGravity #enum:WindowGravity#

    WindowGravity(..)                       ,


-- ** WindowType #enum:WindowType#

    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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum _LayoutOrientation
-- | /No description available in the introspection data./
data LayoutOrientation_ = 
      LayoutOrientationHorizontal_
    -- ^ /No description available in the introspection data./
    | LayoutOrientationVertical_
    -- ^ /No description available in the introspection data./
    | AnotherLayoutOrientation_ Int
    -- ^ Catch-all for unknown values
    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 LayoutOrientation_
LayoutOrientationHorizontal_ = Int
0
    fromEnum LayoutOrientation_
LayoutOrientationVertical_ = Int
1
    fromEnum (AnotherLayoutOrientation_ Int
k) = Int
k

    toEnum :: Int -> LayoutOrientation_
toEnum Int
0 = LayoutOrientation_
LayoutOrientationHorizontal_
    toEnum Int
1 = LayoutOrientation_
LayoutOrientationVertical_
    toEnum Int
k = Int -> LayoutOrientation_
AnotherLayoutOrientation_ Int
k

instance P.Ord LayoutOrientation_ where
    compare :: LayoutOrientation_ -> LayoutOrientation_ -> Ordering
compare LayoutOrientation_
a 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)

-- Enum _LayoutCorner
-- | /No description available in the introspection data./
data LayoutCorner_ = 
      LayoutCornerTopleft_
    -- ^ /No description available in the introspection data./
    | LayoutCornerTopright_
    -- ^ /No description available in the introspection data./
    | LayoutCornerBottomright_
    -- ^ /No description available in the introspection data./
    | LayoutCornerBottomleft_
    -- ^ /No description available in the introspection data./
    | AnotherLayoutCorner_ Int
    -- ^ Catch-all for unknown values
    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 LayoutCorner_
LayoutCornerTopleft_ = Int
0
    fromEnum LayoutCorner_
LayoutCornerTopright_ = Int
1
    fromEnum LayoutCorner_
LayoutCornerBottomright_ = Int
2
    fromEnum LayoutCorner_
LayoutCornerBottomleft_ = Int
3
    fromEnum (AnotherLayoutCorner_ Int
k) = Int
k

    toEnum :: Int -> LayoutCorner_
toEnum Int
0 = LayoutCorner_
LayoutCornerTopleft_
    toEnum Int
1 = LayoutCorner_
LayoutCornerTopright_
    toEnum Int
2 = LayoutCorner_
LayoutCornerBottomright_
    toEnum Int
3 = LayoutCorner_
LayoutCornerBottomleft_
    toEnum Int
k = Int -> LayoutCorner_
AnotherLayoutCorner_ Int
k

instance P.Ord LayoutCorner_ where
    compare :: LayoutCorner_ -> LayoutCorner_ -> Ordering
compare LayoutCorner_
a 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)

-- Enum WindowType
-- | Type describing the semantic type of a t'GI.Wnck.Objects.Window.Window'.
data WindowType = 
      WindowTypeNormal
    -- ^ the window is a normal window.
    | WindowTypeDesktop
    -- ^ the window is a desktop.
    | WindowTypeDock
    -- ^ the window is a dock or a panel.
    | WindowTypeDialog
    -- ^ the window is a dialog window.
    | WindowTypeToolbar
    -- ^ the window is a tearoff toolbar.
    | WindowTypeMenu
    -- ^ the window is a tearoff menu.
    | WindowTypeUtility
    -- ^ the window is a small persistent utility window, such
    -- as a palette or toolbox.
    | WindowTypeSplashscreen
    -- ^ the window is a splash screen displayed as an
    -- application is starting up.
    | AnotherWindowType Int
    -- ^ Catch-all for unknown values
    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 WindowType
WindowTypeNormal = Int
0
    fromEnum WindowType
WindowTypeDesktop = Int
1
    fromEnum WindowType
WindowTypeDock = Int
2
    fromEnum WindowType
WindowTypeDialog = Int
3
    fromEnum WindowType
WindowTypeToolbar = Int
4
    fromEnum WindowType
WindowTypeMenu = Int
5
    fromEnum WindowType
WindowTypeUtility = Int
6
    fromEnum WindowType
WindowTypeSplashscreen = Int
7
    fromEnum (AnotherWindowType Int
k) = Int
k

    toEnum :: Int -> WindowType
toEnum Int
0 = WindowType
WindowTypeNormal
    toEnum Int
1 = WindowType
WindowTypeDesktop
    toEnum Int
2 = WindowType
WindowTypeDock
    toEnum Int
3 = WindowType
WindowTypeDialog
    toEnum Int
4 = WindowType
WindowTypeToolbar
    toEnum Int
5 = WindowType
WindowTypeMenu
    toEnum Int
6 = WindowType
WindowTypeUtility
    toEnum Int
7 = WindowType
WindowTypeSplashscreen
    toEnum Int
k = Int -> WindowType
AnotherWindowType Int
k

instance P.Ord WindowType where
    compare :: WindowType -> WindowType -> Ordering
compare WindowType
a 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)

type instance O.ParentTypes WindowType = '[]
instance O.HasParentTypes WindowType

foreign import ccall "wnck_window_type_get_type" c_wnck_window_type_get_type :: 
    IO GType

instance B.Types.TypedObject WindowType where
    glibType :: IO GType
glibType = IO GType
c_wnck_window_type_get_type

instance B.Types.BoxedEnum WindowType

-- Enum WindowGravity
-- | Flag used when changing the geometry of a t'GI.Wnck.Objects.Window.Window'. This is the gravity
-- point to use as a reference for the new position.
-- 
-- /Since: 2.16/
data WindowGravity = 
      WindowGravityCurrent
    -- ^ keep the current gravity point.
    | WindowGravityNorthwest
    -- ^ use the left top corner of the frame window
    -- as gravity point.
    | WindowGravityNorth
    -- ^ use the center of the frame window\'s top side as
    -- gravity point.
    | WindowGravityNortheast
    -- ^ use the right top corner of the frame window
    -- as gravity point.
    | WindowGravityWest
    -- ^ use the center of the frame window\'s left side as
    -- gravity point.
    | WindowGravityCenter
    -- ^ use the center of the frame window as gravity
    -- point.
    | WindowGravityEast
    -- ^ use the center of the frame window\'s right side
    -- as gravity point.
    | WindowGravitySouthwest
    -- ^ use the left bottom corner of the frame
    -- window as gravity point.
    | WindowGravitySouth
    -- ^ use the center of the frame window\'s bottom side
    -- as gravity point.
    | WindowGravitySoutheast
    -- ^ use the right bottom corner of the frame
    -- window as gravity point.
    | WindowGravityStatic
    -- ^ use the left top corner of the client window as
    -- gravity point.
    | AnotherWindowGravity Int
    -- ^ Catch-all for unknown values
    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 WindowGravity
WindowGravityCurrent = Int
0
    fromEnum WindowGravity
WindowGravityNorthwest = Int
1
    fromEnum WindowGravity
WindowGravityNorth = Int
2
    fromEnum WindowGravity
WindowGravityNortheast = Int
3
    fromEnum WindowGravity
WindowGravityWest = Int
4
    fromEnum WindowGravity
WindowGravityCenter = Int
5
    fromEnum WindowGravity
WindowGravityEast = Int
6
    fromEnum WindowGravity
WindowGravitySouthwest = Int
7
    fromEnum WindowGravity
WindowGravitySouth = Int
8
    fromEnum WindowGravity
WindowGravitySoutheast = Int
9
    fromEnum WindowGravity
WindowGravityStatic = Int
10
    fromEnum (AnotherWindowGravity Int
k) = Int
k

    toEnum :: Int -> WindowGravity
toEnum Int
0 = WindowGravity
WindowGravityCurrent
    toEnum Int
1 = WindowGravity
WindowGravityNorthwest
    toEnum Int
2 = WindowGravity
WindowGravityNorth
    toEnum Int
3 = WindowGravity
WindowGravityNortheast
    toEnum Int
4 = WindowGravity
WindowGravityWest
    toEnum Int
5 = WindowGravity
WindowGravityCenter
    toEnum Int
6 = WindowGravity
WindowGravityEast
    toEnum Int
7 = WindowGravity
WindowGravitySouthwest
    toEnum Int
8 = WindowGravity
WindowGravitySouth
    toEnum Int
9 = WindowGravity
WindowGravitySoutheast
    toEnum Int
10 = WindowGravity
WindowGravityStatic
    toEnum Int
k = Int -> WindowGravity
AnotherWindowGravity Int
k

instance P.Ord WindowGravity where
    compare :: WindowGravity -> WindowGravity -> Ordering
compare WindowGravity
a 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)

type instance O.ParentTypes WindowGravity = '[]
instance O.HasParentTypes WindowGravity

foreign import ccall "wnck_window_gravity_get_type" c_wnck_window_gravity_get_type :: 
    IO GType

instance B.Types.TypedObject WindowGravity where
    glibType :: IO GType
glibType = IO GType
c_wnck_window_gravity_get_type

instance B.Types.BoxedEnum WindowGravity

-- Enum TasklistGroupingType
-- | Type defining the policy of the t'GI.Wnck.Objects.Tasklist.Tasklist' for grouping multiple
-- t'GI.Wnck.Objects.Window.Window' of the same t'GI.Wnck.Objects.Application.Application'.
data TasklistGroupingType = 
      TasklistGroupingTypeNeverGroup
    -- ^ never group multiple t'GI.Wnck.Objects.Window.Window' of the same
    -- t'GI.Wnck.Objects.Application.Application'.
    | TasklistGroupingTypeAutoGroup
    -- ^ group multiple t'GI.Wnck.Objects.Window.Window' of the same
    -- t'GI.Wnck.Objects.Application.Application' for some t'GI.Wnck.Objects.Application.Application', when there is not enough place
    -- to have a good-looking list of all t'GI.Wnck.Objects.Window.Window'.
    | TasklistGroupingTypeAlwaysGroup
    -- ^ always group multiple t'GI.Wnck.Objects.Window.Window' of the same
    -- t'GI.Wnck.Objects.Application.Application', for all t'GI.Wnck.Objects.Application.Application'.
    | AnotherTasklistGroupingType Int
    -- ^ Catch-all for unknown values
    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 TasklistGroupingType
TasklistGroupingTypeNeverGroup = Int
0
    fromEnum TasklistGroupingType
TasklistGroupingTypeAutoGroup = Int
1
    fromEnum TasklistGroupingType
TasklistGroupingTypeAlwaysGroup = Int
2
    fromEnum (AnotherTasklistGroupingType Int
k) = Int
k

    toEnum :: Int -> TasklistGroupingType
toEnum Int
0 = TasklistGroupingType
TasklistGroupingTypeNeverGroup
    toEnum Int
1 = TasklistGroupingType
TasklistGroupingTypeAutoGroup
    toEnum Int
2 = TasklistGroupingType
TasklistGroupingTypeAlwaysGroup
    toEnum Int
k = Int -> TasklistGroupingType
AnotherTasklistGroupingType Int
k

instance P.Ord TasklistGroupingType where
    compare :: TasklistGroupingType -> TasklistGroupingType -> Ordering
compare TasklistGroupingType
a 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)

type instance O.ParentTypes TasklistGroupingType = '[]
instance O.HasParentTypes TasklistGroupingType

foreign import ccall "wnck_tasklist_grouping_type_get_type" c_wnck_tasklist_grouping_type_get_type :: 
    IO GType

instance B.Types.TypedObject TasklistGroupingType where
    glibType :: IO GType
glibType = IO GType
c_wnck_tasklist_grouping_type_get_type

instance B.Types.BoxedEnum TasklistGroupingType

-- Enum PagerScrollMode
-- | Mode defining in which order scrolling on a t'GI.Wnck.Objects.Pager.Pager' will cycle through workspaces.
data PagerScrollMode = 
      PagerScrollMode2d
    -- ^ given that the workspaces are set up in multiple rows,
    -- scrolling on the t'GI.Wnck.Objects.Pager.Pager' will cycle through the workspaces as if on a
    -- 2-dimensional map. Example cycling order with 2 rows and 4 workspaces: 1 3 2 4.
    | PagerScrollMode1d
    -- ^ the t'GI.Wnck.Objects.Pager.Pager' will always cycle workspaces in a linear
    -- manner, irrespective of how many rows are configured. (Hint: Better for mice)
    -- Example cycling order with 2 rows and 4 workspaces: 1 2 3 4.
    | AnotherPagerScrollMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PagerScrollMode -> ShowS
[PagerScrollMode] -> ShowS
PagerScrollMode -> String
(Int -> PagerScrollMode -> ShowS)
-> (PagerScrollMode -> String)
-> ([PagerScrollMode] -> ShowS)
-> Show PagerScrollMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PagerScrollMode] -> ShowS
$cshowList :: [PagerScrollMode] -> ShowS
show :: PagerScrollMode -> String
$cshow :: PagerScrollMode -> String
showsPrec :: Int -> PagerScrollMode -> ShowS
$cshowsPrec :: Int -> PagerScrollMode -> ShowS
Show, PagerScrollMode -> PagerScrollMode -> Bool
(PagerScrollMode -> PagerScrollMode -> Bool)
-> (PagerScrollMode -> PagerScrollMode -> Bool)
-> Eq PagerScrollMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PagerScrollMode -> PagerScrollMode -> Bool
$c/= :: PagerScrollMode -> PagerScrollMode -> Bool
== :: PagerScrollMode -> PagerScrollMode -> Bool
$c== :: PagerScrollMode -> PagerScrollMode -> Bool
Eq)

instance P.Enum PagerScrollMode where
    fromEnum :: PagerScrollMode -> Int
fromEnum PagerScrollMode
PagerScrollMode2d = Int
0
    fromEnum PagerScrollMode
PagerScrollMode1d = Int
1
    fromEnum (AnotherPagerScrollMode Int
k) = Int
k

    toEnum :: Int -> PagerScrollMode
toEnum Int
0 = PagerScrollMode
PagerScrollMode2d
    toEnum Int
1 = PagerScrollMode
PagerScrollMode1d
    toEnum Int
k = Int -> PagerScrollMode
AnotherPagerScrollMode Int
k

instance P.Ord PagerScrollMode where
    compare :: PagerScrollMode -> PagerScrollMode -> Ordering
compare PagerScrollMode
a PagerScrollMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PagerScrollMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PagerScrollMode
a) (PagerScrollMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PagerScrollMode
b)

type instance O.ParentTypes PagerScrollMode = '[]
instance O.HasParentTypes PagerScrollMode

foreign import ccall "wnck_pager_scroll_mode_get_type" c_wnck_pager_scroll_mode_get_type :: 
    IO GType

instance B.Types.TypedObject PagerScrollMode where
    glibType :: IO GType
glibType = IO GType
c_wnck_pager_scroll_mode_get_type

instance B.Types.BoxedEnum PagerScrollMode

-- Enum PagerDisplayMode
-- | Mode defining what a t'GI.Wnck.Objects.Pager.Pager' will display.
data PagerDisplayMode = 
      PagerDisplayModeName
    -- ^ the t'GI.Wnck.Objects.Pager.Pager' will only display the names of the
    -- workspaces.
    | PagerDisplayModeContent
    -- ^ the t'GI.Wnck.Objects.Pager.Pager' will display a representation
    -- for each window in the workspaces.
    | AnotherPagerDisplayMode Int
    -- ^ Catch-all for unknown values
    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 PagerDisplayMode
PagerDisplayModeName = Int
0
    fromEnum PagerDisplayMode
PagerDisplayModeContent = Int
1
    fromEnum (AnotherPagerDisplayMode Int
k) = Int
k

    toEnum :: Int -> PagerDisplayMode
toEnum Int
0 = PagerDisplayMode
PagerDisplayModeName
    toEnum Int
1 = PagerDisplayMode
PagerDisplayModeContent
    toEnum Int
k = Int -> PagerDisplayMode
AnotherPagerDisplayMode Int
k

instance P.Ord PagerDisplayMode where
    compare :: PagerDisplayMode -> PagerDisplayMode -> Ordering
compare PagerDisplayMode
a 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)

type instance O.ParentTypes PagerDisplayMode = '[]
instance O.HasParentTypes PagerDisplayMode

foreign import ccall "wnck_pager_display_mode_get_type" c_wnck_pager_display_mode_get_type :: 
    IO GType

instance B.Types.TypedObject PagerDisplayMode where
    glibType :: IO GType
glibType = IO GType
c_wnck_pager_display_mode_get_type

instance B.Types.BoxedEnum PagerDisplayMode

-- Enum MotionDirection
-- | Type defining a direction in which to search a neighbor t'GI.Wnck.Objects.Workspace.Workspace'.
-- 
-- /Since: 2.14/
data MotionDirection = 
      MotionDirectionUp
    -- ^ search a neighbor t'GI.Wnck.Objects.Workspace.Workspace' above another
    -- t'GI.Wnck.Objects.Workspace.Workspace'.
    | MotionDirectionDown
    -- ^ search a neighbor t'GI.Wnck.Objects.Workspace.Workspace' below another
    -- t'GI.Wnck.Objects.Workspace.Workspace'.
    | MotionDirectionLeft
    -- ^ search a neighbor t'GI.Wnck.Objects.Workspace.Workspace' at the left of another
    -- t'GI.Wnck.Objects.Workspace.Workspace'.
    | MotionDirectionRight
    -- ^ search a neighbor t'GI.Wnck.Objects.Workspace.Workspace' at the right of another
    -- t'GI.Wnck.Objects.Workspace.Workspace'.
    | AnotherMotionDirection Int
    -- ^ Catch-all for unknown values
    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 MotionDirection
MotionDirectionUp = Int
-1
    fromEnum MotionDirection
MotionDirectionDown = Int
-2
    fromEnum MotionDirection
MotionDirectionLeft = Int
-3
    fromEnum MotionDirection
MotionDirectionRight = Int
-4
    fromEnum (AnotherMotionDirection Int
k) = Int
k

    toEnum :: Int -> MotionDirection
toEnum Int
-1 = MotionDirection
MotionDirectionUp
    toEnum Int
-2 = MotionDirection
MotionDirectionDown
    toEnum Int
-3 = MotionDirection
MotionDirectionLeft
    toEnum Int
-4 = MotionDirection
MotionDirectionRight
    toEnum Int
k = Int -> MotionDirection
AnotherMotionDirection Int
k

instance P.Ord MotionDirection where
    compare :: MotionDirection -> MotionDirection -> Ordering
compare MotionDirection
a 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)

type instance O.ParentTypes MotionDirection = '[]
instance O.HasParentTypes MotionDirection

foreign import ccall "wnck_motion_direction_get_type" c_wnck_motion_direction_get_type :: 
    IO GType

instance B.Types.TypedObject MotionDirection where
    glibType :: IO GType
glibType = IO GType
c_wnck_motion_direction_get_type

instance B.Types.BoxedEnum MotionDirection

-- Enum ClientType
-- | Type describing the role of the libwnck user.
-- 
-- /Since: 2.14/
data ClientType = 
      ClientTypeApplication
    -- ^ the libwnck user is a normal application.
    | ClientTypePager
    -- ^ the libwnck user is an utility application dealing
    -- with window management, like pagers and taskbars.
    | AnotherClientType Int
    -- ^ Catch-all for unknown values
    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 ClientType
ClientTypeApplication = Int
1
    fromEnum ClientType
ClientTypePager = Int
2
    fromEnum (AnotherClientType Int
k) = Int
k

    toEnum :: Int -> ClientType
toEnum Int
1 = ClientType
ClientTypeApplication
    toEnum Int
2 = ClientType
ClientTypePager
    toEnum Int
k = Int -> ClientType
AnotherClientType Int
k

instance P.Ord ClientType where
    compare :: ClientType -> ClientType -> Ordering
compare ClientType
a 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)

type instance O.ParentTypes ClientType = '[]
instance O.HasParentTypes ClientType

foreign import ccall "wnck_client_type_get_type" c_wnck_client_type_get_type :: 
    IO GType

instance B.Types.TypedObject ClientType where
    glibType :: IO GType
glibType = IO GType
c_wnck_client_type_get_type

instance B.Types.BoxedEnum ClientType