| 1 |
{-# LANGUAGE DeriveDataTypeable #-} |
| 2 |
{-# LANGUAGE RankNTypes #-} |
| 3 |
{-# LANGUAGE Trustworthy #-} |
| 4 |
|
| 5 |
module System.Console.ANSI.Windows.Foreign |
| 6 |
( |
| 7 |
INPUT_RECORD (..) |
| 8 |
, INPUT_RECORD_EVENT (..) |
| 9 |
, KEY_EVENT_RECORD (..) |
| 10 |
, getNumberOfConsoleInputEvents |
| 11 |
, readConsoleInput |
| 12 |
, cWcharsToChars |
| 13 |
, unicodeAsciiChar |
| 14 |
, eNABLE_VIRTUAL_TERMINAL_PROCESSING |
| 15 |
, iNVALID_HANDLE_VALUE |
| 16 |
, nullHANDLE |
| 17 |
, getConsoleMode |
| 18 |
, setConsoleMode |
| 19 |
) where |
| 20 |
|
| 21 |
import Control.Exception ( Exception ) |
| 22 |
import Data.Char ( chr ) |
| 23 |
import Data.Typeable ( Typeable ) |
| 24 |
import Data.Word ( Word32 ) |
| 25 |
import Foreign.C.Types ( CWchar (..) ) |
| 26 |
import Foreign.Marshal.Alloc ( alloca ) |
| 27 |
import Foreign.Marshal.Array ( allocaArray, peekArray, pokeArray ) |
| 28 |
import Foreign.Ptr ( Ptr, castPtr, plusPtr, nullPtr ) |
| 29 |
import Foreign.Storable ( Storable (..) ) |
| 30 |
import System.Console.ANSI.Windows.Win32.Types |
| 31 |
( BOOL, DWORD, ErrCode, HANDLE, LPDWORD, SHORT, UINT, UINT_PTR, ULONG |
| 32 |
, WCHAR, WORD, failIfFalse_ |
| 33 |
) |
| 34 |
|
| 35 |
peekAndOffset :: Storable a => Ptr a -> IO (a, Ptr b) |
| 36 |
peekAndOffset ptr = do |
| 37 |
item <- peek ptr |
| 38 |
pure (item, ptr `plusPtr` sizeOf item) |
| 39 |
|
| 40 |
pokeAndOffset :: Storable a => Ptr a -> a -> IO (Ptr b) |
| 41 |
pokeAndOffset ptr item = do |
| 42 |
poke ptr item |
| 43 |
pure (ptr `plusPtr` sizeOf item) |
| 44 |
|
| 45 |
data COORD = COORD |
| 46 |
{ coord_x :: SHORT |
| 47 |
, coord_y :: SHORT |
| 48 |
} deriving (Read, Eq) |
| 49 |
|
| 50 |
instance Show COORD where |
| 51 |
show (COORD x y) = "(" ++ show x ++ ", " ++ show y ++ ")" |
| 52 |
|
| 53 |
instance Storable COORD where |
| 54 |
sizeOf ~(COORD x y) = sizeOf x + sizeOf y |
| 55 |
alignment ~(COORD x _) = alignment x |
| 56 |
peek ptr = do |
| 57 |
let ptr' = castPtr ptr :: Ptr SHORT |
| 58 |
x <- peekElemOff ptr' 0 |
| 59 |
y <- peekElemOff ptr' 1 |
| 60 |
pure (COORD x y) |
| 61 |
poke ptr (COORD x y) = do |
| 62 |
let ptr' = castPtr ptr :: Ptr SHORT |
| 63 |
pokeElemOff ptr' 0 x |
| 64 |
pokeElemOff ptr' 1 y |
| 65 |
|
| 66 |
data SMALL_RECT = SMALL_RECT COORD COORD |
| 67 |
|
| 68 |
instance Show SMALL_RECT where |
| 69 |
show (SMALL_RECT tl br) = show tl ++ "-" ++ show br |
| 70 |
|
| 71 |
instance Storable SMALL_RECT where |
| 72 |
sizeOf ~(SMALL_RECT tl br) = sizeOf tl + sizeOf br |
| 73 |
alignment ~(SMALL_RECT tl _) = alignment tl |
| 74 |
peek ptr = do |
| 75 |
let ptr' = castPtr ptr :: Ptr COORD |
| 76 |
tl <- peekElemOff ptr' 0 |
| 77 |
br <- peekElemOff ptr' 1 |
| 78 |
pure (SMALL_RECT tl br) |
| 79 |
poke ptr (SMALL_RECT tl br) = do |
| 80 |
let ptr' = castPtr ptr :: Ptr COORD |
| 81 |
pokeElemOff ptr' 0 tl |
| 82 |
pokeElemOff ptr' 1 br |
| 83 |
|
| 84 |
data CONSOLE_CURSOR_INFO = CONSOLE_CURSOR_INFO |
| 85 |
{ cci_cursor_size :: DWORD |
| 86 |
, cci_cursor_visible :: BOOL |
| 87 |
} deriving (Show) |
| 88 |
|
| 89 |
instance Storable CONSOLE_CURSOR_INFO where |
| 90 |
sizeOf ~(CONSOLE_CURSOR_INFO size visible) = sizeOf size + sizeOf visible |
| 91 |
alignment ~(CONSOLE_CURSOR_INFO size _) = alignment size |
| 92 |
peek ptr = do |
| 93 |
(size, ptr') <- peekAndOffset (castPtr ptr) |
| 94 |
visible <- peek ptr' |
| 95 |
pure (CONSOLE_CURSOR_INFO size visible) |
| 96 |
poke ptr (CONSOLE_CURSOR_INFO size visible) = do |
| 97 |
ptr' <- pokeAndOffset (castPtr ptr) size |
| 98 |
poke ptr' visible |
| 99 |
|
| 100 |
data CONSOLE_SCREEN_BUFFER_INFO = CONSOLE_SCREEN_BUFFER_INFO |
| 101 |
{ csbi_size :: COORD |
| 102 |
, csbi_cursor_position :: COORD |
| 103 |
, csbi_attributes :: WORD |
| 104 |
, csbi_window :: SMALL_RECT |
| 105 |
, csbi_maximum_window_size :: COORD |
| 106 |
} deriving (Show) |
| 107 |
|
| 108 |
instance Storable CONSOLE_SCREEN_BUFFER_INFO where |
| 109 |
sizeOf ~(CONSOLE_SCREEN_BUFFER_INFO |
| 110 |
size cursor_position attributes window maximum_window_size) |
| 111 |
= sizeOf size + sizeOf cursor_position + sizeOf attributes + sizeOf window |
| 112 |
+ sizeOf maximum_window_size |
| 113 |
alignment ~(CONSOLE_SCREEN_BUFFER_INFO size _ _ _ _) = alignment size |
| 114 |
peek ptr = do |
| 115 |
(size, ptr1) <- peekAndOffset (castPtr ptr) |
| 116 |
(cursor_position, ptr2) <- peekAndOffset ptr1 |
| 117 |
(attributes, ptr3) <- peekAndOffset ptr2 |
| 118 |
(window, ptr4) <- peekAndOffset ptr3 |
| 119 |
maximum_window_size <- peek ptr4 |
| 120 |
pure (CONSOLE_SCREEN_BUFFER_INFO |
| 121 |
size cursor_position attributes window maximum_window_size) |
| 122 |
poke ptr (CONSOLE_SCREEN_BUFFER_INFO |
| 123 |
size cursor_position attributes window maximum_window_size) |
| 124 |
= do |
| 125 |
ptr1 <- pokeAndOffset (castPtr ptr) size |
| 126 |
ptr2 <- pokeAndOffset ptr1 cursor_position |
| 127 |
ptr3 <- pokeAndOffset ptr2 attributes |
| 128 |
ptr4 <- pokeAndOffset ptr3 window |
| 129 |
poke ptr4 maximum_window_size |
| 130 |
|
| 131 |
data CONSOLE_SCREEN_BUFFER_INFOEX = CONSOLE_SCREEN_BUFFER_INFOEX |
| 132 |
{ csbix_size :: COORD |
| 133 |
, csbix_cursor_position :: COORD |
| 134 |
, csbix_attributes :: WORD |
| 135 |
, csbix_window :: SMALL_RECT |
| 136 |
, csbix_maximum_window_size :: COORD |
| 137 |
, csbix_popup_attributes :: WORD |
| 138 |
, csbix_fullscreen_supported :: BOOL |
| 139 |
, csbix_color_table :: [COLORREF] |
| 140 |
} deriving (Show) |
| 141 |
|
| 142 |
-- When specifying an explicit RGB color, the COLORREF value has the following |
| 143 |
-- hexadecimal form: |
| 144 |
-- 0x00bbggrr |
| 145 |
-- The low-order byte contains a value for the relative intensity of red; the |
| 146 |
-- second byte contains a value for green; and the third byte contains a value |
| 147 |
-- for blue. The high-order byte must be zero. The maximum value for a single |
| 148 |
-- byte is 0xFF. |
| 149 |
type COLORREF = Word32 |
| 150 |
|
| 151 |
instance Storable CONSOLE_SCREEN_BUFFER_INFOEX where |
| 152 |
sizeOf ~(CONSOLE_SCREEN_BUFFER_INFOEX |
| 153 |
size cursor_position attributes window maximum_window_size popup_attributes |
| 154 |
fullscreen_supported _) |
| 155 |
= sizeOf sizeCsbix + sizeOf size + sizeOf cursor_position + sizeOf attributes + sizeOf window |
| 156 |
+ sizeOf maximum_window_size + sizeOf popup_attributes |
| 157 |
+ sizeOf fullscreen_supported + 16 * sizeOf (undefined :: COLORREF) |
| 158 |
alignment ~(CONSOLE_SCREEN_BUFFER_INFOEX _ _ _ _ _ _ _ _) = alignment sizeCsbix |
| 159 |
peek ptr = do |
| 160 |
let ptr0 = castPtr ptr `plusPtr` sizeOf sizeCsbix |
| 161 |
(size, ptr1) <- peekAndOffset ptr0 |
| 162 |
(cursor_position, ptr2) <- peekAndOffset ptr1 |
| 163 |
(attributes, ptr3) <- peekAndOffset ptr2 |
| 164 |
(window, ptr4) <- peekAndOffset ptr3 |
| 165 |
(maximum_window_size, ptr5) <- peekAndOffset ptr4 |
| 166 |
(popup_attributes, ptr6) <- peekAndOffset ptr5 |
| 167 |
(fullscreen_supported, ptr7) <- peekAndOffset ptr6 |
| 168 |
color_table <- peekArray 16 ptr7 |
| 169 |
pure (CONSOLE_SCREEN_BUFFER_INFOEX |
| 170 |
size cursor_position attributes window maximum_window_size |
| 171 |
popup_attributes fullscreen_supported color_table) |
| 172 |
poke ptr (CONSOLE_SCREEN_BUFFER_INFOEX |
| 173 |
size cursor_position attributes window maximum_window_size popup_attributes |
| 174 |
fullscreen_supported color_table) |
| 175 |
= do |
| 176 |
ptr0 <- pokeAndOffset (castPtr ptr) sizeCsbix |
| 177 |
ptr1 <- pokeAndOffset ptr0 size |
| 178 |
ptr2 <- pokeAndOffset ptr1 cursor_position |
| 179 |
ptr3 <- pokeAndOffset ptr2 attributes |
| 180 |
ptr4 <- pokeAndOffset ptr3 window |
| 181 |
ptr5 <- pokeAndOffset ptr4 maximum_window_size |
| 182 |
ptr6 <- pokeAndOffset ptr5 popup_attributes |
| 183 |
ptr7 <- pokeAndOffset ptr6 fullscreen_supported |
| 184 |
pokeArray ptr7 color_table' |
| 185 |
where |
| 186 |
color_table' = take 16 $ color_table ++ repeat 0 |
| 187 |
|
| 188 |
sizeCsbix :: ULONG |
| 189 |
sizeCsbix = fromIntegral $ |
| 190 |
sizeOf (undefined :: CONSOLE_SCREEN_BUFFER_INFOEX) |
| 191 |
|
| 192 |
data CHAR_INFO = CHAR_INFO |
| 193 |
{ ci_char :: WCHAR |
| 194 |
, ci_attributes :: WORD |
| 195 |
} deriving (Show) |
| 196 |
|
| 197 |
instance Storable CHAR_INFO where |
| 198 |
sizeOf ~(CHAR_INFO char attributes) = sizeOf char + sizeOf attributes |
| 199 |
alignment ~(CHAR_INFO char _) = alignment char |
| 200 |
peek ptr = do |
| 201 |
(char, ptr') <- peekAndOffset (castPtr ptr) |
| 202 |
attributes <- peek ptr' |
| 203 |
pure (CHAR_INFO char attributes) |
| 204 |
poke ptr (CHAR_INFO char attributes) = do |
| 205 |
ptr' <- pokeAndOffset (castPtr ptr) char |
| 206 |
poke ptr' attributes |
| 207 |
|
| 208 |
kEY_EVENT, mOUSE_EVENT, wINDOW_BUFFER_SIZE_EVENT, mENU_EVENT, |
| 209 |
fOCUS_EVENT :: WORD |
| 210 |
kEY_EVENT = 1 |
| 211 |
mOUSE_EVENT = 2 |
| 212 |
wINDOW_BUFFER_SIZE_EVENT = 4 |
| 213 |
mENU_EVENT = 8 |
| 214 |
fOCUS_EVENT = 16 |
| 215 |
|
| 216 |
foreign import ccall unsafe "windows.h GetNumberOfConsoleInputEvents" |
| 217 |
cGetNumberOfConsoleInputEvents :: HANDLE -> Ptr DWORD -> IO BOOL |
| 218 |
foreign import ccall unsafe "windows.h ReadConsoleInputW" |
| 219 |
cReadConsoleInput :: HANDLE |
| 220 |
-> Ptr INPUT_RECORD |
| 221 |
-> DWORD |
| 222 |
-> LPDWORD |
| 223 |
-> IO BOOL |
| 224 |
|
| 225 |
data ConsoleException = ConsoleException !ErrCode deriving (Eq, Typeable) |
| 226 |
|
| 227 |
instance Show ConsoleException where |
| 228 |
show (ConsoleException 6) = |
| 229 |
"A fatal error has occurred.\n\n" ++ |
| 230 |
"An attempt has been made to send console virtual terminal sequences\n" ++ |
| 231 |
"(ANSI codes) to an output that has not been recognised as an\n" ++ |
| 232 |
"ANSI-capable terminal and also cannot be emulated as an ANSI-enabled\n" ++ |
| 233 |
"terminal (emulation needs a ConHost-based terminal, such as Command\n" ++ |
| 234 |
"Prompt or PowerShell). That may occur, for example, if output has\n" ++ |
| 235 |
"been redirected to a file.\n\n" ++ |
| 236 |
"If that is unexpected, please post an issue at:\n" ++ |
| 237 |
"https://github.com/UnkindPartition/ansi-terminal/issues\n" |
| 238 |
show (ConsoleException errCode) = "ConsoleException " ++ show errCode |
| 239 |
|
| 240 |
instance Exception ConsoleException |
| 241 |
|
| 242 |
returnWith_ :: Storable a => (Ptr a -> IO b) -> IO a |
| 243 |
returnWith_ act = alloca $ \ptr -> act ptr >> peek ptr |
| 244 |
|
| 245 |
{- |
| 246 |
typedef union _UNICODE_ASCII_CHAR { |
| 247 |
WCHAR UnicodeChar; |
| 248 |
CHAR AsciiChar; |
| 249 |
} UNICODE_ASCII_CHAR; |
| 250 |
-} |
| 251 |
newtype UNICODE_ASCII_CHAR = UnicodeAsciiChar |
| 252 |
{ unicodeAsciiChar :: WCHAR |
| 253 |
} deriving (Show, Read, Eq) |
| 254 |
|
| 255 |
instance Storable UNICODE_ASCII_CHAR where |
| 256 |
sizeOf _ = 2 |
| 257 |
alignment _ = 2 |
| 258 |
peek ptr = UnicodeAsciiChar <$> (`peekByteOff` 0) ptr |
| 259 |
poke ptr val = case val of |
| 260 |
UnicodeAsciiChar c -> (`pokeByteOff` 0) ptr c |
| 261 |
|
| 262 |
{- |
| 263 |
typedef struct _KEY_EVENT_RECORD { |
| 264 |
BOOL bKeyDown; |
| 265 |
WORD wRepeatCount; |
| 266 |
WORD wVirtualKeyCode; |
| 267 |
WORD wVirtualScanCode; |
| 268 |
union { |
| 269 |
WCHAR UnicodeChar; |
| 270 |
CHAR AsciiChar; |
| 271 |
} uChar; |
| 272 |
DWORD dwControlKeyState; |
| 273 |
} |
| 274 |
#ifdef __GNUC__ |
| 275 |
/* gcc's alignment is not what win32 expects */ |
| 276 |
PACKED |
| 277 |
#endif |
| 278 |
KEY_EVENT_RECORD; |
| 279 |
-} |
| 280 |
data KEY_EVENT_RECORD = KEY_EVENT_RECORD |
| 281 |
{ keyEventKeyDown :: BOOL |
| 282 |
, keyEventRepeatCount :: WORD |
| 283 |
, keyEventVirtualKeyCode :: WORD |
| 284 |
, keyEventVirtualScanCode :: WORD |
| 285 |
, keyEventChar :: UNICODE_ASCII_CHAR |
| 286 |
, keyEventControlKeystate :: DWORD |
| 287 |
} deriving (Show, Read, Eq) |
| 288 |
|
| 289 |
instance Storable KEY_EVENT_RECORD where |
| 290 |
sizeOf _ = 16 |
| 291 |
alignment _ = 4 |
| 292 |
peek ptr = KEY_EVENT_RECORD <$> (`peekByteOff` 0) ptr |
| 293 |
<*> (`peekByteOff` 4) ptr |
| 294 |
<*> (`peekByteOff` 6) ptr |
| 295 |
<*> (`peekByteOff` 8) ptr |
| 296 |
<*> (`peekByteOff` 10) ptr |
| 297 |
<*> (`peekByteOff` 12) ptr |
| 298 |
poke ptr val = do |
| 299 |
(`pokeByteOff` 0) ptr $ keyEventKeyDown val |
| 300 |
(`pokeByteOff` 4) ptr $ keyEventRepeatCount val |
| 301 |
(`pokeByteOff` 6) ptr $ keyEventVirtualKeyCode val |
| 302 |
(`pokeByteOff` 8) ptr $ keyEventVirtualScanCode val |
| 303 |
(`pokeByteOff` 10) ptr $ keyEventChar val |
| 304 |
(`pokeByteOff` 12) ptr $ keyEventControlKeystate val |
| 305 |
|
| 306 |
{- |
| 307 |
typedef struct _MOUSE_EVENT_RECORD { |
| 308 |
COORD dwMousePosition; |
| 309 |
DWORD dwButtonState; |
| 310 |
DWORD dwControlKeyState; |
| 311 |
DWORD dwEventFlags; |
| 312 |
} MOUSE_EVENT_RECORD; |
| 313 |
-} |
| 314 |
data MOUSE_EVENT_RECORD = MOUSE_EVENT_RECORD |
| 315 |
{ mousePosition :: COORD |
| 316 |
, mouseButtonState :: DWORD |
| 317 |
, mouseControlKeyState :: DWORD |
| 318 |
, mouseEventFlags :: DWORD |
| 319 |
} deriving (Show, Read, Eq) |
| 320 |
|
| 321 |
instance Storable MOUSE_EVENT_RECORD where |
| 322 |
sizeOf _ = 16 |
| 323 |
alignment _ = 4 |
| 324 |
peek ptr = MOUSE_EVENT_RECORD <$> (`peekByteOff` 0) ptr |
| 325 |
<*> (`peekByteOff` 4) ptr |
| 326 |
<*> (`peekByteOff` 8) ptr |
| 327 |
<*> (`peekByteOff` 12) ptr |
| 328 |
poke ptr val = do |
| 329 |
(`pokeByteOff` 0) ptr $ mousePosition val |
| 330 |
(`pokeByteOff` 4) ptr $ mouseButtonState val |
| 331 |
(`pokeByteOff` 8) ptr $ mouseControlKeyState val |
| 332 |
(`pokeByteOff` 12) ptr $ mouseEventFlags val |
| 333 |
|
| 334 |
{- |
| 335 |
typedef struct _WINDOW_BUFFER_SIZE_RECORD { |
| 336 |
COORD dwSize; |
| 337 |
} WINDOW_BUFFER_SIZE_RECORD; |
| 338 |
-} |
| 339 |
data WINDOW_BUFFER_SIZE_RECORD = WINDOW_BUFFER_SIZE_RECORD |
| 340 |
{ bufSizeNew :: COORD |
| 341 |
} deriving (Show, Read, Eq) |
| 342 |
|
| 343 |
instance Storable WINDOW_BUFFER_SIZE_RECORD where |
| 344 |
sizeOf _ = 4 |
| 345 |
alignment _ = 4 |
| 346 |
peek ptr = WINDOW_BUFFER_SIZE_RECORD <$> (`peekByteOff` 0) ptr |
| 347 |
poke ptr val = (`pokeByteOff` 0) ptr $ bufSizeNew val |
| 348 |
|
| 349 |
{- |
| 350 |
typedef struct _MENU_EVENT_RECORD { |
| 351 |
UINT dwCommandId; |
| 352 |
} MENU_EVENT_RECORD,*PMENU_EVENT_RECORD; |
| 353 |
-} |
| 354 |
data MENU_EVENT_RECORD = MENU_EVENT_RECORD |
| 355 |
{ menuCommandId :: UINT |
| 356 |
} deriving (Show, Read, Eq) |
| 357 |
|
| 358 |
instance Storable MENU_EVENT_RECORD where |
| 359 |
sizeOf _ = 4 |
| 360 |
alignment _ = 4 |
| 361 |
peek ptr = MENU_EVENT_RECORD <$> (`peekByteOff` 0) ptr |
| 362 |
poke ptr val = (`pokeByteOff` 0) ptr $ menuCommandId val |
| 363 |
|
| 364 |
{- |
| 365 |
typedef struct _FOCUS_EVENT_RECORD { BOOL bSetFocus; } FOCUS_EVENT_RECORD; |
| 366 |
-} |
| 367 |
data FOCUS_EVENT_RECORD = FOCUS_EVENT_RECORD |
| 368 |
{ focusSetFocus :: BOOL |
| 369 |
} deriving (Show, Read, Eq) |
| 370 |
|
| 371 |
instance Storable FOCUS_EVENT_RECORD where |
| 372 |
sizeOf _ = 4 |
| 373 |
alignment _ = 4 |
| 374 |
peek ptr = FOCUS_EVENT_RECORD <$> (`peekByteOff` 0) ptr |
| 375 |
poke ptr val = (`pokeByteOff` 0) ptr $ focusSetFocus val |
| 376 |
|
| 377 |
data INPUT_RECORD_EVENT |
| 378 |
= InputKeyEvent KEY_EVENT_RECORD |
| 379 |
| InputMouseEvent MOUSE_EVENT_RECORD |
| 380 |
| InputWindowBufferSizeEvent WINDOW_BUFFER_SIZE_RECORD |
| 381 |
| InputMenuEvent MENU_EVENT_RECORD |
| 382 |
| InputFocusEvent FOCUS_EVENT_RECORD |
| 383 |
deriving (Show, Read, Eq) |
| 384 |
|
| 385 |
{- |
| 386 |
typedef struct _INPUT_RECORD { |
| 387 |
WORD EventType; |
| 388 |
union { |
| 389 |
KEY_EVENT_RECORD KeyEvent; |
| 390 |
MOUSE_EVENT_RECORD MouseEvent; |
| 391 |
WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent; |
| 392 |
MENU_EVENT_RECORD MenuEvent; |
| 393 |
FOCUS_EVENT_RECORD FocusEvent; |
| 394 |
} Event; |
| 395 |
} INPUT_RECORD,*PINPUT_RECORD; |
| 396 |
-} |
| 397 |
data INPUT_RECORD = INPUT_RECORD |
| 398 |
{ inputEventType :: WORD |
| 399 |
, inputEvent :: INPUT_RECORD_EVENT |
| 400 |
} deriving (Show, Read, Eq) |
| 401 |
|
| 402 |
instance Storable INPUT_RECORD where |
| 403 |
sizeOf _ = 20 |
| 404 |
alignment _ = 4 |
| 405 |
peek ptr = do |
| 406 |
evType <- (`peekByteOff` 0) ptr |
| 407 |
event <- case evType of |
| 408 |
_ | evType == kEY_EVENT |
| 409 |
-> InputKeyEvent <$> (`peekByteOff` 4) ptr |
| 410 |
_ | evType == mOUSE_EVENT |
| 411 |
-> InputMouseEvent <$> (`peekByteOff` 4) ptr |
| 412 |
_ | evType == wINDOW_BUFFER_SIZE_EVENT |
| 413 |
-> InputWindowBufferSizeEvent <$> (`peekByteOff` 4) ptr |
| 414 |
_ | evType == mENU_EVENT |
| 415 |
-> InputMenuEvent <$> (`peekByteOff` 4) ptr |
| 416 |
_ | evType == fOCUS_EVENT |
| 417 |
-> InputFocusEvent <$> (`peekByteOff` 4) ptr |
| 418 |
_ -> error $ "peek (INPUT_RECORD): Unknown event type " ++ |
| 419 |
show evType |
| 420 |
pure $ INPUT_RECORD evType event |
| 421 |
poke ptr val = do |
| 422 |
(`pokeByteOff` 0) ptr $ inputEventType val |
| 423 |
case inputEvent val of |
| 424 |
InputKeyEvent ev -> (`pokeByteOff` 4) ptr ev |
| 425 |
InputMouseEvent ev -> (`pokeByteOff` 4) ptr ev |
| 426 |
InputWindowBufferSizeEvent ev -> (`pokeByteOff` 4) ptr ev |
| 427 |
InputMenuEvent ev -> (`pokeByteOff` 4) ptr ev |
| 428 |
InputFocusEvent ev -> (`pokeByteOff` 4) ptr ev |
| 429 |
|
| 430 |
-- The following is based on module System.Win32.Console.Extra from package |
| 431 |
-- Win32-console. |
| 432 |
|
| 433 |
getNumberOfConsoleInputEvents :: HANDLE -> IO DWORD |
| 434 |
getNumberOfConsoleInputEvents hdl = |
| 435 |
returnWith_ $ \ptrN -> |
| 436 |
failIfFalse_ "GetNumberOfConsoleInputEvents" $ |
| 437 |
cGetNumberOfConsoleInputEvents hdl ptrN |
| 438 |
|
| 439 |
-- The following is based on module System.Win32.Console.Extra from package |
| 440 |
-- Win32-console, cut down for the WCHAR version of readConsoleInput. |
| 441 |
|
| 442 |
readConsoleInput :: HANDLE -> DWORD -> IO [INPUT_RECORD] |
| 443 |
readConsoleInput hdl len |
| 444 |
= readConsoleInputWith hdl len $ \(ptr, n) -> peekArray (fromEnum n) ptr |
| 445 |
|
| 446 |
readConsoleInputWith :: HANDLE |
| 447 |
-> DWORD |
| 448 |
-> OutputHandler (Ptr INPUT_RECORD, DWORD) |
| 449 |
readConsoleInputWith hdl len handler = |
| 450 |
allocaArray (fromEnum len) $ \ptrBuf -> |
| 451 |
alloca $ \ptrN -> do |
| 452 |
failIfFalse_ "ReadConsoleInputW" $ |
| 453 |
cReadConsoleInput hdl ptrBuf len ptrN |
| 454 |
n <- peek ptrN |
| 455 |
handler (ptrBuf, n) |
| 456 |
|
| 457 |
type OutputHandler o = forall a. (o -> IO a) -> IO a |
| 458 |
|
| 459 |
-- Replicated from module Foreign.C.String in package base because that module |
| 460 |
-- does not export the function. |
| 461 |
cWcharsToChars :: [CWchar] -> [Char] |
| 462 |
cWcharsToChars = map chr . fromUTF16 . map fromIntegral |
| 463 |
where |
| 464 |
fromUTF16 (c1:c2:wcs) |
| 465 |
| 0xd800 <= c1 && c1 <= 0xdbff && 0xdc00 <= c2 && c2 <= 0xdfff = |
| 466 |
((c1 - 0xd800)*0x400 + (c2 - 0xdc00) + 0x10000) : fromUTF16 wcs |
| 467 |
fromUTF16 (c:wcs) = c : fromUTF16 wcs |
| 468 |
fromUTF16 [] = [] |
| 469 |
|
| 470 |
eNABLE_VIRTUAL_TERMINAL_PROCESSING :: DWORD |
| 471 |
eNABLE_VIRTUAL_TERMINAL_PROCESSING = 4 |
| 472 |
|
| 473 |
iNVALID_HANDLE_VALUE :: HANDLE |
| 474 |
iNVALID_HANDLE_VALUE = castUINTPtrToPtr maxBound |
| 475 |
|
| 476 |
nullHANDLE :: HANDLE |
| 477 |
nullHANDLE = nullPtr |
| 478 |
|
| 479 |
foreign import ccall unsafe "HsWin32.h _ansi_terminal_castUINTPtrToPtr" |
| 480 |
castUINTPtrToPtr :: UINT_PTR -> Ptr a |
| 481 |
|
| 482 |
foreign import ccall unsafe "windows.h GetConsoleMode" |
| 483 |
c_GetConsoleMode :: HANDLE -> LPDWORD -> IO BOOL |
| 484 |
|
| 485 |
foreign import ccall unsafe "windows.h SetConsoleMode" |
| 486 |
c_SetConsoleMode :: HANDLE -> DWORD -> IO BOOL |
| 487 |
|
| 488 |
getConsoleMode :: HANDLE -> IO DWORD |
| 489 |
getConsoleMode h = alloca $ \ptr -> do |
| 490 |
failIfFalse_ "GetConsoleMode" $ c_GetConsoleMode h ptr |
| 491 |
peek ptr |
| 492 |
|
| 493 |
setConsoleMode :: HANDLE -> DWORD -> IO () |
| 494 |
setConsoleMode h mode = failIfFalse_ "SetConsoleMode" $ c_SetConsoleMode h mode |