module Termbox.Bindings.Hs
  ( -- * Functions

    -- ** Initialize / shutdown
    tb_init,
    tb_init_fd,
    tb_init_file,
    Termbox.Bindings.C.tb_shutdown,

    -- ** Get\/set input\/output mode
    tb_select_input_mode,
    tb_select_output_mode,

    -- ** Get terminal dimensions
    tb_width,
    tb_height,

    -- ** Poll for events
    tb_peek_event,
    tb_poll_event,

    -- ** Style a color
    tb_attr,

    -- ** Set a cell
    tb_set_cursor,
    tb_put_cell,
    tb_change_cell,

    -- ** Clear and synchronize the back buffer
    Termbox.Bindings.C.tb_clear,
    tb_set_clear_attributes,
    Termbox.Bindings.C.tb_present,

    -- * Types
    Tb_attr
      ( Tb_attr,
        TB_BOLD,
        TB_REVERSE,
        TB_UNDERLINE
      ),
    Tb_cell (..),
    Tb_color
      ( Tb_color,
        TB_DEFAULT,
        TB_BLACK,
        TB_BLUE,
        TB_CYAN,
        TB_GREEN,
        TB_MAGENTA,
        TB_RED,
        TB_WHITE,
        TB_YELLOW
      ),
    Tb_event (..),
    Tb_event_mod
      ( Tb_event_mod,
        TB_MOD_ALT,
        TB_MOD_MOTION
      ),
    Tb_event_type
      ( TB_EVENT_KEY,
        TB_EVENT_MOUSE,
        TB_EVENT_RESIZE
      ),
    Tb_init_error
      ( TB_EFAILED_TO_OPEN_TTY,
        TB_EPIPE_TRAP_ERROR,
        TB_EUNSUPPORTED_TERMINAL
      ),
    Tb_input_mode
      ( TB_INPUT_CURRENT,
        TB_INPUT_ALT,
        TB_INPUT_ESC,
        TB_INPUT_MOUSE
      ),
    Tb_key
      ( TB_KEY_ARROW_DOWN,
        TB_KEY_ARROW_LEFT,
        TB_KEY_ARROW_RIGHT,
        TB_KEY_ARROW_UP,
        TB_KEY_BACKSPACE,
        TB_KEY_BACKSPACE2,
        TB_KEY_CTRL_2,
        TB_KEY_CTRL_3,
        TB_KEY_CTRL_4,
        TB_KEY_CTRL_5,
        TB_KEY_CTRL_6,
        TB_KEY_CTRL_7,
        TB_KEY_CTRL_8,
        TB_KEY_CTRL_A,
        TB_KEY_CTRL_B,
        TB_KEY_CTRL_BACKSLASH,
        TB_KEY_CTRL_C,
        TB_KEY_CTRL_D,
        TB_KEY_CTRL_E,
        TB_KEY_CTRL_F,
        TB_KEY_CTRL_G,
        TB_KEY_CTRL_H,
        TB_KEY_CTRL_I,
        TB_KEY_CTRL_J,
        TB_KEY_CTRL_K,
        TB_KEY_CTRL_L,
        TB_KEY_CTRL_LSQ_BRACKET,
        TB_KEY_CTRL_M,
        TB_KEY_CTRL_N,
        TB_KEY_CTRL_O,
        TB_KEY_CTRL_P,
        TB_KEY_CTRL_Q,
        TB_KEY_CTRL_R,
        TB_KEY_CTRL_RSQ_BRACKET,
        TB_KEY_CTRL_S,
        TB_KEY_CTRL_SLASH,
        TB_KEY_CTRL_T,
        TB_KEY_CTRL_TILDE,
        TB_KEY_CTRL_U,
        TB_KEY_CTRL_UNDERSCORE,
        TB_KEY_CTRL_V,
        TB_KEY_CTRL_W,
        TB_KEY_CTRL_X,
        TB_KEY_CTRL_Y,
        TB_KEY_CTRL_Z,
        TB_KEY_DELETE,
        TB_KEY_END,
        TB_KEY_ENTER,
        TB_KEY_ESC,
        TB_KEY_F1,
        TB_KEY_F10,
        TB_KEY_F11,
        TB_KEY_F12,
        TB_KEY_F2,
        TB_KEY_F3,
        TB_KEY_F4,
        TB_KEY_F5,
        TB_KEY_F6,
        TB_KEY_F7,
        TB_KEY_F8,
        TB_KEY_F9,
        TB_KEY_HOME,
        TB_KEY_INSERT,
        TB_KEY_MOUSE_LEFT,
        TB_KEY_MOUSE_MIDDLE,
        TB_KEY_MOUSE_RELEASE,
        TB_KEY_MOUSE_RIGHT,
        TB_KEY_MOUSE_WHEEL_DOWN,
        TB_KEY_MOUSE_WHEEL_UP,
        TB_KEY_PGDN,
        TB_KEY_PGUP,
        TB_KEY_SPACE,
        TB_KEY_TAB
      ),
    Tb_output_mode
      ( TB_OUTPUT_CURRENT,
        TB_OUTPUT_216,
        TB_OUTPUT_256,
        TB_OUTPUT_GRAYSCALE,
        TB_OUTPUT_NORMAL
      ),
  )
where

import Data.Bits ((.|.))
import qualified Data.Char as Char
import Data.Coerce (coerce)
import Data.Int (Int32)
import Data.Word (Word16, Word32, Word8)
import Foreign.C.String (withCString)
import Foreign.C.Types (CInt)
import Foreign.Marshal.Alloc (alloca)
import qualified Foreign.Storable as Storable
import System.Posix.Types (Fd (Fd))
import GHC.Generics (Generic)
import qualified Termbox.Bindings.C
import Prelude hiding (mod)

------------------------------------------------------------------------------------------------------------------------
-- Functions

-- | Set the attribute of a color.
tb_attr :: Tb_attr -> Tb_color -> Tb_color
tb_attr :: Tb_attr -> Tb_color -> Tb_color
tb_attr =
  coerce :: forall a b. Coercible a b => a -> b
coerce (forall a. Bits a => a -> a -> a
(.|.) :: Word16 -> Word16 -> Word16)

-- | Set a cell value in the back buffer.
tb_change_cell ::
  -- | x
  Int ->
  -- | y
  Int ->
  -- | ch
  Char ->
  -- | fg
  Tb_color ->
  -- | bg
  Tb_color ->
  IO ()
tb_change_cell :: Int -> Int -> Char -> Tb_color -> Tb_color -> IO ()
tb_change_cell Int
cx Int
cy Char
c (Tb_color Word16
foreground) (Tb_color Word16
background) =
  CInt -> CInt -> Word32 -> Word16 -> Word16 -> IO ()
Termbox.Bindings.C.tb_change_cell (Int -> CInt
intToCInt Int
cx) (Int -> CInt
intToCInt Int
cy) (Char -> Word32
charToWord32 Char
c) Word16
foreground Word16
background

-- | Get the terminal height.
tb_height :: IO Int
tb_height :: IO Int
tb_height =
  CInt -> Int
cintToInt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CInt
Termbox.Bindings.C.tb_height

-- | Initialize the @termbox@ library.
tb_init :: IO (Either Tb_init_error ())
tb_init :: IO (Either Tb_init_error ())
tb_init = do
  CInt
code <- IO CInt
Termbox.Bindings.C.tb_init
  forall (f :: * -> *) a. Applicative f => a -> f a
pure
    if CInt
code forall a. Eq a => a -> a -> Bool
== CInt
0
      then forall a b. b -> Either a b
Right ()
      else forall a b. a -> Either a b
Left (CInt -> Tb_init_error
Tb_init_error CInt
code)

-- | Initialize the @termbox@ library.
--
-- > tb_init = tb_init_fd(0)
tb_init_fd :: Fd -> IO (Either Tb_init_error ())
tb_init_fd :: Fd -> IO (Either Tb_init_error ())
tb_init_fd (Fd CInt
fd) = do
  CInt
code <- CInt -> IO CInt
Termbox.Bindings.C.tb_init_fd CInt
fd
  forall (f :: * -> *) a. Applicative f => a -> f a
pure
    if CInt
code forall a. Eq a => a -> a -> Bool
== CInt
0
      then forall a b. b -> Either a b
Right ()
      else forall a b. a -> Either a b
Left (CInt -> Tb_init_error
Tb_init_error CInt
code)

-- | Initialize the @termbox@ library.
--
-- > tb_init = tb_init_file("/dev/tty")
tb_init_file :: FilePath -> IO (Either Tb_init_error ())
tb_init_file :: FilePath -> IO (Either Tb_init_error ())
tb_init_file FilePath
file = do
  CInt
code <-
    forall a. FilePath -> (CString -> IO a) -> IO a
withCString FilePath
file \CString
c_file ->
      CString -> IO CInt
Termbox.Bindings.C.tb_init_file CString
c_file
  forall (f :: * -> *) a. Applicative f => a -> f a
pure
    if CInt
code forall a. Eq a => a -> a -> Bool
== CInt
0
      then forall a b. b -> Either a b
Right ()
      else forall a b. a -> Either a b
Left (CInt -> Tb_init_error
Tb_init_error CInt
code)

-- | Wait up to a number of milliseconds for an event.
tb_peek_event :: Int -> IO (Either () (Maybe Tb_event))
tb_peek_event :: Int -> IO (Either () (Maybe Tb_event))
tb_peek_event Int
timeout =
  forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr Tb_event
c_event -> do
    CInt
result <- Ptr Tb_event -> CInt -> IO CInt
Termbox.Bindings.C.tb_peek_event Ptr Tb_event
c_event (Int -> CInt
intToCInt Int
timeout)
    if CInt
result forall a. Ord a => a -> a -> Bool
< CInt
0
      then forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a b. a -> Either a b
Left ())
      else
        if CInt
result forall a. Eq a => a -> a -> Bool
== CInt
0
          then forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a b. b -> Either a b
Right forall a. Maybe a
Nothing)
          else forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tb_event -> Tb_event
