Enums.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

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

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

instance P.Enum LayoutOrientation_ where
    fromEnum LayoutOrientationHorizontal_ = 0
    fromEnum LayoutOrientationVertical_ = 1
    fromEnum (AnotherLayoutOrientation_ k) = k

    toEnum 0 = LayoutOrientationHorizontal_
    toEnum 1 = LayoutOrientationVertical_
    toEnum k = AnotherLayoutOrientation_ k

instance P.Ord LayoutOrientation_ where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 (Show, Eq)

instance P.Enum LayoutCorner_ where
    fromEnum LayoutCornerTopleft_ = 0
    fromEnum LayoutCornerTopright_ = 1
    fromEnum LayoutCornerBottomright_ = 2
    fromEnum LayoutCornerBottomleft_ = 3
    fromEnum (AnotherLayoutCorner_ k) = k

    toEnum 0 = LayoutCornerTopleft_
    toEnum 1 = LayoutCornerTopright_
    toEnum 2 = LayoutCornerBottomright_
    toEnum 3 = LayoutCornerBottomleft_
    toEnum k = AnotherLayoutCorner_ k

instance P.Ord LayoutCorner_ where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

-- Enum WindowType
{- |
Type describing the semantic type of a '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 (Show, Eq)

instance P.Enum WindowType where
    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) = k

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

instance P.Ord WindowType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_window_type_get_type" c_wnck_window_type_get_type :: 
    IO GType

instance BoxedEnum WindowType where
    boxedEnumType _ = c_wnck_window_type_get_type

-- Enum WindowGravity
{- |
Flag used when changing the geometry of a '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 (Show, Eq)

instance P.Enum WindowGravity where
    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) = k

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

instance P.Ord WindowGravity where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_window_gravity_get_type" c_wnck_window_gravity_get_type :: 
    IO GType

instance BoxedEnum WindowGravity where
    boxedEnumType _ = c_wnck_window_gravity_get_type

-- Enum TasklistGroupingType
{- |
Type defining the policy of the 'GI.Wnck.Objects.Tasklist.Tasklist' for grouping multiple
'GI.Wnck.Objects.Window.Window' of the same 'GI.Wnck.Objects.Application.Application'.
-}
data TasklistGroupingType = 
      TasklistGroupingTypeNeverGroup
    {- ^
    never group multiple 'GI.Wnck.Objects.Window.Window' of the same
    'GI.Wnck.Objects.Application.Application'.
    -}
    | TasklistGroupingTypeAutoGroup
    {- ^
    group multiple 'GI.Wnck.Objects.Window.Window' of the same
    'GI.Wnck.Objects.Application.Application' for some 'GI.Wnck.Objects.Application.Application', when there is not enough place
    to have a good-looking list of all 'GI.Wnck.Objects.Window.Window'.
    -}
    | TasklistGroupingTypeAlwaysGroup
    {- ^
    always group multiple 'GI.Wnck.Objects.Window.Window' of the same
    'GI.Wnck.Objects.Application.Application', for all 'GI.Wnck.Objects.Application.Application'.
    -}
    | AnotherTasklistGroupingType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TasklistGroupingType where
    fromEnum TasklistGroupingTypeNeverGroup = 0
    fromEnum TasklistGroupingTypeAutoGroup = 1
    fromEnum TasklistGroupingTypeAlwaysGroup = 2
    fromEnum (AnotherTasklistGroupingType k) = k

    toEnum 0 = TasklistGroupingTypeNeverGroup
    toEnum 1 = TasklistGroupingTypeAutoGroup
    toEnum 2 = TasklistGroupingTypeAlwaysGroup
    toEnum k = AnotherTasklistGroupingType k

instance P.Ord TasklistGroupingType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_tasklist_grouping_type_get_type" c_wnck_tasklist_grouping_type_get_type :: 
    IO GType

instance BoxedEnum TasklistGroupingType where
    boxedEnumType _ = c_wnck_tasklist_grouping_type_get_type

-- Enum PagerDisplayMode
{- |
Mode defining what a 'GI.Wnck.Objects.Pager.Pager' will display.
-}
data PagerDisplayMode = 
      PagerDisplayModeName
    {- ^
    the 'GI.Wnck.Objects.Pager.Pager' will only display the names of the
    workspaces.
    -}
    | PagerDisplayModeContent
    {- ^
    the 'GI.Wnck.Objects.Pager.Pager' will display a representation
    for each window in the workspaces.
    -}
    | AnotherPagerDisplayMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PagerDisplayMode where
    fromEnum PagerDisplayModeName = 0
    fromEnum PagerDisplayModeContent = 1
    fromEnum (AnotherPagerDisplayMode k) = k

    toEnum 0 = PagerDisplayModeName
    toEnum 1 = PagerDisplayModeContent
    toEnum k = AnotherPagerDisplayMode k

instance P.Ord PagerDisplayMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_pager_display_mode_get_type" c_wnck_pager_display_mode_get_type :: 
    IO GType

instance BoxedEnum PagerDisplayMode where
    boxedEnumType _ = c_wnck_pager_display_mode_get_type

-- Enum MotionDirection
{- |
Type defining a direction in which to search a neighbor 'GI.Wnck.Objects.Workspace.Workspace'.

/Since: 2.14/
-}
data MotionDirection = 
      MotionDirectionUp
    {- ^
    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' above another
    'GI.Wnck.Objects.Workspace.Workspace'.
    -}
    | MotionDirectionDown
    {- ^
    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' below another
    'GI.Wnck.Objects.Workspace.Workspace'.
    -}
    | MotionDirectionLeft
    {- ^
    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the left of another
    'GI.Wnck.Objects.Workspace.Workspace'.
    -}
    | MotionDirectionRight
    {- ^
    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the right of another
    'GI.Wnck.Objects.Workspace.Workspace'.
    -}
    | AnotherMotionDirection Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MotionDirection where
    fromEnum MotionDirectionUp = -1
    fromEnum MotionDirectionDown = -2
    fromEnum MotionDirectionLeft = -3
    fromEnum MotionDirectionRight = -4
    fromEnum (AnotherMotionDirection k) = k

    toEnum -1 = MotionDirectionUp
    toEnum -2 = MotionDirectionDown
    toEnum -3 = MotionDirectionLeft
    toEnum -4 = MotionDirectionRight
    toEnum k = AnotherMotionDirection k

instance P.Ord MotionDirection where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_motion_direction_get_type" c_wnck_motion_direction_get_type :: 
    IO GType

instance BoxedEnum MotionDirection where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum ClientType where
    fromEnum ClientTypeApplication = 1
    fromEnum ClientTypePager = 2
    fromEnum (AnotherClientType k) = k

    toEnum 1 = ClientTypeApplication
    toEnum 2 = ClientTypePager
    toEnum k = AnotherClientType k

instance P.Ord ClientType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "wnck_client_type_get_type" c_wnck_client_type_get_type :: 
    IO GType

instance BoxedEnum ClientType where
    boxedEnumType _ = c_wnck_client_type_get_type