> 1 /***********************************************************************\ > 2 * wincon.d * > 3 * * > 4 * Windows API header module * > 5 * * > 6 * Translated from MinGW Windows headers * > 7 * * > 8 * Placed into public domain * > 9 \***********************************************************************/ 1 module win32.wincon; 10 module win32.wincon; > 11 pragma(lib, "kernel32.lib"); 2 | 12 3 // Translated from Microsoft Platform SDK August 2001 Edition < 4 // by Y.Tomino | 13 private import win32.w32api, win32.windef; 5 | 14 6 import win32.windef; | 15 // FIXME: clean up Windows version support 7 import win32.winbase; < 8 | 16 > 17 enum { 9 // #ifndef _WINCON_ | 18 FOREGROUND_BLUE = 1, 10 // #define _WINCON_ | 19 FOREGROUND_GREEN = 2, > 20 FOREGROUND_RED = 4, > 21 FOREGROUND_INTENSITY = 8, > 22 BACKGROUND_BLUE = 16, > 23 BACKGROUND_GREEN = 32, > 24 BACKGROUND_RED = 64, > 25 BACKGROUND_INTENSITY = 128 > 26 } > 27 > 28 static if (_WIN32_WINNT >= 0x0501) { > 29 enum { > 30 CONSOLE_FULLSCREEN_MODE = 1, > 31 CONSOLE_WINDOWED_MODE = 0 > 32 } > 33 } > 34 > 35 enum { > 36 CTRL_C_EVENT = 0, > 37 CTRL_BREAK_EVENT = 1, > 38 CTRL_CLOSE_EVENT = 2, > 39 CTRL_LOGOFF_EVENT = 5, > 40 CTRL_SHUTDOWN_EVENT = 6 > 41 } > 42 > 43 enum { > 44 ENABLE_PROCESSED_INPUT = 1, > 45 ENABLE_LINE_INPUT = 2, > 46 ENABLE_ECHO_INPUT = 4, > 47 ENABLE_WINDOW_INPUT = 8, > 48 ENABLE_MOUSE_INPUT = 16 > 49 } > 50 > 51 enum { > 52 ENABLE_PROCESSED_OUTPUT = 1, > 53 ENABLE_WRAP_AT_EOL_OUTPUT = 2 > 54 } > 55 > 56 enum { > 57 KEY_EVENT = 1, > 58 MOUSE_EVENT = 2, > 59 WINDOW_BUFFER_SIZE_EVENT = 4, > 60 MENU_EVENT = 8, > 61 FOCUS_EVENT = 16 > 62 } > 63 enum { > 64 RIGHT_ALT_PRESSED = 1, > 65 LEFT_ALT_PRESSED = 2, > 66 RIGHT_CTRL_PRESSED = 4, > 67 LEFT_CTRL_PRESSED = 8, > 68 SHIFT_PRESSED = 16, > 69 NUMLOCK_ON = 32, > 70 SCROLLLOCK_ON = 64, > 71 CAPSLOCK_ON = 128, > 72 ENHANCED_KEY = 256 > 73 } > 74 enum { > 75 FROM_LEFT_1ST_BUTTON_PRESSED = 1, > 76 RIGHTMOST_BUTTON_PRESSED = 2, > 77 FROM_LEFT_2ND_BUTTON_PRESSED = 4, > 78 FROM_LEFT_3RD_BUTTON_PRESSED = 8, > 79 FROM_LEFT_4TH_BUTTON_PRESSED = 16 > 80 } > 81 > 82 enum { > 83 MOUSE_MOVED = 1, > 84 DOUBLE_CLICK = 2, > 85 MOUSE_WHEELED = 4 > 86 } > 87 > 88 struct CHAR_INFO { > 89 union _Char { > 90 WCHAR UnicodeChar; > 91 CHAR AsciiChar; > 92 } > 93 _Char Char; > 94 WORD Attributes; > 95 } > 96 alias CHAR_INFO* PCHAR_INFO; > 97 > 98 struct SMALL_RECT { > 99 SHORT Left; > 100 SHORT Top; > 101 SHORT Right; > 102 SHORT Bottom; > 103 } > 104 alias SMALL_RECT* PSMALL_RECT; > 105 > 106 struct CONSOLE_CURSOR_INFO { > 107 DWORD dwSize; > 108 BOOL bVisible; > 109 } > 110 alias CONSOLE_CURSOR_INFO* PCONSOLE_CURSOR_INFO; > 111 > 112 struct COORD { > 113 SHORT X; > 114 SHORT Y; > 115 } > 116 alias COORD* PCOORD; > 117 > 118 struct CONSOLE_FONT_INFO { > 119 DWORD nFont; > 120 COORD dwFontSize; > 121 } > 122 alias CONSOLE_FONT_INFO* PCONSOLE_FONT_INFO; > 123 > 124 struct CONSOLE_SCREEN_BUFFER_INFO { > 125 COORD dwSize; > 126 COORD dwCursorPosition; > 127 WORD wAttributes; > 128 SMALL_RECT srWindow; > 129 COORD dwMaximumWindowSize; > 130 } > 131 alias CONSOLE_SCREEN_BUFFER_INFO* PCONSOLE_SCREEN_BUFFER_INFO; > 132 > 133 alias BOOL function(DWORD) PHANDLER_ROUTINE; > 134 > 135 struct KEY_EVENT_RECORD { > 136 BOOL bKeyDown; > 137 WORD wRepeatCount; > 138 WORD wVirtualKeyCode; > 139 WORD wVirtualScanCode; > 140 union _uChar { > 141 WCHAR UnicodeChar; > 142 CHAR AsciiChar; > 143 } > 144 _uChar uChar; > 145 DWORD dwControlKeyState; > 146 } > 147 > 148 struct MOUSE_EVENT_RECORD { > 149 COORD dwMousePosition; > 150 DWORD dwButtonState; > 151 DWORD dwControlKeyState; > 152 DWORD dwEventFlags; > 153 } 11 154 12 // #ifdef __cplusplus | 155 struct WINDOW_BUFFER_SIZE_RECORD { 13 // extern "C" { < 14 // #endif < 15 < 16 struct _COORD { | 156 COORD dwSize; 17 SHORT X; < 18 SHORT Y; < 19 } 157 } 20 alias _COORD COORD; < 21 alias _COORD* PCOORD; < 22 158 23 struct _SMALL_RECT { | 159 struct MENU_EVENT_RECORD { 24 SHORT Left; | 160 UINT dwCommandId; 25 SHORT Top; < 26 SHORT Right; < 27 SHORT Bottom; < 28 } 161 } 29 alias _SMALL_RECT SMALL_RECT; | 162 alias MENU_EVENT_RECORD* PMENU_EVENT_RECORD; 30 alias _SMALL_RECT* PSMALL_RECT; < 31 163 32 struct _KEY_EVENT_RECORD { | 164 struct FOCUS_EVENT_RECORD { 33 BOOL bKeyDown; | 165 BOOL bSetFocus; 34 WORD wRepeatCount; < 35 WORD wVirtualKeyCode; < 36 WORD wVirtualScanCode; < 37 union { < 38 WCHAR UnicodeChar; < 39 CHAR AsciiChar; < 40 } 166 } 41 167 42 DWORD dwControlKeyState; | 168 struct INPUT_RECORD { 43 } < > 169 WORD EventType; > 170 union _Event { 44 alias _KEY_EVENT_RECORD KEY_EVENT_RECORD; | 171 KEY_EVENT_RECORD KeyEvent; 45 alias _KEY_EVENT_RECORD* PKEY_EVENT_RECORD; | 172 MOUSE_EVENT_RECORD MouseEvent; 46 < 47 enum : uint { RIGHT_ALT_PRESSED = 0x0001 } | 173 WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent; 48 enum : uint { LEFT_ALT_PRESSED = 0x0002 } | 174 MENU_EVENT_RECORD MenuEvent; 49 enum : uint { RIGHT_CTRL_PRESSED = 0x0004 } | 175 FOCUS_EVENT_RECORD FocusEvent; 50 enum : uint { LEFT_CTRL_PRESSED = 0x0008 } < 51 enum : uint { SHIFT_PRESSED = 0x0010 } < 52 enum : uint { NUMLOCK_ON = 0x0020 } < 53 enum : uint { SCROLLLOCK_ON = 0x0040 } < 54 enum : uint { CAPSLOCK_ON = 0x0080 } < 55 enum : uint { ENHANCED_KEY = 0x0100 } < 56 enum : uint { NLS_DBCSCHAR = 0x00010000 } < 57 enum : uint { NLS_ALPHANUMERIC = 0x00000000 } < 58 enum : uint { NLS_KATAKANA = 0x00020000 } < 59 enum : uint { NLS_HIRAGANA = 0x00040000 } < 60 enum : uint { NLS_ROMAN = 0x00400000 } < 61 enum : uint { NLS_IME_CONVERSION = 0x00800000 } < 62 enum : uint { NLS_IME_DISABLE = 0x20000000 } < 63 | 176 } 64 struct _MOUSE_EVENT_RECORD { < 65 COORD dwMousePosition; < 66 DWORD dwButtonState; < 67 DWORD dwControlKeyState; < 68 DWORD dwEventFlags; < > 177 _Event Event; 69 } 178 } 70 alias _MOUSE_EVENT_RECORD MOUSE_EVENT_RECORD; | 179 alias INPUT_RECORD* PINPUT_RECORD; 71 alias _MOUSE_EVENT_RECORD* PMOUSE_EVENT_RECORD; < 72 180 73 enum : uint { FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001 } | 181 extern (Windows): 74 enum : uint { RIGHTMOST_BUTTON_PRESSED = 0x0002 } < 75 enum : uint { FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004 } < 76 enum : uint { FROM_LEFT_3RD_BUTTON_PRESSED = 0x0008 } < 77 enum : uint { FROM_LEFT_4TH_BUTTON_PRESSED = 0x0010 } < 78 182 79 enum : uint { MOUSE_MOVED = 0x0001 } | 183 BOOL AllocConsole(); 80 enum : uint { DOUBLE_CLICK = 0x0002 } | 184 HANDLE CreateConsoleScreenBuffer(DWORD, DWORD, SECURITY_ATTRIBUTES*, DWORD, LPVO 81 enum : uint { MOUSE_WHEELED = 0x0004 } | 185 BOOL FillConsoleOutputAttribute(HANDLE, WORD, DWORD, COORD, PDWORD); 82 < > 186 BOOL FillConsoleOutputCharacterA(HANDLE, CHAR, DWORD, COORD, PDWORD); 83 struct _WINDOW_BUFFER_SIZE_RECORD { | 187 BOOL FillConsoleOutputCharacterW(HANDLE, WCHAR, DWORD, COORD, PDWORD); 84 COORD dwSize; | 188 BOOL FlushConsoleInputBuffer(HANDLE); 85 } < > 189 BOOL FreeConsole(); 86 alias _WINDOW_BUFFER_SIZE_RECORD WINDOW_BUFFER_SIZE_RECORD; | 190 BOOL GenerateConsoleCtrlEvent(DWORD, DWORD); 87 alias _WINDOW_BUFFER_SIZE_RECORD* PWINDOW_BUFFER_SIZE_RECORD; | 191 UINT GetConsoleCP(); 88 < > 192 BOOL GetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO); 89 struct _MENU_EVENT_RECORD { | 193 BOOL GetConsoleMode(HANDLE,PDWORD); 90 UINT dwCommandId; | 194 UINT GetConsoleOutputCP(); > 195 BOOL GetConsoleScreenBufferInfo(HANDLE, PCONSOLE_SCREEN_BUFFER_INFO); > 196 DWORD GetConsoleTitleA(LPSTR, DWORD); > 197 DWORD GetConsoleTitleW(LPWSTR, DWORD); > 198 COORD GetLargestConsoleWindowSize(HANDLE); > 199 BOOL GetNumberOfConsoleInputEvents(HANDLE, PDWORD); > 200 BOOL GetNumberOfConsoleMouseButtons(PDWORD); > 201 BOOL PeekConsoleInputA(HANDLE, PINPUT_RECORD, DWORD, PDWORD); > 202 BOOL PeekConsoleInputW(HANDLE, PINPUT_RECORD, DWORD, PDWORD); > 203 BOOL ReadConsoleA(HANDLE, PVOID, DWORD, PDWORD, PVOID); > 204 BOOL ReadConsoleW(HANDLE, PVOID, DWORD, PDWORD, PVOID); > 205 BOOL ReadConsoleInputA(HANDLE, PINPUT_RECORD, DWORD, PDWORD); > 206 BOOL ReadConsoleInputW(HANDLE, PINPUT_RECORD, DWORD, PDWORD); > 207 BOOL ReadConsoleOutputAttribute(HANDLE, LPWORD, DWORD, COORD, LPDWORD); > 208 BOOL ReadConsoleOutputCharacterA(HANDLE, LPSTR, DWORD, COORD, PDWORD); > 209 BOOL ReadConsoleOutputCharacterW(HANDLE, LPWSTR, DWORD, COORD, PDWORD); > 210 BOOL ReadConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); > 211 BOOL ReadConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); > 212 BOOL ScrollConsoleScreenBufferA(HANDLE, CPtr!(SMALL_RECT), CPtr!(SMALL_RECT), CO > 213 BOOL ScrollConsoleScreenBufferW(HANDLE, CPtr!(SMALL_RECT), CPtr!(SMALL_RECT), CO > 214 BOOL SetConsoleActiveScreenBuffer(HANDLE); > 215 BOOL SetConsoleCP(UINT); > 216 BOOL SetConsoleCtrlHandler(PHANDLER_ROUTINE, BOOL); > 217 BOOL SetConsoleCursorInfo(HANDLE, CPtr!(CONSOLE_CURSOR_INFO)); > 218 BOOL SetConsoleCursorPosition(HANDLE, COORD); 91 } | 219 92 alias _MENU_EVENT_RECORD MENU_EVENT_RECORD; < 93 alias _MENU_EVENT_RECORD* PMENU_EVENT_RECORD; < 94 220 95 struct _FOCUS_EVENT_RECORD { | 221 static if (_WIN32_WINNT >= 0x0500) { 96 BOOL bSetFocus; | 222 BOOL GetConsoleDisplayMode(LPDWORD); 97 } < 98 alias _FOCUS_EVENT_RECORD FOCUS_EVENT_RECORD; < 99 alias _FOCUS_EVENT_RECORD* PFOCUS_EVENT_RECORD; < 100 < 101 struct _INPUT_RECORD { < 102 WORD EventType; < 103 union { < 104 KEY_EVENT_RECORD KeyEvent; < 105 MOUSE_EVENT_RECORD MouseEvent; < 106 WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent; < 107 MENU_EVENT_RECORD MenuEvent; < 108 FOCUS_EVENT_RECORD FocusEvent; < > 223 HWND GetConsoleWindow(); 109 } 224 } 110 225 111 } < > 226 static if (_WIN32_WINNT >= 0x0501) { 112 alias _INPUT_RECORD INPUT_RECORD; | 227 BOOL AttachConsole(DWORD); 113 alias _INPUT_RECORD* PINPUT_RECORD; | 228 BOOL SetConsoleDisplayMode(HANDLE, DWORD, PCOORD); 114 < 115 enum : uint { KEY_EVENT = 0x0001 } < 116 enum : uint { MOUSE_EVENT = 0x0002 } < 117 enum : uint { WINDOW_BUFFER_SIZE_EVENT = 0x0004 } < 118 enum : uint { MENU_EVENT = 0x0008 } < 119 enum : uint { FOCUS_EVENT = 0x0010 } < 120 < 121 struct _CHAR_INFO { < 122 union { < 123 WCHAR UnicodeChar; < 124 CHAR AsciiChar; < > 229 const DWORD ATTACH_PARENT_PROCESS = cast(DWORD)-1; 125 } 230 } 126 231 127 WORD Attributes; | 232 BOOL SetConsoleMode(HANDLE, DWORD); 128 } < > 233 BOOL SetConsoleOutputCP(UINT); 129 alias _CHAR_INFO CHAR_INFO; | 234 BOOL SetConsoleScreenBufferSize(HANDLE, COORD); 130 alias _CHAR_INFO* PCHAR_INFO; | 235 BOOL SetConsoleTextAttribute(HANDLE, WORD); 131 < > 236 BOOL SetConsoleTitleA(LPCSTR); 132 enum : uint { FOREGROUND_BLUE = 0x0001 } | 237 BOOL SetConsoleTitleW(LPCWSTR); 133 enum : uint { FOREGROUND_GREEN = 0x0002 } | 238 BOOL SetConsoleWindowInfo(HANDLE, BOOL, CPtr!(SMALL_RECT)); 134 enum : uint { FOREGROUND_RED = 0x0004 } | 239 BOOL WriteConsoleA(HANDLE, PCVOID, DWORD, PDWORD, PVOID); 135 enum : uint { FOREGROUND_INTENSITY = 0x0008 } | 240 BOOL WriteConsoleW(HANDLE, PCVOID, DWORD, PDWORD, PVOID); 136 enum : uint { BACKGROUND_BLUE = 0x0010 } < 137 enum : uint { BACKGROUND_GREEN = 0x0020 } < 138 enum : uint { BACKGROUND_RED = 0x0040 } < 139 enum : uint { BACKGROUND_INTENSITY = 0x0080 } < 140 enum : uint { COMMON_LVB_LEADING_BYTE = 0x0100 } < 141 enum : uint { COMMON_LVB_TRAILING_BYTE = 0x0200 } < 142 enum : uint { COMMON_LVB_GRID_HORIZONTAL = 0x0400 } < 143 enum : uint { COMMON_LVB_GRID_LVERTICAL = 0x0800 } < 144 enum : uint { COMMON_LVB_GRID_RVERTICAL = 0x1000 } < 145 enum : uint { COMMON_LVB_REVERSE_VIDEO = 0x4000 } < 146 enum : uint { COMMON_LVB_UNDERSCORE = 0x8000 } < 147 < 148 enum : uint { COMMON_LVB_SBCSDBCS = 0x0300 } < 149 < 150 struct _CONSOLE_SCREEN_BUFFER_INFO { < 151 COORD dwSize; < 152 COORD dwCursorPosition; < 153 WORD wAttributes; < 154 SMALL_RECT srWindow; < 155 COORD dwMaximumWindowSize; < 156 } < 157 alias _CONSOLE_SCREEN_BUFFER_INFO CONSOLE_SCREEN_BUFFER_INFO; < 158 alias _CONSOLE_SCREEN_BUFFER_INFO* PCONSOLE_SCREEN_BUFFER_INFO; < 159 < 160 struct _CONSOLE_CURSOR_INFO { < 161 DWORD dwSize; < 162 BOOL bVisible; < 163 } < 164 alias _CONSOLE_CURSOR_INFO CONSOLE_CURSOR_INFO; < 165 alias _CONSOLE_CURSOR_INFO* PCONSOLE_CURSOR_INFO; < 166 < 167 struct _CONSOLE_FONT_INFO { < 168 DWORD nFont; < 169 COORD dwFontSize; < 170 } < 171 alias _CONSOLE_FONT_INFO CONSOLE_FONT_INFO; < 172 alias _CONSOLE_FONT_INFO* PCONSOLE_FONT_INFO; < 173 < 174 // #if(_WIN32_WINNT >= 0x0500) < 175 struct _CONSOLE_SELECTION_INFO { < 176 DWORD dwFlags; < 177 COORD dwSelectionAnchor; < 178 SMALL_RECT srSelection; < 179 } < 180 alias _CONSOLE_SELECTION_INFO CONSOLE_SELECTION_INFO; < 181 alias _CONSOLE_SELECTION_INFO* PCONSOLE_SELECTION_INFO; < 182 < 183 enum : uint { CONSOLE_NO_SELECTION = 0x0000 } < 184 enum : uint { CONSOLE_SELECTION_IN_PROGRESS = 0x0001 } < 185 enum : uint { CONSOLE_SELECTION_NOT_EMPTY = 0x0002 } < 186 enum : uint { CONSOLE_MOUSE_SELECTION = 0x0004 } < 187 enum : uint { CONSOLE_MOUSE_DOWN = 0x0008 } < 188 // #endif /* _WIN32_WINNT >= 0x0500 */ < 189 < 190 extern(Windows) alias BOOL function( DWORD CtrlType ) PHANDLER_ROUTINE; < 191 < 192 enum : uint { CTRL_C_EVENT = 0 } < 193 enum : uint { CTRL_BREAK_EVENT = 1 } < 194 enum : uint { CTRL_CLOSE_EVENT = 2 } < 195 < 196 enum : uint { CTRL_LOGOFF_EVENT = 5 } < 197 enum : uint { CTRL_SHUTDOWN_EVENT = 6 } < 198 < 199 enum : uint { ENABLE_PROCESSED_INPUT = 0x0001 } < 200 enum : uint { ENABLE_LINE_INPUT = 0x0002 } < 201 enum : uint { ENABLE_ECHO_INPUT = 0x0004 } < 202 enum : uint { ENABLE_WINDOW_INPUT = 0x0008 } < 203 enum : uint { ENABLE_MOUSE_INPUT = 0x0010 } < 204 < 205 enum : uint { ENABLE_PROCESSED_OUTPUT = 0x0001 } < 206 enum : uint { ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002 } < 207 < 208 extern(Windows) export BOOL PeekConsoleInputA( < 209 HANDLE hConsoleInput, < 210 PINPUT_RECORD lpBuffer, < 211 DWORD nLength, < 212 LPDWORD lpNumberOfEventsRead < 213 ); < 214 extern(Windows) export BOOL PeekConsoleInputW( < 215 HANDLE hConsoleInput, < 216 PINPUT_RECORD lpBuffer, < 217 DWORD nLength, < 218 LPDWORD lpNumberOfEventsRead < 219 ); < 220 // #ifdef UNICODE < 221 alias PeekConsoleInputW PeekConsoleInput; < 222 // #else < 223 // #... < 224 // #endif // !UNICODE < 225 < 226 extern(Windows) export BOOL ReadConsoleInputA( < 227 HANDLE hConsoleInput, < 228 PINPUT_RECORD lpBuffer, < 229 DWORD nLength, < 230 LPDWORD lpNumberOfEventsRead < 231 ); < 232 extern(Windows) export BOOL ReadConsoleInputW( < 233 HANDLE hConsoleInput, < 234 PINPUT_RECORD lpBuffer, < 235 DWORD nLength, < 236 LPDWORD lpNumberOfEventsRead < 237 ); < 238 // #ifdef UNICODE < 239 alias ReadConsoleInputW ReadConsoleInput; < 240 // #else < 241 // #... < 242 // #endif // !UNICODE < 243 < 244 extern(Windows) export BOOL WriteConsoleInputA( | 241 BOOL WriteConsoleInputA(HANDLE, CPtr!(INPUT_RECORD), DWORD, PDWORD); 245 HANDLE hConsoleInput, < 246 INPUT_RECORD *lpBuffer, < 247 DWORD nLength, < 248 LPDWORD lpNumberOfEventsWritten < 249 ); < 250 extern(Windows) export BOOL WriteConsoleInputW( | 242 BOOL WriteConsoleInputW(HANDLE, CPtr!(INPUT_RECORD), DWORD, PDWORD); 251 HANDLE hConsoleInput, < 252 INPUT_RECORD *lpBuffer, < 253 DWORD nLength, < 254 LPDWORD lpNumberOfEventsWritten < 255 ); < 256 // #ifdef UNICODE < 257 alias WriteConsoleInputW WriteConsoleInput; < 258 // #else < 259 // #... < 260 // #endif // !UNICODE < > 243 BOOL WriteConsoleOutputA(HANDLE, CPtr!(CHAR_INFO), COORD, COORD, PSMALL_RECT); > 244 BOOL WriteConsoleOutputW(HANDLE, CPtr!(CHAR_INFO), COORD, COORD, PSMALL_RECT); > 245 BOOL WriteConsoleOutputAttribute(HANDLE, CPtr!(WORD), DWORD, COORD, PDWORD); > 246 BOOL WriteConsoleOutputCharacterA(HANDLE, LPCSTR, DWORD, COORD, PDWORD); > 247 BOOL WriteConsoleOutputCharacterW(HANDLE, LPCWSTR, DWORD, COORD, PDWORD); 261 248 262 extern(Windows) export BOOL ReadConsoleOutputA( | 249 version (Unicode) { 263 HANDLE hConsoleOutput, | 250 alias FillConsoleOutputCharacterW FillConsoleOutputCharacter; 264 PCHAR_INFO lpBuffer, | 251 alias GetConsoleTitleW GetConsoleTitle; 265 COORD dwBufferSize, | 252 alias PeekConsoleInputW PeekConsoleInput; 266 COORD dwBufferCoord, | 253 alias ReadConsoleW ReadConsole; 267 PSMALL_RECT lpReadRegion | 254 alias ReadConsoleInputW ReadConsoleInput; 268 ); < 269 extern(Windows) export BOOL ReadConsoleOutputW( < 270 HANDLE hConsoleOutput, < 271 PCHAR_INFO lpBuffer, < 272 COORD dwBufferSize, < 273 COORD dwBufferCoord, < 274 PSMALL_RECT lpReadRegion < 275 ); < 276 // #ifdef UNICODE < 277 alias ReadConsoleOutputW ReadConsoleOutput; | 255 alias ReadConsoleOutputW ReadConsoleOutput; 278 // #else < 279 // #... < 280 // #endif // !UNICODE < 281 < 282 extern(Windows) export BOOL WriteConsoleOutputA( < 283 HANDLE hConsoleOutput, < 284 CHAR_INFO *lpBuffer, < 285 COORD dwBufferSize, < 286 COORD dwBufferCoord, < 287 PSMALL_RECT lpWriteRegion < 288 ); < 289 extern(Windows) export BOOL WriteConsoleOutputW( < 290 HANDLE hConsoleOutput, < 291 CHAR_INFO *lpBuffer, < 292 COORD dwBufferSize, < 293 COORD dwBufferCoord, < 294 PSMALL_RECT lpWriteRegion < 295 ); < 296 // #ifdef UNICODE < 297 alias WriteConsoleOutputW WriteConsoleOutput; < 298 // #else < 299 // #... < 300 // #endif // !UNICODE < 301 < 302 extern(Windows) export BOOL ReadConsoleOutputCharacterA( < 303 HANDLE hConsoleOutput, < 304 LPSTR lpCharacter, < 305 DWORD nLength, < 306 COORD dwReadCoord, < 307 LPDWORD lpNumberOfCharsRead < 308 ); < 309 extern(Windows) export BOOL ReadConsoleOutputCharacterW( < 310 HANDLE hConsoleOutput, < 311 LPWSTR lpCharacter, < 312 DWORD nLength, < 313 COORD dwReadCoord, < 314 LPDWORD lpNumberOfCharsRead < 315 ); < 316 // #ifdef UNICODE < 317 alias ReadConsoleOutputCharacterW ReadConsoleOutputCharacter; | 256 alias ReadConsoleOutputCharacterW ReadConsoleOutputCharacter; 318 // #else < 319 // #... < 320 // #endif // !UNICODE < 321 < 322 extern(Windows) export BOOL ReadConsoleOutputAttribute( < > 257 alias ScrollConsoleScreenBufferW ScrollConsoleScreenBuffer; > 258 alias SetConsoleTitleW SetConsoleTitle; > 259 alias WriteConsoleW WriteConsole; > 260 alias WriteConsoleInputW WriteConsoleInput; 323 HANDLE hConsoleOutput, | 261 alias WriteConsoleOutputW WriteConsoleOutput; 324 LPWORD lpAttribute, < 325 DWORD nLength, < 326 COORD dwReadCoord, < 327 LPDWORD lpNumberOfAttrsRead < 328 ); < 329 < 330 extern(Windows) export BOOL WriteConsoleOutputCharacterA( < 331 HANDLE hConsoleOutput, < 332 LPCSTR lpCharacter, < 333 DWORD nLength, < 334 COORD dwWriteCoord, < 335 LPDWORD lpNumberOfCharsWritten < 336 ); < 337 extern(Windows) export BOOL WriteConsoleOutputCharacterW( < 338 HANDLE hConsoleOutput, < 339 LPCWSTR lpCharacter, < 340 DWORD nLength, < 341 COORD dwWriteCoord, < 342 LPDWORD lpNumberOfCharsWritten < 343 ); < 344 // #ifdef UNICODE < 345 alias WriteConsoleOutputCharacterW WriteConsoleOutputCharacter; | 262 alias WriteConsoleOutputCharacterW WriteConsoleOutputCharacter; 346 // #else | 263 } else { 347 // #... < 348 // #endif // !UNICODE < 349 < 350 extern(Windows) export BOOL WriteConsoleOutputAttribute( < 351 HANDLE hConsoleOutput, < 352 WORD *lpAttribute, < 353 DWORD nLength, < 354 COORD dwWriteCoord, < 355 LPDWORD lpNumberOfAttrsWritten < 356 ); < 357 < 358 extern(Windows) export BOOL FillConsoleOutputCharacterA( < 359 HANDLE hConsoleOutput, < 360 CHAR cCharacter, < 361 DWORD nLength, < 362 COORD dwWriteCoord, < 363 LPDWORD lpNumberOfCharsWritten < 364 ); < 365 extern(Windows) export BOOL FillConsoleOutputCharacterW( < 366 HANDLE hConsoleOutput, < 367 WCHAR cCharacter, < 368 DWORD nLength, < 369 COORD dwWriteCoord, < 370 LPDWORD lpNumberOfCharsWritten < 371 ); < 372 // #ifdef UNICODE < 373 alias FillConsoleOutputCharacterW FillConsoleOutputCharacter; | 264 alias FillConsoleOutputCharacterA FillConsoleOutputCharacter; 374 // #else < 375 // #... < 376 // #endif // !UNICODE < 377 < 378 extern(Windows) export BOOL FillConsoleOutputAttribute( < 379 HANDLE hConsoleOutput, < 380 WORD wAttribute, < 381 DWORD nLength, < 382 COORD dwWriteCoord, < 383 LPDWORD lpNumberOfAttrsWritten < 384 ); < 385 < 386 extern(Windows) export BOOL GetConsoleMode( < 387 HANDLE hConsoleHandle, < 388 LPDWORD lpMode < 389 ); < 390 < 391 extern(Windows) export BOOL GetNumberOfConsoleInputEvents( < > 265 alias GetConsoleTitleA GetConsoleTitle; 392 HANDLE hConsoleInput, | 266 alias PeekConsoleInputA PeekConsoleInput; 393 LPDWORD lpNumberOfEvents < 394 ); < 395 < 396 extern(Windows) export BOOL GetConsoleScreenBufferInfo( < 397 HANDLE hConsoleOutput, < 398 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo < 399 ); < 400 < 401 extern(Windows) export COORD GetLargestConsoleWindowSize( < 402 HANDLE hConsoleOutput < 403 ); < 404 < 405 extern(Windows) export BOOL GetConsoleCursorInfo( < 406 HANDLE hConsoleOutput, < 407 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo < 408 ); < 409 < 410 // #if(_WIN32_WINNT >= 0x0500) < 411 < 412 extern(Windows) export BOOL GetCurrentConsoleFont( < 413 HANDLE hConsoleOutput, < 414 BOOL bMaximumWindow, < 415 PCONSOLE_FONT_INFO lpConsoleCurrentFont < 416 ); < 417 < 418 extern(Windows) export COORD GetConsoleFontSize( < 419 HANDLE hConsoleOutput, < 420 DWORD nFont < 421 ); < 422 < 423 extern(Windows) export BOOL GetConsoleSelectionInfo( < 424 PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo < 425 ); < 426 < 427 // #endif /* _WIN32_WINNT >= 0x0500 */ < 428 < 429 extern(Windows) export BOOL GetNumberOfConsoleMouseButtons( < 430 LPDWORD lpNumberOfMouseButtons < 431 ); < 432 < 433 extern(Windows) export BOOL SetConsoleMode( < 434 HANDLE hConsoleHandle, < 435 DWORD dwMode < 436 ); < 437 < 438 extern(Windows) export BOOL SetConsoleActiveScreenBuffer( < 439 HANDLE hConsoleOutput < 440 ); < 441 < 442 extern(Windows) export BOOL FlushConsoleInputBuffer( < > 267 alias ReadConsoleA ReadConsole; 443 HANDLE hConsoleInput | 268 alias ReadConsoleInputA ReadConsoleInput; 444 ); < 445 < 446 extern(Windows) export BOOL SetConsoleScreenBufferSize( < 447 HANDLE hConsoleOutput, | 269 alias ReadConsoleOutputA ReadConsoleOutput; 448 COORD dwSize < 449 ); < 450 < 451 extern(Windows) export BOOL SetConsoleCursorPosition( < 452 HANDLE hConsoleOutput, < 453 COORD dwCursorPosition < 454 ); < 455 < 456 extern(Windows) export BOOL SetConsoleCursorInfo( < 457 HANDLE hConsoleOutput, < 458 CONSOLE_CURSOR_INFO *lpConsoleCursorInfo < 459 ); < 460 < 461 extern(Windows) export BOOL ScrollConsoleScreenBufferA( < 462 HANDLE hConsoleOutput, < 463 SMALL_RECT *lpScrollRectangle, < 464 SMALL_RECT *lpClipRectangle, < 465 COORD dwDestinationOrigin, < 466 CHAR_INFO *lpFill < 467 ); < 468 extern(Windows) export BOOL ScrollConsoleScreenBufferW( < 469 HANDLE hConsoleOutput, < 470 SMALL_RECT *lpScrollRectangle, < 471 SMALL_RECT *lpClipRectangle, < 472 COORD dwDestinationOrigin, < 473 CHAR_INFO *lpFill < 474 ); < 475 // #ifdef UNICODE < > 270 alias ReadConsoleOutputCharacterA ReadConsoleOutputCharacter; 476 alias ScrollConsoleScreenBufferW ScrollConsoleScreenBuffer; | 271 alias ScrollConsoleScreenBufferA ScrollConsoleScreenBuffer; 477 // #else < 478 // #... < 479 // #endif // !UNICODE < 480 < 481 extern(Windows) export BOOL SetConsoleWindowInfo( < 482 HANDLE hConsoleOutput, < 483 BOOL bAbsolute, < 484 SMALL_RECT *lpConsoleWindow < 485 ); < 486 < 487 extern(Windows) export BOOL SetConsoleTextAttribute( < 488 HANDLE hConsoleOutput, < 489 WORD wAttributes < 490 ); < 491 < 492 extern(Windows) export BOOL SetConsoleCtrlHandler( < 493 PHANDLER_ROUTINE HandlerRoutine, < 494 BOOL Add < 495 ); < 496 < 497 extern(Windows) export BOOL GenerateConsoleCtrlEvent( < 498 DWORD dwCtrlEvent, < 499 DWORD dwProcessGroupId < 500 ); < 501 < 502 extern(Windows) export BOOL AllocConsole(); < 503 < 504 extern(Windows) export BOOL FreeConsole(); < 505 < 506 // #if(_WIN32_WINNT >= 0x0500) < 507 extern(Windows) export BOOL AttachConsole( < 508 DWORD dwProcessId < 509 ); < 510 // #endif /* _WIN32_WINNT >= 0x0500 */ < 511 < 512 extern(Windows) export DWORD GetConsoleTitleA( < 513 LPSTR lpConsoleTitle, < 514 DWORD nSize < 515 ); < 516 extern(Windows) export DWORD GetConsoleTitleW( < 517 LPWSTR lpConsoleTitle, < 518 DWORD nSize < 519 ); < 520 // #ifdef UNICODE < 521 alias GetConsoleTitleW GetConsoleTitle; < 522 // #else < 523 // #... < 524 // #endif // !UNICODE < 525 < 526 extern(Windows) export BOOL SetConsoleTitleA( < 527 LPCSTR lpConsoleTitle < 528 ); < 529 extern(Windows) export BOOL SetConsoleTitleW( < 530 LPCWSTR lpConsoleTitle < 531 ); < 532 // #ifdef UNICODE < 533 alias SetConsoleTitleW SetConsoleTitle; | 272 alias SetConsoleTitleA SetConsoleTitle; 534 // #else < 535 // #... < 536 // #endif // !UNICODE < 537 < 538 extern(Windows) export BOOL ReadConsoleA( < 539 HANDLE hConsoleInput, < 540 LPVOID lpBuffer, < 541 DWORD nNumberOfCharsToRead, < 542 LPDWORD lpNumberOfCharsRead, < 543 LPVOID lpReserved < 544 ); < 545 extern(Windows) export BOOL ReadConsoleW( < 546 HANDLE hConsoleInput, < 547 LPVOID lpBuffer, < 548 DWORD nNumberOfCharsToRead, < 549 LPDWORD lpNumberOfCharsRead, < 550 LPVOID lpReserved < 551 ); < 552 // #ifdef UNICODE < 553 alias ReadConsoleW ReadConsole; < 554 // #else < 555 // #... < 556 // #endif // !UNICODE < 557 < 558 extern(Windows) export BOOL WriteConsoleA( | 273 alias WriteConsoleA WriteConsole; > 274 alias WriteConsoleInputA WriteConsoleInput; 559 HANDLE hConsoleOutput, | 275 alias WriteConsoleOutputA WriteConsoleOutput; 560 VOID *lpBuffer, < 561 DWORD nNumberOfCharsToWrite, < 562 LPDWORD lpNumberOfCharsWritten, < 563 LPVOID lpReserved < 564 ); < 565 extern(Windows) export BOOL WriteConsoleW( < 566 HANDLE hConsoleOutput, < 567 VOID *lpBuffer, < 568 DWORD nNumberOfCharsToWrite, < 569 LPDWORD lpNumberOfCharsWritten, < 570 LPVOID lpReserved < 571 ); < 572 // #ifdef UNICODE < 573 alias WriteConsoleW WriteConsole; | 276 alias WriteConsoleOutputCharacterA WriteConsoleOutputCharacter; 574 // #else < 575 // #... < 576 // #endif // !UNICODE < 577 | 277 } 578 enum : uint { CONSOLE_TEXTMODE_BUFFER = 1 } < 579 < 580 extern(Windows) export HANDLE CreateConsoleScreenBuffer( < 581 DWORD dwDesiredAccess, < 582 DWORD dwShareMode, < 583 SECURITY_ATTRIBUTES *lpSecurityAttributes, < 584 DWORD dwFlags, < 585 LPVOID lpScreenBufferData < 586 ); < 587 < 588 extern(Windows) export UINT GetConsoleCP(); < 589 < 590 extern(Windows) export BOOL SetConsoleCP( < 591 UINT wCodePageID < 592 ); < 593 < 594 extern(Windows) export UINT GetConsoleOutputCP(); < 595 < 596 extern(Windows) export BOOL SetConsoleOutputCP( < 597 UINT wCodePageID < 598 ); < 599 < 600 // #if(_WIN32_WINNT >= 0x0500) < 601 < 602 enum : uint { CONSOLE_FULLSCREEN = 1 } < 603 enum : uint { CONSOLE_FULLSCREEN_HARDWARE = 2 } < 604 < 605 extern(Windows) export BOOL GetConsoleDisplayMode( < 606 LPDWORD lpModeFlags < 607 ); < 608 < 609 extern(Windows) export HWND GetConsoleWindow(); < 610 < 611 // #endif /* _WIN32_WINNT >= 0x0500 */ < 612 < 613 // #if(_WIN32_WINNT >= 0x0501) < 614 < 615 extern(Windows) export DWORD GetConsoleProcessList( < 616 LPDWORD lpdwProcessList, < 617 DWORD dwProcessCount); < 618 // #endif /* _WIN32_WINNT >= 0x0501 */ < 619 < 620 // #ifdef __cplusplus < 621 // } < 622 // #endif < 623 < 624 // #endif // _WINCON_ < 625 <