ceventToEvent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Storable a => Ptr a -> IO a
Storable.peek Ptr Tb_event
c_event

-- | Wait for an event.
tb_poll_event :: IO (Either () Tb_event)
tb_poll_event :: IO (Either () Tb_event)
tb_poll_event =
  forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr Tb_event
c_event -> do
    CInt
result <- Ptr Tb_event -> IO CInt
Termbox.Bindings.C.tb_poll_event Ptr Tb_event
c_event
    if CInt
result forall a. Ord a => a -> a -> Bool
< CInt
0
      then forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall a b. a -> Either a b
Left ())
      else forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tb_event -> Tb_event
ceventToEvent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Storable a => Ptr a -> IO a
Storable.peek Ptr Tb_event
c_event

-- | Set a cell value in the back buffer.
tb_put_cell ::
  -- | x
  Int ->
  -- | y
  Int ->
  -- | cell
  Tb_cell ->
  IO ()
tb_put_cell :: Int -> Int -> Tb_cell -> IO ()
tb_put_cell Int
cx Int
cy Tb_cell
cell =
  forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca \Ptr Tb_cell
c_cell -> do
    forall a. Storable a => Ptr a -> a -> IO ()
Storable.poke Ptr Tb_cell
c_cell (Tb_cell -> Tb_cell
cellToCCell Tb_cell
cell)
    CInt -> CInt -> Ptr Tb_cell -> IO ()
Termbox.Bindings.C.tb_put_cell (Int -> CInt
intToCInt Int
cx) (Int -> CInt
intToCInt Int
cy) Ptr Tb_cell
c_cell

-- | Get\/set the input mode.
tb_select_input_mode :: Tb_input_mode -> IO Tb_input_mode
tb_select_input_mode :: Tb_input_mode -> IO Tb_input_mode
tb_select_input_mode =
  coerce :: forall a b. Coercible a b => a -> b
coerce CInt -> IO CInt
Termbox.Bindings.C.tb_select_input_mode

-- | Get\/set the output mode.
tb_select_output_mode :: Tb_output_mode -> IO Tb_output_mode
tb_select_output_mode :: Tb_output_mode -> IO Tb_output_mode
tb_select_output_mode =
  coerce :: forall a b. Coercible a b => a -> b
coerce CInt -> IO CInt
Termbox.Bindings.C.tb_select_output_mode

-- | Set the foreground and background attributes that 'tb_clear' clears the back buffer with.
tb_set_clear_attributes ::
  -- | fg
  Tb_color ->
  -- | bg
  Tb_color ->
  IO ()
tb_set_clear_attributes :: Tb_color -> Tb_color -> IO ()
tb_set_clear_attributes (Tb_color Word16
foreground) (Tb_color Word16
background) =
  Word16 -> Word16 -> IO ()
Termbox.Bindings.C.tb_set_clear_attributes Word16
foreground Word16
background

-- | Set the cursor location, or hide it.
tb_set_cursor ::
  -- | x, y
  Maybe (Int, Int) ->
  IO ()
tb_set_cursor :: Maybe (Int, Int) -> IO ()
tb_set_cursor = \case
  Maybe (Int, Int)
Nothing -> CInt -> CInt -> IO ()
Termbox.Bindings.C.tb_set_cursor CInt
Termbox.Bindings.C._TB_HIDE_CURSOR CInt
Termbox.Bindings.C._TB_HIDE_CURSOR
  Just (Int
cx, Int
cy) -> CInt -> CInt -> IO ()
Termbox.Bindings.C.tb_set_cursor (Int -> CInt
intToCInt Int
cx) (Int -> CInt
intToCInt Int
cy)

-- | Get the terminal width.
tb_width :: IO Int
tb_width :: IO Int
tb_width =
  CInt -> Int
cintToInt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CInt
Termbox.Bindings.C.tb_width

------------------------------------------------------------------------------------------------------------------------
-- Types

-- | An attribute.
newtype Tb_attr
  = Tb_attr Word16
  deriving stock (Tb_attr -> Tb_attr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_attr -> Tb_attr -> Bool
$c/= :: Tb_attr -> Tb_attr -> Bool
== :: Tb_attr -> Tb_attr -> Bool
$c== :: Tb_attr -> Tb_attr -> Bool
Eq, Eq Tb_attr
Tb_attr -> Tb_attr -> Bool
Tb_attr -> Tb_attr -> Ordering
Tb_attr -> Tb_attr -> Tb_attr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_attr -> Tb_attr -> Tb_attr
$cmin :: Tb_attr -> Tb_attr -> Tb_attr
max :: Tb_attr -> Tb_attr -> Tb_attr
$cmax :: Tb_attr -> Tb_attr -> Tb_attr
>= :: Tb_attr -> Tb_attr -> Bool
$c>= :: Tb_attr -> Tb_attr -> Bool
> :: Tb_attr -> Tb_attr -> Bool
$c> :: Tb_attr -> Tb_attr -> Bool
<= :: Tb_attr -> Tb_attr -> Bool
$c<= :: Tb_attr -> Tb_attr -> Bool
< :: Tb_attr -> Tb_attr -> Bool
$c< :: Tb_attr -> Tb_attr -> Bool
compare :: Tb_attr -> Tb_attr -> Ordering
$ccompare :: Tb_attr -> Tb_attr -> Ordering
Ord, Int -> Tb_attr -> ShowS
[Tb_attr] -> ShowS
Tb_attr -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Tb_attr] -> ShowS
$cshowList :: [Tb_attr] -> ShowS
show :: Tb_attr -> FilePath
$cshow :: Tb_attr -> FilePath
showsPrec :: Int -> Tb_attr -> ShowS
$cshowsPrec :: Int -> Tb_attr -> ShowS
Show)

instance Semigroup Tb_attr where
  Tb_attr Word16
cx <> :: Tb_attr -> Tb_attr -> Tb_attr
<> Tb_attr Word16
cy =
    Word16 -> Tb_attr
Tb_attr (Word16
cx forall a. Bits a => a -> a -> a
.|. Word16
cy)

