{-# LINE 1 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface, CPP #-}

-- | This module provides a function to obtain input events from the Win32 API

module Graphics.Vty.Platform.Windows.WindowsConsoleInput
    (KeyEventRecord(..),
     MouseEventRecord(..),
     WindowBufferSizeRecord(..),
     MenuEventRecord(..),
     FocusEventRecord(..),
     WinConsoleInputEvent(..),
     readConsoleInput) where

import Control.Monad (foldM)
import Foreign.C.Types ( CWchar(..) )
import Foreign.Marshal.Alloc (alloca)
import Foreign.Storable (Storable(..))
import GHC.Ptr ( Ptr )
import System.Win32.Console
import System.Win32.Types
import System.IO (Handle)



foreign import ccall unsafe "windows.h ReadConsoleInputW" cReadConsoleInput :: HANDLE -> Ptr WinConsoleInputEvent -> DWORD -> LPDWORD -> IO BOOL

-- | This type represents a keyboard input event. The structure is documented here:

-- https://learn.microsoft.com/en-us/windows/console/key-event-record-str

data KeyEventRecord = KeyEventRecordC
  { KeyEventRecord -> BOOL
keyDown :: BOOL
  , KeyEventRecord -> WORD
repeatCount :: WORD
  , KeyEventRecord -> WORD
virtualKeyCode :: WORD
  , KeyEventRecord -> WORD
virtualScanCode :: WORD
  , KeyEventRecord -> CWchar
uChar :: CWchar
  , KeyEventRecord -> DWORD
controlKeyStateK :: DWORD
  } deriving (KeyEventRecord -> KeyEventRecord -> BOOL
(KeyEventRecord -> KeyEventRecord -> BOOL)
-> (KeyEventRecord -> KeyEventRecord -> BOOL) -> Eq KeyEventRecord
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: KeyEventRecord -> KeyEventRecord -> BOOL
== :: KeyEventRecord -> KeyEventRecord -> BOOL
$c/= :: KeyEventRecord -> KeyEventRecord -> BOOL
/= :: KeyEventRecord -> KeyEventRecord -> BOOL
Eq, Int -> KeyEventRecord -> ShowS
[KeyEventRecord] -> ShowS
KeyEventRecord -> String
(Int -> KeyEventRecord -> ShowS)
-> (KeyEventRecord -> String)
-> ([KeyEventRecord] -> ShowS)
-> Show KeyEventRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyEventRecord -> ShowS
showsPrec :: Int -> KeyEventRecord -> ShowS
$cshow :: KeyEventRecord -> String
show :: KeyEventRecord -> String
$cshowList :: [KeyEventRecord] -> ShowS
showList :: [KeyEventRecord] -> ShowS
Show)

-- | This type represents a mouse event. The structure is documented here:

-- https://learn.microsoft.com/en-us/windows/console/mouse-event-record-str

data MouseEventRecord = MouseEventRecordC
  { MouseEventRecord -> COORD
mousePosition :: COORD
  , MouseEventRecord -> DWORD
buttonState :: DWORD
  , MouseEventRecord -> DWORD
controlKeyStateM :: DWORD
  , MouseEventRecord -> DWORD
eventFlags :: DWORD
  } deriving (MouseEventRecord -> MouseEventRecord -> BOOL
(MouseEventRecord -> MouseEventRecord -> BOOL)
-> (MouseEventRecord -> MouseEventRecord -> BOOL)
-> Eq MouseEventRecord
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: MouseEventRecord -> MouseEventRecord -> BOOL
== :: MouseEventRecord -> MouseEventRecord -> BOOL
$c/= :: MouseEventRecord -> MouseEventRecord -> BOOL
/= :: MouseEventRecord -> MouseEventRecord -> BOOL
Eq, Int -> MouseEventRecord -> ShowS
[MouseEventRecord] -> ShowS
MouseEventRecord -> String
(Int -> MouseEventRecord -> ShowS)
-> (MouseEventRecord -> String)
-> ([MouseEventRecord] -> ShowS)
-> Show MouseEventRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MouseEventRecord -> ShowS
showsPrec :: Int -> MouseEventRecord -> ShowS
$cshow :: MouseEventRecord -> String
show :: MouseEventRecord -> String
$cshowList :: [MouseEventRecord] -> ShowS
showList :: [MouseEventRecord] -> ShowS
Show)

-- | This type represents a window size change event. The structure is documented here:

-- https://learn.microsoft.com/en-us/windows/console/window-buffer-size-record-str

newtype WindowBufferSizeRecord = WindowBufferSizeRecordC
  { WindowBufferSizeRecord -> COORD
windowSize :: COORD
  } deriving (WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL
(WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL)
-> (WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL)
-> Eq WindowBufferSizeRecord
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL
== :: WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL
$c/= :: WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL
/= :: WindowBufferSizeRecord -> WindowBufferSizeRecord -> BOOL
Eq, Int -> WindowBufferSizeRecord -> ShowS
[WindowBufferSizeRecord] -> ShowS
WindowBufferSizeRecord -> String
(Int -> WindowBufferSizeRecord -> ShowS)
-> (WindowBufferSizeRecord -> String)
-> ([WindowBufferSizeRecord] -> ShowS)
-> Show WindowBufferSizeRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowBufferSizeRecord -> ShowS
showsPrec :: Int -> WindowBufferSizeRecord -> ShowS
$cshow :: WindowBufferSizeRecord -> String
show :: WindowBufferSizeRecord -> String
$cshowList :: [WindowBufferSizeRecord] -> ShowS
showList :: [WindowBufferSizeRecord] -> ShowS
Show)

-- | This type represents a window menu event. (Current ignored by VTY). The structure

-- is documented here: https://learn.microsoft.com/en-us/windows/console/menu-event-record-str

newtype MenuEventRecord = MenuEventRecordC
  { MenuEventRecord -> DWORD
commandId :: UINT
  } deriving (MenuEventRecord -> MenuEventRecord -> BOOL
(MenuEventRecord -> MenuEventRecord -> BOOL)
-> (MenuEventRecord -> MenuEventRecord -> BOOL)
-> Eq MenuEventRecord
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: MenuEventRecord -> MenuEventRecord -> BOOL
== :: MenuEventRecord -> MenuEventRecord -> BOOL
$c/= :: MenuEventRecord -> MenuEventRecord -> BOOL
/= :: MenuEventRecord -> MenuEventRecord -> BOOL
Eq, Int -> MenuEventRecord -> ShowS
[MenuEventRecord] -> ShowS
MenuEventRecord -> String
(Int -> MenuEventRecord -> ShowS)
-> (MenuEventRecord -> String)
-> ([MenuEventRecord] -> ShowS)
-> Show MenuEventRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MenuEventRecord -> ShowS
showsPrec :: Int -> MenuEventRecord -> ShowS
$cshow :: MenuEventRecord -> String
show :: MenuEventRecord -> String
$cshowList :: [MenuEventRecord] -> ShowS
showList :: [MenuEventRecord] -> ShowS
Show)

-- | This type represents a window focus change event. The structure is documented here:

-- https://learn.microsoft.com/en-us/windows/console/focus-event-record-str

newtype FocusEventRecord = FocusEventRecordC
  { FocusEventRecord -> BOOL
setFocus :: BOOL
  } deriving (FocusEventRecord -> FocusEventRecord -> BOOL
(FocusEventRecord -> FocusEventRecord -> BOOL)
-> (FocusEventRecord -> FocusEventRecord -> BOOL)
-> Eq FocusEventRecord
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: FocusEventRecord -> FocusEventRecord -> BOOL
== :: FocusEventRecord -> FocusEventRecord -> BOOL
$c/= :: FocusEventRecord -> FocusEventRecord -> BOOL
/= :: FocusEventRecord -> FocusEventRecord -> BOOL
Eq, Int -> FocusEventRecord -> ShowS
[FocusEventRecord] -> ShowS
FocusEventRecord -> String
(Int -> FocusEventRecord -> ShowS)
-> (FocusEventRecord -> String)
-> ([FocusEventRecord] -> ShowS)
-> Show FocusEventRecord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FocusEventRecord -> ShowS
showsPrec :: Int -> FocusEventRecord -> ShowS
$cshow :: FocusEventRecord -> String
show :: FocusEventRecord -> String
$cshowList :: [FocusEventRecord] -> ShowS
showList :: [FocusEventRecord] -> ShowS
Show)

-- | Description of a Windows console input event. Documented here:

-- https://learn.microsoft.com/en-us/windows/console/input-record-str

data WinConsoleInputEvent =
    KeyEventRecordU KeyEventRecord
  | MouseEventRecordU MouseEventRecord
  | WindowBufferSizeRecordU WindowBufferSizeRecord
  | MenuEventRecordU MenuEventRecord
  | FocusEventRecordU FocusEventRecord
  deriving (WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL
(WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL)
-> (WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL)
-> Eq WinConsoleInputEvent
forall a. (a -> a -> BOOL) -> (a -> a -> BOOL) -> Eq a
$c== :: WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL
== :: WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL
$c/= :: WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL
/= :: WinConsoleInputEvent -> WinConsoleInputEvent -> BOOL
Eq, Int -> WinConsoleInputEvent -> ShowS
[WinConsoleInputEvent] -> ShowS
WinConsoleInputEvent -> String
(Int -> WinConsoleInputEvent -> ShowS)
-> (WinConsoleInputEvent -> String)
-> ([WinConsoleInputEvent] -> ShowS)
-> Show WinConsoleInputEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WinConsoleInputEvent -> ShowS
showsPrec :: Int -> WinConsoleInputEvent -> ShowS
$cshow :: WinConsoleInputEvent -> String
show :: WinConsoleInputEvent -> String
$cshowList :: [WinConsoleInputEvent] -> ShowS
showList :: [WinConsoleInputEvent] -> ShowS
Show)

-- | A wrapper for the ReadConsoleInput Win32 API as documented here:

-- https://learn.microsoft.com/en-us/windows/console/readconsoleinput

readConsoleInput :: Ptr WinConsoleInputEvent -> Int -> Handle -> IO [WinConsoleInputEvent]
readConsoleInput :: Ptr WinConsoleInputEvent
-> Int -> Handle -> IO [WinConsoleInputEvent]
readConsoleInput Ptr WinConsoleInputEvent
inputRecordPtr Int
maxEvents Handle
handle = Handle
-> (HANDLE -> IO [WinConsoleInputEvent])
-> IO [WinConsoleInputEvent]
forall a. Handle -> (HANDLE -> IO a) -> IO a
withHandleToHANDLE Handle
handle (Ptr WinConsoleInputEvent
-> Int -> HANDLE -> IO [WinConsoleInputEvent]
readConsoleInput' Ptr WinConsoleInputEvent
inputRecordPtr Int
maxEvents)

readConsoleInput' :: Ptr WinConsoleInputEvent -> Int -> HANDLE -> IO [WinConsoleInputEvent]
readConsoleInput' :: Ptr WinConsoleInputEvent
-> Int -> HANDLE -> IO [WinConsoleInputEvent]
readConsoleInput' Ptr WinConsoleInputEvent
inputRecordPtr Int
maxEvents HANDLE
handle' =
    (Ptr DWORD -> IO [WinConsoleInputEvent])
-> IO [WinConsoleInputEvent]
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr DWORD -> IO [WinConsoleInputEvent])
 -> IO [WinConsoleInputEvent])
