Debian Codegraph @

win/System/Console/ANSI/Windows/Foreign.hs

raw
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