pattern TB_BOLD :: Tb_attr
pattern $bTB_BOLD :: Tb_attr
$mTB_BOLD :: forall {r}. Tb_attr -> ((# #) -> r) -> ((# #) -> r) -> r
TB_BOLD <-
  ((== Tb_attr Termbox.Bindings.C._TB_BOLD) -> True)
  where
    TB_BOLD = Word16 -> Tb_attr
Tb_attr Word16
Termbox.Bindings.C._TB_BOLD

pattern TB_REVERSE :: Tb_attr
pattern $bTB_REVERSE :: Tb_attr
$mTB_REVERSE :: forall {r}. Tb_attr -> ((# #) -> r) -> ((# #) -> r) -> r
TB_REVERSE <-
  ((== Tb_attr Termbox.Bindings.C._TB_REVERSE) -> True)
  where
    TB_REVERSE = Word16 -> Tb_attr
Tb_attr Word16
Termbox.Bindings.C._TB_REVERSE

pattern TB_UNDERLINE :: Tb_attr
pattern $bTB_UNDERLINE :: Tb_attr
$mTB_UNDERLINE :: forall {r}. Tb_attr -> ((# #) -> r) -> ((# #) -> r) -> r
TB_UNDERLINE <-
  ((== Tb_attr Termbox.Bindings.C._TB_UNDERLINE) -> True)
  where
    TB_UNDERLINE = Word16 -> Tb_attr
Tb_attr Word16
Termbox.Bindings.C._TB_UNDERLINE

-- | A cell.
data Tb_cell = Tb_cell
  { -- | A unicode character.
    Tb_cell -> Char
ch :: {-# UNPACK #-} !Char,
    -- | Foreground attribute.
    Tb_cell -> Tb_attr
fg :: {-# UNPACK #-} !Tb_attr,
    -- | Background attribute.
    Tb_cell -> Tb_attr
bg :: {-# UNPACK #-} !Tb_attr
  }
  deriving stock (Tb_cell -> Tb_cell -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_cell -> Tb_cell -> Bool
$c/= :: Tb_cell -> Tb_cell -> Bool
== :: Tb_cell -> Tb_cell -> Bool
$c== :: Tb_cell -> Tb_cell -> Bool
Eq, forall x. Rep Tb_cell x -> Tb_cell
forall x. Tb_cell -> Rep Tb_cell x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tb_cell x -> Tb_cell
$cfrom :: forall x. Tb_cell -> Rep Tb_cell x
Generic, Eq Tb_cell
Tb_cell -> Tb_cell -> Bool
Tb_cell -> Tb_cell -> Ordering
Tb_cell -> Tb_cell -> Tb_cell
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_cell -> Tb_cell -> Tb_cell
$cmin :: Tb_cell -> Tb_cell -> Tb_cell
max :: Tb_cell -> Tb_cell -> Tb_cell
$cmax :: Tb_cell -> Tb_cell -> Tb_cell
>= :: Tb_cell -> Tb_cell -> Bool
$c>= :: Tb_cell -> Tb_cell -> Bool
> :: Tb_cell -> Tb_cell -> Bool
$c> :: Tb_cell -> Tb_cell -> Bool
<= :: Tb_cell -> Tb_cell -> Bool
$c<= :: Tb_cell -> Tb_cell -> Bool
< :: Tb_cell -> Tb_cell -> Bool
$c< :: Tb_cell -> Tb_cell -> Bool
compare :: Tb_cell -> Tb_cell -> Ordering
$ccompare :: Tb_cell -> Tb_cell -> Ordering
Ord, Int -> Tb_cell -> ShowS
[Tb_cell] -> ShowS
Tb_cell -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Tb_cell] -> ShowS
$cshowList :: [Tb_cell] -> ShowS
show :: Tb_cell -> FilePath
$cshow :: Tb_cell -> FilePath
showsPrec :: Int -> Tb_cell -> ShowS
$cshowsPrec :: Int -> Tb_cell -> ShowS
Show)

cellToCCell :: Tb_cell -> Termbox.Bindings.C.Tb_cell
cellToCCell :: Tb_cell -> Tb_cell
cellToCCell Tb_cell {Char
ch :: Char
$sel:ch:Tb_cell :: Tb_cell -> Char
ch, $sel:fg:Tb_cell :: Tb_cell -> Tb_attr
fg = Tb_attr Word16
fg, $sel:bg:Tb_cell :: Tb_cell -> Tb_attr
bg = Tb_attr Word16
bg} =
  Termbox.Bindings.C.Tb_cell
    { $sel:ch:Tb_cell :: Word32
ch = Char -> Word32
charToWord32 Char
ch,
      Word16
$sel:fg:Tb_cell :: Word16
fg :: Word16
fg,
      Word16
$sel:bg:Tb_cell :: Word16
bg :: Word16
bg
    }
{-# INLINE cellToCCell #-}

-- | A color.
newtype Tb_color
  = Tb_color Word16
  deriving stock (Tb_color -> Tb_color -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_color -> Tb_color -> Bool
$c/= :: Tb_color -> Tb_color -> Bool
== :: Tb_color -> Tb_color -> Bool
$c== :: Tb_color -> Tb_color -> Bool
Eq, Eq Tb_color
Tb_color -> Tb_color -> Bool
Tb_color -> Tb_color -> Ordering
Tb_color -> Tb_color -> Tb_color
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_color -> Tb_color -> Tb_color
$cmin :: Tb_color -> Tb_color -> Tb_color
max :: Tb_color -> Tb_color -> Tb_color
$cmax :: Tb_color -> Tb_color -> Tb_color
>= :: Tb_color -> Tb_color -> Bool
$c>= :: Tb_color -> Tb_color -> Bool
> :: Tb_color -> Tb_color -> Bool
$c> :: Tb_color -> Tb_color -> Bool
<= :: Tb_color -> Tb_color -> Bool
$c<= :: Tb_color -> Tb_color -> Bool
< :: Tb_color -> Tb_color -> Bool
$c< :: Tb_color -> Tb_color -> Bool
compare :: Tb_color -> Tb_color -> Ordering
$ccompare :: Tb_color -> Tb_color -> Ordering
Ord)
  deriving newtype (Integer -> Tb_color
Tb_color -> Tb_color
Tb_color -> Tb_color -> Tb_color
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Tb_color
$cfromInteger :: Integer -> Tb_color
signum :: Tb_color -> Tb_color
$csignum :: Tb_color -> Tb_color
abs :: Tb_color -> Tb_color
$cabs :: Tb_color -> Tb_color
negate :: Tb_color -> Tb_color
$cnegate :: Tb_color -> Tb_color
* :: Tb_color -> Tb_color -> Tb_color
$c* :: Tb_color -> Tb_color -> Tb_color
- :: Tb_color -> Tb_color -> Tb_color
$c- :: Tb_color -> Tb_color -> Tb_color
+ :: Tb_color -> Tb_color -> Tb_color
$c+ :: Tb_color -> Tb_color -> Tb_color
Num, Int -> Tb_color -> ShowS
[Tb_color] -> ShowS
Tb_color -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Tb_color] -> ShowS
$cshowList :: [Tb_color] -> ShowS
show :: Tb_color -> FilePath
$cshow :: Tb_color -> FilePath
showsPrec :: Int -> Tb_color -> ShowS
$cshowsPrec :: Int -> Tb_color -> ShowS
Show)

pattern TB_DEFAULT :: Tb_color
pattern $bTB_DEFAULT :: Tb_color
$mTB_DEFAULT :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_DEFAULT <-
  ((== Tb_color Termbox.Bindings.C._TB_DEFAULT) -> True)
  where
    TB_DEFAULT = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_DEFAULT

pattern TB_BLACK :: Tb_color
pattern $bTB_BLACK :: Tb_color
$mTB_BLACK :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_BLACK <-
  ((== Tb_color Termbox.Bindings.C._TB_BLACK) -> True)
  where
    TB_BLACK = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_BLACK

pattern TB_BLUE :: Tb_color
pattern $bTB_BLUE :: Tb_color
$mTB_BLUE :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_BLUE <-
  ((== Tb_color Termbox.Bindings.C._TB_BLUE) -> True)
  where
    TB_BLUE = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_BLUE

pattern TB_CYAN :: Tb_color
pattern $bTB_CYAN :: Tb_color
$mTB_CYAN :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_CYAN <-
  ((== Tb_color Termbox.Bindings.C._TB_CYAN) -> True)
  where
    TB_CYAN = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_CYAN

pattern TB_GREEN :: Tb_color
pattern $bTB_GREEN :: Tb_color
$mTB_GREEN :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_GREEN <-
  ((== Tb_color Termbox.Bindings.C._TB_GREEN) -> True)
  where
    TB_GREEN = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_GREEN

pattern TB_MAGENTA :: Tb_color
pattern $bTB_MAGENTA :: Tb_color
$mTB_MAGENTA :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_MAGENTA <-
  ((== Tb_color Termbox.Bindings.C._TB_MAGENTA) -> True)
  where
    TB_MAGENTA = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_MAGENTA

pattern TB_RED :: Tb_color
pattern $bTB_RED :: Tb_color
$mTB_RED :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_RED <-
  ((== Tb_color Termbox.Bindings.C._TB_RED) -> True)
  where
    TB_RED = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_RED

pattern TB_WHITE :: Tb_color
pattern $bTB_WHITE :: Tb_color
$mTB_WHITE :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_WHITE <-
  ((== Tb_color Termbox.Bindings.C._TB_WHITE) -> True)
  where
    TB_WHITE = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_WHITE

pattern TB_YELLOW :: Tb_color
pattern $bTB_YELLOW :: Tb_color
$mTB_YELLOW :: forall {r}. Tb_color -> ((# #) -> r) -> ((# #) -> r) -> r
TB_YELLOW <-
  ((== Tb_color Termbox.Bindings.C._TB_YELLOW) -> True)
  where
    TB_YELLOW = Word16 -> Tb_color
Tb_color Word16
Termbox.Bindings.C._TB_YELLOW

-- | An event.
data Tb_event = Tb_event
  { Tb_event -> Tb_event_type
type_ :: {-# UNPACK #-} !Tb_event_type,
    Tb_event -> Tb_event_mod
mod :: {-# UNPACK #-} !Tb_event_mod,
    Tb_event -> Tb_key
key :: {-# UNPACK #-} !Tb_key,
    Tb_event -> Char
ch :: {-# UNPACK #-} !Char,
    Tb_event -> Int32
w :: {-# UNPACK #-} !Int32,
    Tb_event -> Int32
h :: {-# UNPACK #-} !Int32,
    Tb_event -> Int32
x :: {-# UNPACK #-} !Int32,
    Tb_event -> Int32
y :: {-# UNPACK #-} !Int32
  }
  deriving stock (Tb_event -> Tb_event -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_event -> Tb_event -> Bool
$c/= :: Tb_event -> Tb_event -> Bool
== :: Tb_event -> Tb_event -> Bool
$c== :: Tb_event -> Tb_event -> Bool
Eq, forall x. Rep Tb_event x -> Tb_event
forall x. Tb_event -> Rep Tb_event x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tb_event x -> Tb_event
$cfrom :: forall x. Tb_event -> Rep Tb_event x
Generic, Eq Tb_event
Tb_event -> Tb_event -> Bool
Tb_event -> Tb_event -> Ordering
Tb_event -> Tb_event -> Tb_event
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_event -> Tb_event -> Tb_event
$cmin :: Tb_event -> Tb_event -> Tb_event
max :: Tb_event -> Tb_event -> Tb_event
$cmax :: Tb_event -> Tb_event -> Tb_event
>= :: Tb_event -> Tb_event -> Bool
$c>= :: Tb_event -> Tb_event -> Bool
> :: Tb_event -> Tb_event -> Bool
$c> :: Tb_event -> Tb_event -> Bool
<= :: Tb_event -> Tb_event -> Bool
$c<= :: Tb_event -> Tb_event -> Bool
< :: Tb_event -> Tb_event -> Bool
$c< :: Tb_event -> Tb_event -> Bool
compare :: Tb_event -> Tb_event -> Ordering
$ccompare :: Tb_event -> Tb_event -> Ordering
Ord, Int -> Tb_event -> ShowS
[Tb_event] -> ShowS
Tb_event -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Tb_event] -> ShowS
$cshowList :: [Tb_event] -> ShowS
show :: Tb_event -> FilePath
$cshow :: Tb_event -> FilePath
showsPrec :: Int -> Tb_event -> ShowS
$cshowsPrec :: Int -> Tb_event -> ShowS
Show)

ceventToEvent :: Termbox.Bindings.C.Tb_event -> Tb_event
ceventToEvent :: Tb_event -> Tb_event
ceventToEvent Termbox.Bindings.C.Tb_event {Word8
$sel:type_:Tb_event :: Tb_event -> Word8
type_ :: Word8
type_, Word8
$sel:mod:Tb_event :: Tb_event -> Word8
mod :: Word8
mod, Word16
$sel:key:Tb_event :: Tb_event -> Word16
key :: Word16
key, Word32
$sel:ch:Tb_event :: Tb_event -> Word32
ch :: Word32
ch, Int32
$sel:w:Tb_event :: Tb_event -> Int32
w :: Int32
w, Int32
$sel:h:Tb_event :: Tb_event -> Int32
h :: Int32
h, Int32
$sel:x:Tb_event :: Tb_event -> Int32
x :: Int32
x, Int32
$sel:y:Tb_event :: Tb_event -> Int32
y :: Int32
y} =
  Tb_event
    { $sel:type_:Tb_event :: Tb_event_type
type_ = Word8 -> Tb_event_type
Tb_event_type Word8
type_,
      $sel:mod:Tb_event :: Tb_event_mod
mod = Word8 -> Tb_event_mod
Tb_event_mod Word8
mod,
      $sel:key:Tb_event :: Tb_key
key = Word16 -> Tb_key
Tb_key Word16
key,
      $sel:ch:Tb_event :: Char
ch = Word32 -> Char
word32ToChar Word32
ch,
      Int32
w :: Int32
$sel:w:Tb_event :: Int32
w,
      Int32
h :: Int32
$sel:h:Tb_event :: Int32
h,
      Int32
x :: Int32
$sel:x:Tb_event :: Int32
x,
      Int32
y :: Int32
$sel:y:Tb_event :: Int32
y
    }
{-# INLINE ceventToEvent #-}

-- | An event modifier.
newtype Tb_event_mod
  = Tb_event_mod Word8
  deriving stock (Tb_event_mod -> Tb_event_mod -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_event_mod -> Tb_event_mod -> Bool
$c/= :: Tb_event_mod -> Tb_event_mod -> Bool
== :: Tb_event_mod -> Tb_event_mod -> Bool
$c== :: Tb_event_mod -> Tb_event_mod -> Bool
Eq, Eq Tb_event_mod
Tb_event_mod -> Tb_event_mod -> Bool
Tb_event_mod -> Tb_event_mod -> Ordering
Tb_event_mod -> Tb_event_mod -> Tb_event_mod
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_event_mod -> Tb_event_mod -> Tb_event_mod
$cmin :: Tb_event_mod -> Tb_event_mod -> Tb_event_mod
max :: Tb_event_mod -> Tb_event_mod -> Tb_event_mod
$cmax :: Tb_event_mod -> Tb_event_mod -> Tb_event_mod
>= :: Tb_event_mod -> Tb_event_mod -> Bool
$c>= :: Tb_event_mod -> Tb_event_mod -> Bool
> :: Tb_event_mod -> Tb_event_mod -> Bool
$c> :: Tb_event_mod -> Tb_event_mod -> Bool
<= :: Tb_event_mod -> Tb_event_mod -> Bool
$c<= :: Tb_event_mod -> Tb_event_mod -> Bool
< :: Tb_event_mod -> Tb_event_mod -> Bool
$c< :: Tb_event_mod -> Tb_event_mod -> Bool
compare :: Tb_event_mod -> Tb_event_mod -> Ordering
$ccompare :: Tb_event_mod -> Tb_event_mod -> Ordering
Ord, Int -> Tb_event_mod -> ShowS
[Tb_event_mod] -> ShowS
Tb_event_mod -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Tb_event_mod] -> ShowS
$cshowList :: [Tb_event_mod] -> ShowS
show :: Tb_event_mod -> FilePath
$cshow :: Tb_event_mod -> FilePath
showsPrec :: Int -> Tb_event_mod -> ShowS
$cshowsPrec :: Int -> Tb_event_mod -> ShowS
Show)

pattern TB_MOD_ALT :: Tb_event_mod
pattern $bTB_MOD_ALT :: Tb_event_mod
$mTB_MOD_ALT :: forall {r}. Tb_event_mod -> ((# #) -> r) -> ((# #) -> r) -> r
TB_MOD_ALT <-
  ((== Tb_event_mod Termbox.Bindings.C._TB_MOD_ALT) -> True)
  where
    TB_MOD_ALT = Word8 -> Tb_event_mod
Tb_event_mod Word8
Termbox.Bindings.C._TB_MOD_ALT

pattern TB_MOD_MOTION :: Tb_event_mod
pattern $bTB_MOD_MOTION :: Tb_event_mod
$mTB_MOD_MOTION :: forall {r}. Tb_event_mod -> ((# #) -> r) -> ((# #) -> r) -> r
TB_MOD_MOTION <-
  ((== Tb_event_mod Termbox.Bindings.C._TB_MOD_MOTION) -> True)
  where
    TB_MOD_MOTION = Word8 -> Tb_event_mod
Tb_event_mod Word8
Termbox.Bindings.C._TB_MOD_MOTION

-- | An event type.
newtype Tb_event_type
  = Tb_event_type Word8
  deriving stock (Tb_event_type -> Tb_event_type -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_event_type -> Tb_event_type -> Bool
$c/= :: Tb_event_type -> Tb_event_type -> Bool
== :: Tb_event_type -> Tb_event_type -> Bool
$c== :: Tb_event_type -> Tb_event_type -> Bool
Eq, Eq Tb_event_type
Tb_event_type -> Tb_event_type -> Bool
Tb_event_type -> Tb_event_type -> Ordering
Tb_event_type -> Tb_event_type -> Tb_event_type
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_event_type -> Tb_event_type -> Tb_event_type
$cmin :: Tb_event_type -> Tb_event_type -> Tb_event_type
max :: Tb_event_type -> Tb_event_type -> Tb_event_type
$cmax :: Tb_event_type -> Tb_event_type -> Tb_event_type
>= :: Tb_event_type -> Tb_event_type -> Bool
$c>= :: Tb_event_type -> Tb_event_type -> Bool
> :: Tb_event_type -> Tb_event_type -> Bool
$c> :: Tb_event_type -> Tb_event_type -> Bool
<= :: Tb_event_type -> Tb_event_type -> Bool
$c<= :: Tb_event_type -> Tb_event_type -> Bool
< :: Tb_event_type -> Tb_event_type -> Bool
$c< :: Tb_event_type -> Tb_event_type -> Bool
compare :: Tb_event_type -> Tb_event_type -> Ordering
$ccompare :: Tb_event_type -> Tb_event_type -> Ordering
Ord)

instance Show Tb_event_type where
  show :: Tb_event_type -> FilePath
show = \case
    Tb_event_type
TB_EVENT_KEY -> FilePath
"TB_EVENT_KEY"
    Tb_event_type
TB_EVENT_MOUSE -> FilePath
"TB_EVENT_MOUSE"
    Tb_event_type
TB_EVENT_RESIZE -> FilePath
"TB_EVENT_RESIZE"

pattern TB_EVENT_KEY :: Tb_event_type
pattern $bTB_EVENT_KEY :: Tb_event_type
$mTB_EVENT_KEY :: forall {r}. Tb_event_type -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EVENT_KEY <-
  ((== Tb_event_type Termbox.Bindings.C._TB_EVENT_KEY) -> True)
  where
    TB_EVENT_KEY = Word8 -> Tb_event_type
Tb_event_type Word8
Termbox.Bindings.C._TB_EVENT_KEY

pattern TB_EVENT_MOUSE :: Tb_event_type
pattern $bTB_EVENT_MOUSE :: Tb_event_type
$mTB_EVENT_MOUSE :: forall {r}. Tb_event_type -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EVENT_MOUSE <-
  ((== Tb_event_type Termbox.Bindings.C._TB_EVENT_MOUSE) -> True)
  where
    TB_EVENT_MOUSE = Word8 -> Tb_event_type
Tb_event_type Word8
Termbox.Bindings.C._TB_EVENT_MOUSE

pattern TB_EVENT_RESIZE :: Tb_event_type
pattern $bTB_EVENT_RESIZE :: Tb_event_type
$mTB_EVENT_RESIZE :: forall {r}. Tb_event_type -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EVENT_RESIZE <-
  ((== Tb_event_type Termbox.Bindings.C._TB_EVENT_RESIZE) -> True)
  where
    TB_EVENT_RESIZE = Word8 -> Tb_event_type
Tb_event_type Word8
Termbox.Bindings.C._TB_EVENT_RESIZE

{-# COMPLETE TB_EVENT_KEY, TB_EVENT_MOUSE, TB_EVENT_RESIZE #-}

-- | A 'tb_init' error.
newtype Tb_init_error
  = Tb_init_error CInt
  deriving stock (Tb_init_error -> Tb_init_error -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_init_error -> Tb_init_error -> Bool
$c/= :: Tb_init_error -> Tb_init_error -> Bool
== :: Tb_init_error -> Tb_init_error -> Bool
$c== :: Tb_init_error -> Tb_init_error -> Bool
Eq, Eq Tb_init_error
Tb_init_error -> Tb_init_error -> Bool
Tb_init_error -> Tb_init_error -> Ordering
Tb_init_error -> Tb_init_error -> Tb_init_error
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_init_error -> Tb_init_error -> Tb_init_error
$cmin :: Tb_init_error -> Tb_init_error -> Tb_init_error
max :: Tb_init_error -> Tb_init_error -> Tb_init_error
$cmax :: Tb_init_error -> Tb_init_error -> Tb_init_error
>= :: Tb_init_error -> Tb_init_error -> Bool
$c>= :: Tb_init_error -> Tb_init_error -> Bool
> :: Tb_init_error -> Tb_init_error -> Bool
$c> :: Tb_init_error -> Tb_init_error -> Bool
<= :: Tb_init_error -> Tb_init_error -> Bool
$c<= :: Tb_init_error -> Tb_init_error -> Bool
< :: Tb_init_error -> Tb_init_error -> Bool
$c< :: Tb_init_error -> Tb_init_error -> Bool
compare :: Tb_init_error -> Tb_init_error -> Ordering
$ccompare :: Tb_init_error -> Tb_init_error -> Ordering
Ord)

instance Show Tb_init_error where
  show :: Tb_init_error -> FilePath
show = \case
    Tb_init_error
TB_EFAILED_TO_OPEN_TTY -> FilePath
"TB_EFAILED_TO_OPEN_TTY"
    Tb_init_error
TB_EPIPE_TRAP_ERROR -> FilePath
"TB_EPIPE_TRAP_ERROR"
    Tb_init_error
TB_EUNSUPPORTED_TERMINAL -> FilePath
"TB_EUNSUPPORTED_TERMINAL"

pattern TB_EFAILED_TO_OPEN_TTY :: Tb_init_error
pattern $bTB_EFAILED_TO_OPEN_TTY :: Tb_init_error
$mTB_EFAILED_TO_OPEN_TTY :: forall {r}. Tb_init_error -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EFAILED_TO_OPEN_TTY <-
  ((== Tb_init_error Termbox.Bindings.C._TB_EFAILED_TO_OPEN_TTY) -> True)
  where
    TB_EFAILED_TO_OPEN_TTY = CInt -> Tb_init_error
Tb_init_error CInt
Termbox.Bindings.C._TB_EFAILED_TO_OPEN_TTY

pattern TB_EPIPE_TRAP_ERROR :: Tb_init_error
pattern $bTB_EPIPE_TRAP_ERROR :: Tb_init_error
$mTB_EPIPE_TRAP_ERROR :: forall {r}. Tb_init_error -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EPIPE_TRAP_ERROR <-
  ((== Tb_init_error Termbox.Bindings.C._TB_EPIPE_TRAP_ERROR) -> True)
  where
    TB_EPIPE_TRAP_ERROR = CInt -> Tb_init_error
Tb_init_error CInt
Termbox.Bindings.C._TB_EPIPE_TRAP_ERROR

pattern TB_EUNSUPPORTED_TERMINAL :: Tb_init_error
pattern $bTB_EUNSUPPORTED_TERMINAL :: Tb_init_error
$mTB_EUNSUPPORTED_TERMINAL :: forall {r}. Tb_init_error -> ((# #) -> r) -> ((# #) -> r) -> r
TB_EUNSUPPORTED_TERMINAL <-
  ((== Tb_init_error Termbox.Bindings.C._TB_EUNSUPPORTED_TERMINAL) -> True)
  where
    TB_EUNSUPPORTED_TERMINAL = CInt -> Tb_init_error
Tb_init_error CInt
Termbox.Bindings.C._TB_EUNSUPPORTED_TERMINAL

{-# COMPLETE TB_EFAILED_TO_OPEN_TTY, TB_EPIPE_TRAP_ERROR, TB_EUNSUPPORTED_TERMINAL #-}

-- | The input mode.
newtype Tb_input_mode
  = Tb_input_mode CInt
  deriving stock (Tb_input_mode -> Tb_input_mode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_input_mode -> Tb_input_mode -> Bool
$c/= :: Tb_input_mode -> Tb_input_mode -> Bool
== :: Tb_input_mode -> Tb_input_mode -> Bool
$c== :: Tb_input_mode -> Tb_input_mode -> Bool
Eq, Eq Tb_input_mode
Tb_input_mode -> Tb_input_mode -> Bool
Tb_input_mode -> Tb_input_mode -> Ordering
Tb_input_mode -> Tb_input_mode -> Tb_input_mode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_input_mode -> Tb_input_mode -> Tb_input_mode
$cmin :: Tb_input_mode -> Tb_input_mode -> Tb_input_mode
max :: Tb_input_mode -> Tb_input_mode -> Tb_input_mode
$cmax :: Tb_input_mode -> Tb_input_mode -> Tb_input_mode
>= :: Tb_input_mode -> Tb_input_mode -> Bool
$c>= :: Tb_input_mode -> Tb_input_mode -> Bool
> :: Tb_input_mode -> Tb_input_mode -> Bool
$c> :: Tb_input_mode -> Tb_input_mode -> Bool
<= :: Tb_input_mode -> Tb_input_mode -> Bool
$c<= :: Tb_input_mode -> Tb_input_mode -> Bool
< :: Tb_input_mode -> Tb_input_mode -> Bool
$c< :: Tb_input_mode -> Tb_input_mode -> Bool
compare :: Tb_input_mode -> Tb_input_mode -> Ordering
$ccompare :: Tb_input_mode -> Tb_input_mode -> Ordering
Ord)

instance Show Tb_input_mode where
  show :: Tb_input_mode -> FilePath
show = \case
    Tb_input_mode
TB_INPUT_CURRENT -> FilePath
"TB_INPUT_CURRENT"
    Tb_input_mode
TB_INPUT_ALT -> FilePath
"TB_INPUT_ALT"
    Tb_input_mode
TB_INPUT_ESC -> FilePath
"TB_INPUT_ESC"
    Tb_input_mode
TB_INPUT_MOUSE -> FilePath
"TB_INPUT_MOUSE"

pattern TB_INPUT_CURRENT :: Tb_input_mode
pattern $bTB_INPUT_CURRENT :: Tb_input_mode
$mTB_INPUT_CURRENT :: forall {r}. Tb_input_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_INPUT_CURRENT <-
  ((== Tb_input_mode Termbox.Bindings.C._TB_INPUT_CURRENT) -> True)
  where
    TB_INPUT_CURRENT = CInt -> Tb_input_mode
Tb_input_mode CInt
Termbox.Bindings.C._TB_INPUT_CURRENT

pattern TB_INPUT_ALT :: Tb_input_mode
pattern $bTB_INPUT_ALT :: Tb_input_mode
$mTB_INPUT_ALT :: forall {r}. Tb_input_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_INPUT_ALT <-
  ((== Tb_input_mode Termbox.Bindings.C._TB_INPUT_ALT) -> True)
  where
    TB_INPUT_ALT = CInt -> Tb_input_mode
Tb_input_mode CInt
Termbox.Bindings.C._TB_INPUT_ALT

pattern TB_INPUT_ESC :: Tb_input_mode
pattern $bTB_INPUT_ESC :: Tb_input_mode
$mTB_INPUT_ESC :: forall {r}. Tb_input_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_INPUT_ESC <-
  ((== Tb_input_mode Termbox.Bindings.C._TB_INPUT_ESC) -> True)
  where
    TB_INPUT_ESC = CInt -> Tb_input_mode
Tb_input_mode CInt
Termbox.Bindings.C._TB_INPUT_ESC

pattern TB_INPUT_MOUSE :: Tb_input_mode
pattern $bTB_INPUT_MOUSE :: Tb_input_mode
$mTB_INPUT_MOUSE :: forall {r}. Tb_input_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_INPUT_MOUSE <-
  ((== Tb_input_mode Termbox.Bindings.C._TB_INPUT_MOUSE) -> True)
  where
    TB_INPUT_MOUSE = CInt -> Tb_input_mode
Tb_input_mode CInt
Termbox.Bindings.C._TB_INPUT_MOUSE

{-# COMPLETE TB_INPUT_CURRENT, TB_INPUT_ALT, TB_INPUT_ESC, TB_INPUT_MOUSE #-}

newtype Tb_key
  = Tb_key Word16
  deriving stock (Tb_key -> Tb_key -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_key -> Tb_key -> Bool
$c/= :: Tb_key -> Tb_key -> Bool
== :: Tb_key -> Tb_key -> Bool
$c== :: Tb_key -> Tb_key -> Bool
Eq, Eq Tb_key
Tb_key -> Tb_key -> Bool
Tb_key -> Tb_key -> Ordering
Tb_key -> Tb_key -> Tb_key
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_key -> Tb_key -> Tb_key
$cmin :: Tb_key -> Tb_key -> Tb_key
max :: Tb_key -> Tb_key -> Tb_key
$cmax :: Tb_key -> Tb_key -> Tb_key
>= :: Tb_key -> Tb_key -> Bool
$c>= :: Tb_key -> Tb_key -> Bool
> :: Tb_key -> Tb_key -> Bool
$c> :: Tb_key -> Tb_key -> Bool
<= :: Tb_key -> Tb_key -> Bool
$c<= :: Tb_key -> Tb_key -> Bool
< :: Tb_key -> Tb_key -> Bool
$c< :: Tb_key -> Tb_key -> Bool
compare :: Tb_key -> Tb_key -> Ordering
$ccompare :: Tb_key -> Tb_key -> Ordering
Ord)

instance Show Tb_key where
  show :: Tb_key -> FilePath
show = \case
    Tb_key
TB_KEY_F1 -> FilePath
"TB_KEY_F1"
    Tb_key
TB_KEY_F2 -> FilePath
"TB_KEY_F2"
    Tb_key
TB_KEY_F3 -> FilePath
"TB_KEY_F3"
    Tb_key
TB_KEY_F4 -> FilePath
"TB_KEY_F4"
    Tb_key
TB_KEY_F5 -> FilePath
"TB_KEY_F5"
    Tb_key
TB_KEY_F6 -> FilePath
"TB_KEY_F6"
    Tb_key
TB_KEY_F7 -> FilePath
"TB_KEY_F7"
    Tb_key
TB_KEY_F8 -> FilePath
"TB_KEY_F8"
    Tb_key
TB_KEY_F9 -> FilePath
"TB_KEY_F9"
    Tb_key
TB_KEY_F10 -> FilePath
"TB_KEY_F10"
    Tb_key
TB_KEY_F11 -> FilePath
"TB_KEY_F11"
    Tb_key
TB_KEY_F12 -> FilePath
"TB_KEY_F12"
    Tb_key
TB_KEY_INSERT -> FilePath
"TB_KEY_INSERT"
    Tb_key
TB_KEY_DELETE -> FilePath
"TB_KEY_DELETE"
    Tb_key
TB_KEY_HOME -> FilePath
"TB_KEY_HOME"
    Tb_key
TB_KEY_END -> FilePath
"TB_KEY_END"
    Tb_key
TB_KEY_PGUP -> FilePath
"TB_KEY_PGUP"
    Tb_key
TB_KEY_PGDN -> FilePath
"TB_KEY_PGDN"
    Tb_key
TB_KEY_ARROW_UP -> FilePath
"TB_KEY_ARROW_UP"
    Tb_key
TB_KEY_ARROW_DOWN -> FilePath
"TB_KEY_ARROW_DOWN"
    Tb_key
TB_KEY_ARROW_LEFT -> FilePath
"TB_KEY_ARROW_LEFT"
    Tb_key
TB_KEY_ARROW_RIGHT -> FilePath
"TB_KEY_ARROW_RIGHT"
    Tb_key
TB_KEY_MOUSE_LEFT -> FilePath
"TB_KEY_MOUSE_LEFT"
    Tb_key
TB_KEY_MOUSE_RIGHT -> FilePath
"TB_KEY_MOUSE_RIGHT"
    Tb_key
TB_KEY_MOUSE_MIDDLE -> FilePath
"TB_KEY_MOUSE_MIDDLE"
    Tb_key
TB_KEY_MOUSE_RELEASE -> FilePath
"TB_KEY_MOUSE_RELEASE"
    Tb_key
TB_KEY_MOUSE_WHEEL_UP -> FilePath
"TB_KEY_MOUSE_WHEEL_UP"
    Tb_key
TB_KEY_MOUSE_WHEEL_DOWN -> FilePath
"TB_KEY_MOUSE_WHEEL_DOWN"
    Tb_key
TB_KEY_CTRL_TILDE -> FilePath
"TB_KEY_CTRL_TILDE"
    Tb_key
TB_KEY_CTRL_A -> FilePath
"TB_KEY_CTRL_A"
    Tb_key
TB_KEY_CTRL_B -> FilePath
"TB_KEY_CTRL_B"
    Tb_key
TB_KEY_CTRL_C -> FilePath
"TB_KEY_CTRL_C"
    Tb_key
TB_KEY_CTRL_D -> FilePath
"TB_KEY_CTRL_D"
    Tb_key
TB_KEY_CTRL_E -> FilePath
"TB_KEY_CTRL_E"
    Tb_key
TB_KEY_CTRL_F -> FilePath
"TB_KEY_CTRL_F"
    Tb_key
TB_KEY_CTRL_G -> FilePath
"TB_KEY_CTRL_G"
    Tb_key
TB_KEY_BACKSPACE -> FilePath
"TB_KEY_BACKSPACE"
    Tb_key
TB_KEY_TAB -> FilePath
"TB_KEY_TAB"
    Tb_key
TB_KEY_CTRL_J -> FilePath
"TB_KEY_CTRL_J"
    Tb_key
TB_KEY_CTRL_K -> FilePath
"TB_KEY_CTRL_K"
    Tb_key
TB_KEY_CTRL_L -> FilePath
"TB_KEY_CTRL_L"
    Tb_key
TB_KEY_ENTER -> FilePath
"TB_KEY_ENTER"
    Tb_key
TB_KEY_CTRL_N -> FilePath
"TB_KEY_CTRL_N"
    Tb_key
TB_KEY_CTRL_O -> FilePath
"TB_KEY_CTRL_O"
    Tb_key
TB_KEY_CTRL_P -> FilePath
"TB_KEY_CTRL_P"
    Tb_key
TB_KEY_CTRL_Q -> FilePath
"TB_KEY_CTRL_Q"
    Tb_key
TB_KEY_CTRL_R -> FilePath
"TB_KEY_CTRL_R"
    Tb_key
TB_KEY_CTRL_S -> FilePath
"TB_KEY_CTRL_S"
    Tb_key
TB_KEY_CTRL_T -> FilePath
"TB_KEY_CTRL_T"
    Tb_key
TB_KEY_CTRL_U -> FilePath
"TB_KEY_CTRL_U"
    Tb_key
TB_KEY_CTRL_V -> FilePath
"TB_KEY_CTRL_V"
    Tb_key
TB_KEY_CTRL_W -> FilePath
"TB_KEY_CTRL_W"
    Tb_key
TB_KEY_CTRL_X -> FilePath
"TB_KEY_CTRL_X"
    Tb_key
TB_KEY_CTRL_Y -> FilePath
"TB_KEY_CTRL_Y"
    Tb_key
TB_KEY_CTRL_Z -> FilePath
"TB_KEY_CTRL_Z"
    Tb_key
TB_KEY_ESC -> FilePath
"TB_KEY_ESC"
    Tb_key
TB_KEY_CTRL_4 -> FilePath
"TB_KEY_CTRL_4"
    Tb_key
TB_KEY_CTRL_5 -> FilePath
"TB_KEY_CTRL_5"
    Tb_key
TB_KEY_CTRL_6 -> FilePath
"TB_KEY_CTRL_6"
    Tb_key
TB_KEY_CTRL_7 -> FilePath
"TB_KEY_CTRL_7"
    Tb_key
TB_KEY_SPACE -> FilePath
"TB_KEY_SPACE"
    Tb_key
TB_KEY_BACKSPACE2 -> FilePath
"TB_KEY_BACKSPACE2"
    Tb_key
k -> forall a. HasCallStack => FilePath -> a
error (FilePath
"Unknown key: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show Tb_key
k)

pattern TB_KEY_ARROW_DOWN :: Tb_key
pattern $bTB_KEY_ARROW_DOWN :: Tb_key
$mTB_KEY_ARROW_DOWN :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ARROW_DOWN <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ARROW_DOWN) -> True)
  where
    TB_KEY_ARROW_DOWN = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ARROW_DOWN

pattern TB_KEY_ARROW_LEFT :: Tb_key
pattern $bTB_KEY_ARROW_LEFT :: Tb_key
$mTB_KEY_ARROW_LEFT :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ARROW_LEFT <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ARROW_LEFT) -> True)
  where
    TB_KEY_ARROW_LEFT = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ARROW_LEFT

pattern TB_KEY_ARROW_RIGHT :: Tb_key
pattern $bTB_KEY_ARROW_RIGHT :: Tb_key
$mTB_KEY_ARROW_RIGHT :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ARROW_RIGHT <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ARROW_RIGHT) -> True)
  where
    TB_KEY_ARROW_RIGHT = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ARROW_RIGHT

pattern TB_KEY_ARROW_UP :: Tb_key
pattern $bTB_KEY_ARROW_UP :: Tb_key
$mTB_KEY_ARROW_UP :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ARROW_UP <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ARROW_UP) -> True)
  where
    TB_KEY_ARROW_UP = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ARROW_UP

pattern TB_KEY_BACKSPACE :: Tb_key
pattern $bTB_KEY_BACKSPACE :: Tb_key
$mTB_KEY_BACKSPACE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_BACKSPACE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_BACKSPACE) -> True)
  where
    TB_KEY_BACKSPACE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_BACKSPACE

pattern TB_KEY_BACKSPACE2 :: Tb_key
pattern $bTB_KEY_BACKSPACE2 :: Tb_key
$mTB_KEY_BACKSPACE2 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_BACKSPACE2 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_BACKSPACE2) -> True)
  where
    TB_KEY_BACKSPACE2 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_BACKSPACE2

pattern TB_KEY_CTRL_2 :: Tb_key
pattern $bTB_KEY_CTRL_2 :: Tb_key
$mTB_KEY_CTRL_2 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_2 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_2) -> True)
  where
    TB_KEY_CTRL_2 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_2

pattern TB_KEY_CTRL_3 :: Tb_key
pattern $bTB_KEY_CTRL_3 :: Tb_key
$mTB_KEY_CTRL_3 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_3 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_3) -> True)
  where
    TB_KEY_CTRL_3 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_3

pattern TB_KEY_CTRL_4 :: Tb_key
pattern $bTB_KEY_CTRL_4 :: Tb_key
$mTB_KEY_CTRL_4 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_4 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_4) -> True)
  where
    TB_KEY_CTRL_4 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_4

pattern TB_KEY_CTRL_5 :: Tb_key
pattern $bTB_KEY_CTRL_5 :: Tb_key
$mTB_KEY_CTRL_5 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_5 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_5) -> True)
  where
    TB_KEY_CTRL_5 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_5

pattern TB_KEY_CTRL_6 :: Tb_key
pattern $bTB_KEY_CTRL_6 :: Tb_key
$mTB_KEY_CTRL_6 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_6 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_6) -> True)
  where
    TB_KEY_CTRL_6 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_6

pattern TB_KEY_CTRL_7 :: Tb_key
pattern $bTB_KEY_CTRL_7 :: Tb_key
$mTB_KEY_CTRL_7 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_7 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_7) -> True)
  where
    TB_KEY_CTRL_7 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_7

pattern TB_KEY_CTRL_8 :: Tb_key
pattern $bTB_KEY_CTRL_8 :: Tb_key
$mTB_KEY_CTRL_8 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_8 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_8) -> True)
  where
    TB_KEY_CTRL_8 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_8