-> (Ptr DWORD -> IO [WinConsoleInputEvent])
-> IO [WinConsoleInputEvent]
forall a b. (a -> b) -> a -> b
$ \Ptr DWORD
numEventsReadPtr -> do
        Ptr DWORD -> DWORD -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr DWORD
numEventsReadPtr DWORD
1
        BOOL
_ <- HANDLE -> Ptr WinConsoleInputEvent -> DWORD -> Ptr DWORD -> IO BOOL
cReadConsoleInput HANDLE
handle' Ptr WinConsoleInputEvent
inputRecordPtr (Int -> DWORD
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxEvents) Ptr DWORD
numEventsReadPtr
        DWORD
numEvents <- Ptr DWORD -> IO DWORD
forall a. Storable a => Ptr a -> IO a
peek Ptr DWORD
numEventsReadPtr
        ([WinConsoleInputEvent] -> Int -> IO [WinConsoleInputEvent])
-> [WinConsoleInputEvent] -> [Int] -> IO [WinConsoleInputEvent]
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM [WinConsoleInputEvent] -> Int -> IO [WinConsoleInputEvent]
addNextRecord [] [(DWORD -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral DWORD
numEvents Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1), (DWORD -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral DWORD
numEvents Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2)..Int
0]
    where
        addNextRecord :: [WinConsoleInputEvent] -> Int -> IO [WinConsoleInputEvent]
