-- | 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(..)                    ,


-- ** 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.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


-- 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 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)

-- 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 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)

-- 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 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

-- 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 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

-- 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 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

-- 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 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" c_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

-- 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 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

-- 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 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