pattern TB_KEY_CTRL_A :: Tb_key
pattern $bTB_KEY_CTRL_A :: Tb_key
$mTB_KEY_CTRL_A :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_A <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_A) -> True)
  where
    TB_KEY_CTRL_A = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_A

pattern TB_KEY_CTRL_B :: Tb_key
pattern $bTB_KEY_CTRL_B :: Tb_key
$mTB_KEY_CTRL_B :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_B <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_B) -> True)
  where
    TB_KEY_CTRL_B = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_B

pattern TB_KEY_CTRL_BACKSLASH :: Tb_key
pattern $bTB_KEY_CTRL_BACKSLASH :: Tb_key
$mTB_KEY_CTRL_BACKSLASH :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_BACKSLASH <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_BACKSLASH) -> True)
  where
    TB_KEY_CTRL_BACKSLASH = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_BACKSLASH

pattern TB_KEY_CTRL_C :: Tb_key
pattern $bTB_KEY_CTRL_C :: Tb_key
$mTB_KEY_CTRL_C :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_C <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_C) -> True)
  where
    TB_KEY_CTRL_C = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_C

pattern TB_KEY_CTRL_D :: Tb_key
pattern $bTB_KEY_CTRL_D :: Tb_key
$mTB_KEY_CTRL_D :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_D <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_D) -> True)
  where
    TB_KEY_CTRL_D = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_D