addNextRecord [WinConsoleInputEvent]
inputRecords Int
idx = do
            WinConsoleInputEvent
inputRecord <- Ptr WinConsoleInputEvent -> Int -> IO WinConsoleInputEvent
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff Ptr WinConsoleInputEvent
inputRecordPtr Int
idx
            [WinConsoleInputEvent] -> IO [WinConsoleInputEvent]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (WinConsoleInputEvent
inputRecordWinConsoleInputEvent
-> [WinConsoleInputEvent] -> [WinConsoleInputEvent]
forall a. a -> [a] -> [a]
:[WinConsoleInputEvent]
inputRecords)

instance Storable KeyEventRecord where
    sizeOf :: KeyEventRecord -> Int
sizeOf = Int -> KeyEventRecord -> Int
forall a b. a -> b -> a
const (Int
16)
{-# LINE 93 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 4
{-# LINE 94 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf input = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0))          buf (keyDown input)
{-# LINE 96 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4))      buf (repeatCount input)
{-# LINE 97 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 6))   buf (virtualKeyCode input)
{-# LINE 98 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8))  buf (virtualScanCode input)
{-# LINE 99 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 10))             buf (uChar input)
{-# LINE 100 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 12)) buf (controlKeyStateK input)
{-# LINE 101 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    peek buf = do
        keyDown'          <- ((\hsc_ptr -> peekByteOff hsc_ptr 0)) buf
{-# LINE 103 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        repeatCount'      <- ((\hsc_ptr -> peekByteOff hsc_ptr 4)) buf
{-# LINE 104 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        virtualKeyCode'   <- ((\hsc_ptr -> peekByteOff hsc_ptr 6)) buf
{-# LINE 105 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        virtualScanCode'  <- ((\hsc_ptr -> peekByteOff hsc_ptr 8)) buf
{-# LINE 106 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        uChar'            <- ((\hsc_ptr -> peekByteOff hsc_ptr 10)) buf
{-# LINE 107 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        controlKeyStateK' <- ((\hsc_ptr -> peekByteOff hsc_ptr 12)) buf
{-# LINE 108 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        return $ KeyEventRecordC keyDown' repeatCount' virtualKeyCode' virtualScanCode' uChar' controlKeyStateK'

instance Storable MouseEventRecord where
    sizeOf :: MouseEventRecord -> Int
sizeOf = Int -> MouseEventRecord -> Int
forall a b. a -> b -> a
const (Int
16)
{-# LINE 112 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 4
{-# LINE 113 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf input = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0))   buf (mousePosition input)
{-# LINE 115 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4))     buf (buttonState input)
{-# LINE 116 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) buf (controlKeyStateM input)
{-# LINE 117 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 12))      buf (eventFlags input)
{-# LINE 118 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    peek buf = do
        mousePosition'    <- ((\hsc_ptr -> peekByteOff hsc_ptr 0)) buf
{-# LINE 120 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        buttonState'      <- ((\hsc_ptr -> peekByteOff hsc_ptr 4)) buf
{-# LINE 121 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        controlKeyStateM' <- ((\hsc_ptr -> peekByteOff hsc_ptr 8)) buf
{-# LINE 122 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        eventFlags'       <- ((\hsc_ptr -> peekByteOff hsc_ptr 12)) buf
{-# LINE 123 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        return $ MouseEventRecordC mousePosition' buttonState' controlKeyStateM' eventFlags'

instance Storable WindowBufferSizeRecord where
    sizeOf :: WindowBufferSizeRecord -> Int
sizeOf = Int -> WindowBufferSizeRecord -> Int
forall a b. a -> b -> a
const (Int
4)
{-# LINE 127 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 2
{-# LINE 128 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf input = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (windowSize input)
{-# LINE 130 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    peek buf = do
        size' <- ((\hsc_ptr -> peekByteOff hsc_ptr 0)) buf
{-# LINE 132 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        return $ WindowBufferSizeRecordC size'

instance Storable MenuEventRecord where
    sizeOf :: MenuEventRecord -> Int
sizeOf = Int -> MenuEventRecord -> Int
forall a b. a -> b -> a
const (Int
4)
{-# LINE 136 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 4
{-# LINE 137 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf input = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (commandId input)
{-# LINE 139 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    peek buf = do
        commandId' <- ((\hsc_ptr -> peekByteOff hsc_ptr 0)) buf
{-# LINE 141 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        return $ MenuEventRecordC commandId'

instance Storable FocusEventRecord where
    sizeOf :: FocusEventRecord -> Int
sizeOf = Int -> FocusEventRecord -> Int
forall a b. a -> b -> a
const (Int
4)
{-# LINE 145 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 4
{-# LINE 146 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf input = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (setFocus input)
{-# LINE 148 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    peek buf = do
        setFocus' <- ((\hsc_ptr -> peekByteOff hsc_ptr 0)) buf
{-# LINE 150 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        return $ FocusEventRecordC setFocus'

instance Storable WinConsoleInputEvent where
    sizeOf :: WinConsoleInputEvent -> Int
sizeOf = Int -> WinConsoleInputEvent -> Int
forall a b. a -> b -> a
const (Int
20)
{-# LINE 154 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    alignment _ = 4
{-# LINE 155 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}

    poke :: Ptr WinConsoleInputEvent -> WinConsoleInputEvent -> IO ()
poke Ptr WinConsoleInputEvent
buf (KeyEventRecordU KeyEventRecord
key) = do
        ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> WORD -> IO ()
forall b. Ptr b -> Int -> WORD -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
0)) Ptr WinConsoleInputEvent
buf (WORD
1 :: WORD)
{-# LINE 158 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> KeyEventRecord -> IO ()
forall b. Ptr b -> Int -> KeyEventRecord -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf KeyEventRecord
key
{-# LINE 159 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf (MouseEventRecordU mouse) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (2 :: WORD)
{-# LINE 161 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) buf mouse
{-# LINE 162 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf (WindowBufferSizeRecordU window) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (4 :: WORD)
{-# LINE 164 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) buf window
{-# LINE 165 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf (MenuEventRecordU menu) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (8 :: WORD)
{-# LINE 167 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) buf menu
{-# LINE 168 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
    poke buf (FocusEventRecordU focus) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) buf (16 :: WORD)
{-# LINE 170 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) buf focus
{-# LINE 171 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}

    peek :: Ptr WinConsoleInputEvent -> IO WinConsoleInputEvent
peek Ptr WinConsoleInputEvent
buf = do
        WORD
event <- ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO WORD
forall b. Ptr b -> Int -> IO WORD
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
0)) Ptr WinConsoleInputEvent
buf :: IO WORD
{-# LINE 174 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
        case WORD
event of
          WORD
1 ->
{-# LINE 176 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
              KeyEventRecord -> WinConsoleInputEvent
KeyEventRecordU (KeyEventRecord -> WinConsoleInputEvent)
-> IO KeyEventRecord -> IO WinConsoleInputEvent
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO KeyEventRecord
forall b. Ptr b -> Int -> IO KeyEventRecord
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf
{-# LINE 177 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
          WORD
2 ->
{-# LINE 178 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
              MouseEventRecord -> WinConsoleInputEvent
MouseEventRecordU (MouseEventRecord -> WinConsoleInputEvent)
-> IO MouseEventRecord -> IO WinConsoleInputEvent
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO MouseEventRecord
forall b. Ptr b -> Int -> IO MouseEventRecord
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf
{-# LINE 179 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
          WORD
4 ->
{-# LINE 180 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
              WindowBufferSizeRecord -> WinConsoleInputEvent
WindowBufferSizeRecordU (WindowBufferSizeRecord -> WinConsoleInputEvent)
-> IO WindowBufferSizeRecord -> IO WinConsoleInputEvent
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO WindowBufferSizeRecord
forall b. Ptr b -> Int -> IO WindowBufferSizeRecord
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf
{-# LINE 181 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
          WORD
8 ->
{-# LINE 182 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
              MenuEventRecord -> WinConsoleInputEvent
MenuEventRecordU (MenuEventRecord -> WinConsoleInputEvent)
-> IO MenuEventRecord -> IO WinConsoleInputEvent
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO MenuEventRecord
forall b. Ptr b -> Int -> IO MenuEventRecord
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf
{-# LINE 183 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
          WORD
16 ->
{-# LINE 184 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
              FocusEventRecord -> WinConsoleInputEvent
FocusEventRecordU (FocusEventRecord -> WinConsoleInputEvent)
-> IO FocusEventRecord -> IO WinConsoleInputEvent
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ((\Ptr WinConsoleInputEvent
hsc_ptr -> Ptr WinConsoleInputEvent -> Int -> IO FocusEventRecord
forall b. Ptr b -> Int -> IO FocusEventRecord
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr WinConsoleInputEvent
hsc_ptr Int
4)) Ptr WinConsoleInputEvent
buf
{-# LINE 185 "src\\Graphics\\Vty\\Platform\\Windows\\WindowsConsoleInput.hsc" #-}
          WORD
_ -> String -> IO WinConsoleInputEvent
forall a. HasCallStack => String -> a
error (String -> IO WinConsoleInputEvent)
-> String -> IO WinConsoleInputEvent
forall a b. (a -> b) -> a -> b
$ String
"Unknown input event type " String -> ShowS
forall a. [a] -> [a] -> [a]
++ WORD -> String
forall a. Show a => a -> String
show WORD
event