pattern TB_KEY_CTRL_E :: Tb_key
pattern $bTB_KEY_CTRL_E :: Tb_key
$mTB_KEY_CTRL_E :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_E <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_E) -> True)
  where
    TB_KEY_CTRL_E = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_E

pattern TB_KEY_CTRL_F :: Tb_key
pattern $bTB_KEY_CTRL_F :: Tb_key
$mTB_KEY_CTRL_F :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_F <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_F) -> True)
  where
    TB_KEY_CTRL_F = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_F

pattern TB_KEY_CTRL_G :: Tb_key
pattern $bTB_KEY_CTRL_G :: Tb_key
$mTB_KEY_CTRL_G :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_G <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_G) -> True)
  where
    TB_KEY_CTRL_G = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_G

pattern TB_KEY_CTRL_H :: Tb_key
pattern $bTB_KEY_CTRL_H :: Tb_key
$mTB_KEY_CTRL_H :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_H <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_H) -> True)
  where
    TB_KEY_CTRL_H = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_H

pattern TB_KEY_CTRL_I :: Tb_key
pattern $bTB_KEY_CTRL_I :: Tb_key
$mTB_KEY_CTRL_I :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_I <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_I) -> True)
  where
    TB_KEY_CTRL_I = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_I

pattern TB_KEY_CTRL_J :: Tb_key
pattern $bTB_KEY_CTRL_J :: Tb_key
$mTB_KEY_CTRL_J :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_J <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_J) -> True)
  where
    TB_KEY_CTRL_J = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_J

pattern TB_KEY_CTRL_K :: Tb_key
pattern $bTB_KEY_CTRL_K :: Tb_key
$mTB_KEY_CTRL_K :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_K <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_K) -> True)
  where
    TB_KEY_CTRL_K = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_K

pattern TB_KEY_CTRL_L :: Tb_key
pattern $bTB_KEY_CTRL_L :: Tb_key
$mTB_KEY_CTRL_L :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_L <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_L) -> True)
  where
    TB_KEY_CTRL_L = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_L

pattern TB_KEY_CTRL_LSQ_BRACKET :: Tb_key
pattern $bTB_KEY_CTRL_LSQ_BRACKET :: Tb_key
$mTB_KEY_CTRL_LSQ_BRACKET :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_LSQ_BRACKET <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_LSQ_BRACKET) -> True)
  where
    TB_KEY_CTRL_LSQ_BRACKET = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_LSQ_BRACKET

pattern TB_KEY_CTRL_M :: Tb_key
pattern $bTB_KEY_CTRL_M :: Tb_key
$mTB_KEY_CTRL_M :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_M <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_M) -> True)
  where
    TB_KEY_CTRL_M = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_M

pattern TB_KEY_CTRL_N :: Tb_key
pattern $bTB_KEY_CTRL_N :: Tb_key
$mTB_KEY_CTRL_N :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_N <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_N) -> True)
  where
    TB_KEY_CTRL_N = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_N

pattern TB_KEY_CTRL_O :: Tb_key
pattern $bTB_KEY_CTRL_O :: Tb_key
$mTB_KEY_CTRL_O :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_O <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_O) -> True)
  where
    TB_KEY_CTRL_O = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_O

pattern TB_KEY_CTRL_P :: Tb_key
pattern $bTB_KEY_CTRL_P :: Tb_key
$mTB_KEY_CTRL_P :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_P <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_P) -> True)
  where
    TB_KEY_CTRL_P = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_P

pattern TB_KEY_CTRL_Q :: Tb_key
pattern $bTB_KEY_CTRL_Q :: Tb_key
$mTB_KEY_CTRL_Q :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_Q <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_Q) -> True)
  where
    TB_KEY_CTRL_Q = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_Q

pattern TB_KEY_CTRL_R :: Tb_key
pattern $bTB_KEY_CTRL_R :: Tb_key
$mTB_KEY_CTRL_R :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_R <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_R) -> True)
  where
    TB_KEY_CTRL_R = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_R

pattern TB_KEY_CTRL_RSQ_BRACKET :: Tb_key
pattern $bTB_KEY_CTRL_RSQ_BRACKET :: Tb_key
$mTB_KEY_CTRL_RSQ_BRACKET :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_RSQ_BRACKET <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_RSQ_BRACKET) -> True)
  where
    TB_KEY_CTRL_RSQ_BRACKET = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_RSQ_BRACKET

pattern TB_KEY_CTRL_S :: Tb_key
pattern $bTB_KEY_CTRL_S :: Tb_key
$mTB_KEY_CTRL_S :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_S <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_S) -> True)
  where
    TB_KEY_CTRL_S = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_S

pattern TB_KEY_CTRL_SLASH :: Tb_key
pattern $bTB_KEY_CTRL_SLASH :: Tb_key
$mTB_KEY_CTRL_SLASH :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_SLASH <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_SLASH) -> True)
  where
    TB_KEY_CTRL_SLASH = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_SLASH

pattern TB_KEY_CTRL_T :: Tb_key
pattern $bTB_KEY_CTRL_T :: Tb_key
$mTB_KEY_CTRL_T :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_T <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_T) -> True)
  where
    TB_KEY_CTRL_T = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_T

pattern TB_KEY_CTRL_TILDE :: Tb_key
pattern $bTB_KEY_CTRL_TILDE :: Tb_key
$mTB_KEY_CTRL_TILDE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_TILDE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_TILDE) -> True)
  where
    TB_KEY_CTRL_TILDE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_TILDE

pattern TB_KEY_CTRL_U :: Tb_key
pattern $bTB_KEY_CTRL_U :: Tb_key
$mTB_KEY_CTRL_U :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_U <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_U) -> True)
  where
    TB_KEY_CTRL_U = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_U

pattern TB_KEY_CTRL_UNDERSCORE :: Tb_key
pattern $bTB_KEY_CTRL_UNDERSCORE :: Tb_key
$mTB_KEY_CTRL_UNDERSCORE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_UNDERSCORE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_UNDERSCORE) -> True)
  where
    TB_KEY_CTRL_UNDERSCORE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_UNDERSCORE

pattern TB_KEY_CTRL_V :: Tb_key
pattern $bTB_KEY_CTRL_V :: Tb_key
$mTB_KEY_CTRL_V :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_V <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_V) -> True)
  where
    TB_KEY_CTRL_V = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_V

pattern TB_KEY_CTRL_W :: Tb_key
pattern $bTB_KEY_CTRL_W :: Tb_key
$mTB_KEY_CTRL_W :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_W <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_W) -> True)
  where
    TB_KEY_CTRL_W = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_W

pattern TB_KEY_CTRL_X :: Tb_key
pattern $bTB_KEY_CTRL_X :: Tb_key
$mTB_KEY_CTRL_X :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_X <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_X) -> True)
  where
    TB_KEY_CTRL_X = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_X

pattern TB_KEY_CTRL_Y :: Tb_key
pattern $bTB_KEY_CTRL_Y :: Tb_key
$mTB_KEY_CTRL_Y :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_Y <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_Y) -> True)
  where
    TB_KEY_CTRL_Y = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_Y

pattern TB_KEY_CTRL_Z :: Tb_key
pattern $bTB_KEY_CTRL_Z :: Tb_key
$mTB_KEY_CTRL_Z :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_CTRL_Z <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_CTRL_Z) -> True)
  where
    TB_KEY_CTRL_Z = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_CTRL_Z

pattern TB_KEY_DELETE :: Tb_key
pattern $bTB_KEY_DELETE :: Tb_key
$mTB_KEY_DELETE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_DELETE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_DELETE) -> True)
  where
    TB_KEY_DELETE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_DELETE

pattern TB_KEY_END :: Tb_key
pattern $bTB_KEY_END :: Tb_key
$mTB_KEY_END :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_END <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_END) -> True)
  where
    TB_KEY_END = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_END

pattern TB_KEY_ENTER :: Tb_key
pattern $bTB_KEY_ENTER :: Tb_key
$mTB_KEY_ENTER :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ENTER <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ENTER) -> True)
  where
    TB_KEY_ENTER = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ENTER

pattern TB_KEY_ESC :: Tb_key
pattern $bTB_KEY_ESC :: Tb_key
$mTB_KEY_ESC :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_ESC <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_ESC) -> True)
  where
    TB_KEY_ESC = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_ESC

pattern TB_KEY_F1 :: Tb_key
pattern $bTB_KEY_F1 :: Tb_key
$mTB_KEY_F1 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F1 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F1) -> True)
  where
    TB_KEY_F1 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F1

pattern TB_KEY_F10 :: Tb_key
pattern $bTB_KEY_F10 :: Tb_key
$mTB_KEY_F10 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F10 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F10) -> True)
  where
    TB_KEY_F10 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F10

pattern TB_KEY_F11 :: Tb_key
pattern $bTB_KEY_F11 :: Tb_key
$mTB_KEY_F11 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F11 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F11) -> True)
  where
    TB_KEY_F11 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F11

pattern TB_KEY_F12 :: Tb_key
pattern $bTB_KEY_F12 :: Tb_key
$mTB_KEY_F12 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F12 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F12) -> True)
  where
    TB_KEY_F12 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F12

pattern TB_KEY_F2 :: Tb_key
pattern $bTB_KEY_F2 :: Tb_key
$mTB_KEY_F2 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F2 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F2) -> True)
  where
    TB_KEY_F2 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F2

pattern TB_KEY_F3 :: Tb_key
pattern $bTB_KEY_F3 :: Tb_key
$mTB_KEY_F3 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F3 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F3) -> True)
  where
    TB_KEY_F3 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F3

pattern TB_KEY_F4 :: Tb_key
pattern $bTB_KEY_F4 :: Tb_key
$mTB_KEY_F4 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F4 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F4) -> True)
  where
    TB_KEY_F4 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F4

pattern TB_KEY_F5 :: Tb_key
pattern $bTB_KEY_F5 :: Tb_key
$mTB_KEY_F5 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F5 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F5) -> True)
  where
    TB_KEY_F5 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F5

pattern TB_KEY_F6 :: Tb_key
pattern $bTB_KEY_F6 :: Tb_key
$mTB_KEY_F6 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F6 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F6) -> True)
  where
    TB_KEY_F6 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F6

pattern TB_KEY_F7 :: Tb_key
pattern $bTB_KEY_F7 :: Tb_key
$mTB_KEY_F7 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F7 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F7) -> True)
  where
    TB_KEY_F7 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F7

pattern TB_KEY_F8 :: Tb_key
pattern $bTB_KEY_F8 :: Tb_key
$mTB_KEY_F8 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F8 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F8) -> True)
  where
    TB_KEY_F8 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F8

pattern TB_KEY_F9 :: Tb_key
pattern $bTB_KEY_F9 :: Tb_key
$mTB_KEY_F9 :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_F9 <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_F9) -> True)
  where
    TB_KEY_F9 = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_F9

pattern TB_KEY_HOME :: Tb_key
pattern $bTB_KEY_HOME :: Tb_key
$mTB_KEY_HOME :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_HOME <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_HOME) -> True)
  where
    TB_KEY_HOME = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_HOME

pattern TB_KEY_INSERT :: Tb_key
pattern $bTB_KEY_INSERT :: Tb_key
$mTB_KEY_INSERT :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_INSERT <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_INSERT) -> True)
  where
    TB_KEY_INSERT = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_INSERT

pattern TB_KEY_MOUSE_LEFT :: Tb_key
pattern $bTB_KEY_MOUSE_LEFT :: Tb_key
$mTB_KEY_MOUSE_LEFT :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_LEFT <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_LEFT) -> True)
  where
    TB_KEY_MOUSE_LEFT = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_LEFT

pattern TB_KEY_MOUSE_MIDDLE :: Tb_key
pattern $bTB_KEY_MOUSE_MIDDLE :: Tb_key
$mTB_KEY_MOUSE_MIDDLE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_MIDDLE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_MIDDLE) -> True)
  where
    TB_KEY_MOUSE_MIDDLE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_MIDDLE

pattern TB_KEY_MOUSE_RELEASE :: Tb_key
pattern $bTB_KEY_MOUSE_RELEASE :: Tb_key
$mTB_KEY_MOUSE_RELEASE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_RELEASE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_RELEASE) -> True)
  where
    TB_KEY_MOUSE_RELEASE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_RELEASE

pattern TB_KEY_MOUSE_RIGHT :: Tb_key
pattern $bTB_KEY_MOUSE_RIGHT :: Tb_key
$mTB_KEY_MOUSE_RIGHT :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_RIGHT <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_RIGHT) -> True)
  where
    TB_KEY_MOUSE_RIGHT = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_RIGHT

pattern TB_KEY_MOUSE_WHEEL_DOWN :: Tb_key
pattern $bTB_KEY_MOUSE_WHEEL_DOWN :: Tb_key
$mTB_KEY_MOUSE_WHEEL_DOWN :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_WHEEL_DOWN <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_WHEEL_DOWN) -> True)
  where
    TB_KEY_MOUSE_WHEEL_DOWN = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_WHEEL_DOWN

pattern TB_KEY_MOUSE_WHEEL_UP :: Tb_key
pattern $bTB_KEY_MOUSE_WHEEL_UP :: Tb_key
$mTB_KEY_MOUSE_WHEEL_UP :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_MOUSE_WHEEL_UP <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_MOUSE_WHEEL_UP) -> True)
  where
    TB_KEY_MOUSE_WHEEL_UP = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_MOUSE_WHEEL_UP

pattern TB_KEY_PGDN :: Tb_key
pattern $bTB_KEY_PGDN :: Tb_key
$mTB_KEY_PGDN :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_PGDN <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_PGDN) -> True)
  where
    TB_KEY_PGDN = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_PGDN

pattern TB_KEY_PGUP :: Tb_key
pattern $bTB_KEY_PGUP :: Tb_key
$mTB_KEY_PGUP :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_PGUP <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_PGUP) -> True)
  where
    TB_KEY_PGUP = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_PGUP

pattern TB_KEY_SPACE :: Tb_key
pattern $bTB_KEY_SPACE :: Tb_key
$mTB_KEY_SPACE :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_SPACE <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_SPACE) -> True)
  where
    TB_KEY_SPACE = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_SPACE

pattern TB_KEY_TAB :: Tb_key
pattern $bTB_KEY_TAB :: Tb_key
$mTB_KEY_TAB :: forall {r}. Tb_key -> ((# #) -> r) -> ((# #) -> r) -> r
TB_KEY_TAB <-
  ((== Tb_key Termbox.Bindings.C._TB_KEY_TAB) -> True)
  where
    TB_KEY_TAB = Word16 -> Tb_key
Tb_key Word16
Termbox.Bindings.C._TB_KEY_TAB

-- | The output mode.
newtype Tb_output_mode
  = Tb_output_mode CInt
  deriving stock (Tb_output_mode -> Tb_output_mode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tb_output_mode -> Tb_output_mode -> Bool
$c/= :: Tb_output_mode -> Tb_output_mode -> Bool
== :: Tb_output_mode -> Tb_output_mode -> Bool
$c== :: Tb_output_mode -> Tb_output_mode -> Bool
Eq, Eq Tb_output_mode
Tb_output_mode -> Tb_output_mode -> Bool
Tb_output_mode -> Tb_output_mode -> Ordering
Tb_output_mode -> Tb_output_mode -> Tb_output_mode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tb_output_mode -> Tb_output_mode -> Tb_output_mode
$cmin :: Tb_output_mode -> Tb_output_mode -> Tb_output_mode
max :: Tb_output_mode -> Tb_output_mode -> Tb_output_mode
$cmax :: Tb_output_mode -> Tb_output_mode -> Tb_output_mode
>= :: Tb_output_mode -> Tb_output_mode -> Bool
$c>= :: Tb_output_mode -> Tb_output_mode -> Bool
> :: Tb_output_mode -> Tb_output_mode -> Bool
$c> :: Tb_output_mode -> Tb_output_mode -> Bool
<= :: Tb_output_mode -> Tb_output_mode -> Bool
$c<= :: Tb_output_mode -> Tb_output_mode -> Bool
< :: Tb_output_mode -> Tb_output_mode -> Bool
$c< :: Tb_output_mode -> Tb_output_mode -> Bool
compare :: Tb_output_mode -> Tb_output_mode -> Ordering
$ccompare :: Tb_output_mode -> Tb_output_mode -> Ordering
Ord)

instance Show Tb_output_mode where
  show :: Tb_output_mode -> FilePath
show = \case
    Tb_output_mode
TB_OUTPUT_CURRENT -> FilePath
"TB_OUTPUT_CURRENT"
    Tb_output_mode
TB_OUTPUT_216 -> FilePath
"TB_OUTPUT_216"
    Tb_output_mode
TB_OUTPUT_256 -> FilePath
"TB_OUTPUT_256"
    Tb_output_mode
TB_OUTPUT_GRAYSCALE -> FilePath
"TB_OUTPUT_GRAYSCALE"
    Tb_output_mode
TB_OUTPUT_NORMAL -> FilePath
"TB_OUTPUT_NORMAL"

pattern TB_OUTPUT_CURRENT :: Tb_output_mode
pattern $bTB_OUTPUT_CURRENT :: Tb_output_mode
$mTB_OUTPUT_CURRENT :: forall {r}. Tb_output_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_OUTPUT_CURRENT <-
  ((== Tb_output_mode Termbox.Bindings.C._TB_OUTPUT_CURRENT) -> True)
  where
    TB_OUTPUT_CURRENT = CInt -> Tb_output_mode
Tb_output_mode CInt
Termbox.Bindings.C._TB_OUTPUT_CURRENT

pattern TB_OUTPUT_216 :: Tb_output_mode
pattern $bTB_OUTPUT_216 :: Tb_output_mode
$mTB_OUTPUT_216 :: forall {r}. Tb_output_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_OUTPUT_216 <-
  ((== Tb_output_mode Termbox.Bindings.C._TB_OUTPUT_216) -> True)
  where
    TB_OUTPUT_216 = CInt -> Tb_output_mode
Tb_output_mode CInt
Termbox.Bindings.C._TB_OUTPUT_216

pattern TB_OUTPUT_256 :: Tb_output_mode
pattern $bTB_OUTPUT_256 :: Tb_output_mode
$mTB_OUTPUT_256 :: forall {r}. Tb_output_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_OUTPUT_256 <-
  ((== Tb_output_mode Termbox.Bindings.C._TB_OUTPUT_256) -> True)
  where
    TB_OUTPUT_256 = CInt -> Tb_output_mode
Tb_output_mode CInt
Termbox.Bindings.C._TB_OUTPUT_256

pattern TB_OUTPUT_GRAYSCALE :: Tb_output_mode
pattern $bTB_OUTPUT_GRAYSCALE :: Tb_output_mode
$mTB_OUTPUT_GRAYSCALE :: forall {r}. Tb_output_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_OUTPUT_GRAYSCALE <-
  ((== Tb_output_mode Termbox.Bindings.C._TB_OUTPUT_GRAYSCALE) -> True)
  where
    TB_OUTPUT_GRAYSCALE = CInt -> Tb_output_mode
Tb_output_mode CInt
Termbox.Bindings.C._TB_OUTPUT_GRAYSCALE

pattern TB_OUTPUT_NORMAL :: Tb_output_mode
pattern $bTB_OUTPUT_NORMAL :: Tb_output_mode
$mTB_OUTPUT_NORMAL :: forall {r}. Tb_output_mode -> ((# #) -> r) -> ((# #) -> r) -> r
TB_OUTPUT_NORMAL <-
  ((== Tb_output_mode Termbox.Bindings.C._TB_OUTPUT_NORMAL) -> True)
  where
    TB_OUTPUT_NORMAL = CInt -> Tb_output_mode
Tb_output_mode CInt
Termbox.Bindings.C._TB_OUTPUT_NORMAL

{-# COMPLETE TB_OUTPUT_CURRENT, TB_OUTPUT_216, TB_OUTPUT_256, TB_OUTPUT_GRAYSCALE, TB_OUTPUT_NORMAL #-}

--

charToWord32 :: Char -> Word32
charToWord32 :: Char -> Word32
charToWord32 =
  forall a b. (Integral a, Num b) => a -> b
fromIntegral @Int @Word32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
Char.ord
{-# INLINE charToWord32 #-}

word32ToChar :: Word32 -> Char
word32ToChar :: Word32 -> Char
word32ToChar =
  Int -> Char
Char.chr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word32 @Int
{-# INLINE word32ToChar #-}

cintToInt :: CInt -> Int
cintToInt :: CInt -> Int
cintToInt =
  forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE cintToInt #-}

intToCInt :: Int -> CInt
intToCInt :: Int -> CInt
intToCInt =
  forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE intToCInt #-}