2 * Win32 console functions
4 * Copyright 1995 Martin von Loewis and Cameron Heide
5 * Copyright 1997 Karl Garrison
6 * Copyright 1998 John Richardson
7 * Copyright 1998 Marcus Meissner
8 * Copyright 2001,2002,2004 Eric Pouech
9 * Copyright 2001 Alexandre Julliard
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 /* Reference applications:
27 * - IDA (interactive disassembler) full version 3.75. Works.
28 * - LYNX/W32. Works mostly, some keys crash it.
32 #include "wine/port.h"
47 #include "wine/winbase16.h"
48 #include "wine/server.h"
49 #include "wine/exception.h"
50 #include "wine/unicode.h"
51 #include "wine/debug.h"
53 #include "console_private.h"
54 #include "kernel_private.h"
57 WINE_DEFAULT_DEBUG_CHANNEL(console
);
59 static UINT console_input_codepage
;
60 static UINT console_output_codepage
;
63 /* map input records to ASCII */
64 static void input_records_WtoA( INPUT_RECORD
*buffer
, int count
)
69 for (i
= 0; i
< count
; i
++)
71 if (buffer
[i
].EventType
!= KEY_EVENT
) continue;
72 WideCharToMultiByte( GetConsoleCP(), 0,
73 &buffer
[i
].Event
.KeyEvent
.uChar
.UnicodeChar
, 1, &ch
, 1, NULL
, NULL
);
74 buffer
[i
].Event
.KeyEvent
.uChar
.AsciiChar
= ch
;
78 /* map input records to Unicode */
79 static void input_records_AtoW( INPUT_RECORD
*buffer
, int count
)
84 for (i
= 0; i
< count
; i
++)
86 if (buffer
[i
].EventType
!= KEY_EVENT
) continue;
87 MultiByteToWideChar( GetConsoleCP(), 0,
88 &buffer
[i
].Event
.KeyEvent
.uChar
.AsciiChar
, 1, &ch
, 1 );
89 buffer
[i
].Event
.KeyEvent
.uChar
.UnicodeChar
= ch
;
93 /* map char infos to ASCII */
94 static void char_info_WtoA( CHAR_INFO
*buffer
, int count
)
100 WideCharToMultiByte( GetConsoleOutputCP(), 0, &buffer
->Char
.UnicodeChar
, 1,
101 &ch
, 1, NULL
, NULL
);
102 buffer
->Char
.AsciiChar
= ch
;
107 /* map char infos to Unicode */
108 static void char_info_AtoW( CHAR_INFO
*buffer
, int count
)
114 MultiByteToWideChar( GetConsoleOutputCP(), 0, &buffer
->Char
.AsciiChar
, 1, &ch
, 1 );
115 buffer
->Char
.UnicodeChar
= ch
;
121 /******************************************************************************
122 * GetConsoleWindow [KERNEL32.@]
124 HWND WINAPI
GetConsoleWindow(VOID
)
131 /******************************************************************************
132 * GetConsoleCP [KERNEL32.@] Returns the OEM code page for the console
137 UINT WINAPI
GetConsoleCP(VOID
)
139 if (!console_input_codepage
)
141 console_input_codepage
= GetOEMCP();
142 TRACE("%u\n", console_input_codepage
);
144 return console_input_codepage
;
148 /******************************************************************************
149 * SetConsoleCP [KERNEL32.@]
151 BOOL WINAPI
SetConsoleCP(UINT cp
)
153 if (!IsValidCodePage( cp
)) return FALSE
;
154 console_input_codepage
= cp
;
159 /***********************************************************************
160 * GetConsoleOutputCP (KERNEL32.@)
162 UINT WINAPI
GetConsoleOutputCP(VOID
)
164 if (!console_output_codepage
)
166 console_output_codepage
= GetOEMCP();
167 TRACE("%u\n", console_output_codepage
);
169 return console_output_codepage
;
173 /******************************************************************************
174 * SetConsoleOutputCP [KERNEL32.@] Set the output codepage used by the console
177 * cp [I] code page to set
183 BOOL WINAPI
SetConsoleOutputCP(UINT cp
)
185 if (!IsValidCodePage( cp
)) return FALSE
;
186 console_output_codepage
= cp
;
191 /***********************************************************************
194 BOOL WINAPI
Beep( DWORD dwFreq
, DWORD dwDur
)
196 static const char beep
= '\a';
197 /* dwFreq and dwDur are ignored by Win95 */
198 if (isatty(2)) write( 2, &beep
, 1 );
203 /******************************************************************
204 * OpenConsoleW (KERNEL32.@)
207 * Open a handle to the current process console.
208 * Returns INVALID_HANDLE_VALUE on failure.
210 HANDLE WINAPI
OpenConsoleW(LPCWSTR name
, DWORD access
, BOOL inherit
, DWORD creation
)
212 static const WCHAR coninW
[] = {'C','O','N','I','N','$',0};
213 static const WCHAR conoutW
[] = {'C','O','N','O','U','T','$',0};
217 if (strcmpiW(coninW
, name
) == 0)
219 else if (strcmpiW(conoutW
, name
) == 0)
223 SetLastError(ERROR_INVALID_NAME
);
224 return INVALID_HANDLE_VALUE
;
226 if (creation
!= OPEN_EXISTING
)
228 SetLastError(ERROR_INVALID_PARAMETER
);
229 return INVALID_HANDLE_VALUE
;
232 SERVER_START_REQ( open_console
)
235 req
->access
= access
;
236 req
->share
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
237 req
->inherit
= inherit
;
239 wine_server_call_err( req
);
243 return ret
? console_handle_map(ret
) : INVALID_HANDLE_VALUE
;
246 /******************************************************************
247 * VerifyConsoleIoHandle (KERNEL32.@)
251 BOOL WINAPI
VerifyConsoleIoHandle(HANDLE handle
)
255 if (!is_console_handle(handle
)) return FALSE
;
256 SERVER_START_REQ(get_console_mode
)
258 req
->handle
= console_handle_unmap(handle
);
259 ret
= !wine_server_call_err( req
);
265 /******************************************************************
266 * DuplicateConsoleHandle (KERNEL32.@)
270 HANDLE WINAPI
DuplicateConsoleHandle(HANDLE handle
, DWORD access
, BOOL inherit
,
275 if (!is_console_handle(handle
) ||
276 !DuplicateHandle(GetCurrentProcess(), console_handle_unmap(handle
),
277 GetCurrentProcess(), &ret
, access
, inherit
, options
))
278 return INVALID_HANDLE_VALUE
;
279 return console_handle_map(ret
);
282 /******************************************************************
283 * CloseConsoleHandle (KERNEL32.@)
287 BOOL WINAPI
CloseConsoleHandle(HANDLE handle
)
289 if (!is_console_handle(handle
))
291 SetLastError(ERROR_INVALID_PARAMETER
);
294 return CloseHandle(console_handle_unmap(handle
));
297 /******************************************************************
298 * GetConsoleInputWaitHandle (KERNEL32.@)
302 HANDLE WINAPI
GetConsoleInputWaitHandle(void)
304 static HANDLE console_wait_event
;
306 /* FIXME: this is not thread safe */
307 if (!console_wait_event
)
309 SERVER_START_REQ(get_console_wait_event
)
311 if (!wine_server_call_err( req
)) console_wait_event
= reply
->handle
;
315 return console_wait_event
;
319 /******************************************************************************
320 * WriteConsoleInputA [KERNEL32.@]
322 BOOL WINAPI
WriteConsoleInputA( HANDLE handle
, const INPUT_RECORD
*buffer
,
323 DWORD count
, LPDWORD written
)
328 if (!(recW
= HeapAlloc( GetProcessHeap(), 0, count
* sizeof(*recW
) ))) return FALSE
;
329 memcpy( recW
, buffer
, count
*sizeof(*recW
) );
330 input_records_AtoW( recW
, count
);
331 ret
= WriteConsoleInputW( handle
, recW
, count
, written
);
332 HeapFree( GetProcessHeap(), 0, recW
);
337 /******************************************************************************
338 * WriteConsoleInputW [KERNEL32.@]
340 BOOL WINAPI
WriteConsoleInputW( HANDLE handle
, const INPUT_RECORD
*buffer
,
341 DWORD count
, LPDWORD written
)
345 TRACE("(%p,%p,%ld,%p)\n", handle
, buffer
, count
, written
);
347 if (written
) *written
= 0;
348 SERVER_START_REQ( write_console_input
)
350 req
->handle
= console_handle_unmap(handle
);
351 wine_server_add_data( req
, buffer
, count
* sizeof(INPUT_RECORD
) );
352 if ((ret
= !wine_server_call_err( req
)) && written
)
353 *written
= reply
->written
;
361 /***********************************************************************
362 * WriteConsoleOutputA (KERNEL32.@)
364 BOOL WINAPI
WriteConsoleOutputA( HANDLE hConsoleOutput
, const CHAR_INFO
*lpBuffer
,
365 COORD size
, COORD coord
, LPSMALL_RECT region
)
369 COORD new_size
, new_coord
;
372 new_size
.X
= min( region
->Right
- region
->Left
+ 1, size
.X
- coord
.X
);
373 new_size
.Y
= min( region
->Bottom
- region
->Top
+ 1, size
.Y
- coord
.Y
);
375 if (new_size
.X
<= 0 || new_size
.Y
<= 0)
377 region
->Bottom
= region
->Top
+ new_size
.Y
- 1;
378 region
->Right
= region
->Left
+ new_size
.X
- 1;
382 /* only copy the useful rectangle */
383 if (!(ciw
= HeapAlloc( GetProcessHeap(), 0, sizeof(CHAR_INFO
) * new_size
.X
* new_size
.Y
)))
385 for (y
= 0; y
< new_size
.Y
; y
++)
387 memcpy( &ciw
[y
* new_size
.X
], &lpBuffer
[(y
+ coord
.Y
) * size
.X
+ coord
.X
],
388 new_size
.X
* sizeof(CHAR_INFO
) );
389 char_info_AtoW( ciw
, new_size
.X
);
391 new_coord
.X
= new_coord
.Y
= 0;
392 ret
= WriteConsoleOutputW( hConsoleOutput
, ciw
, new_size
, new_coord
, region
);
393 HeapFree( GetProcessHeap(), 0, ciw
);
398 /***********************************************************************
399 * WriteConsoleOutputW (KERNEL32.@)
401 BOOL WINAPI
WriteConsoleOutputW( HANDLE hConsoleOutput
, const CHAR_INFO
*lpBuffer
,
402 COORD size
, COORD coord
, LPSMALL_RECT region
)
404 int width
, height
, y
;
407 TRACE("(%p,%p,(%d,%d),(%d,%d),(%d,%dx%d,%d)\n",
408 hConsoleOutput
, lpBuffer
, size
.X
, size
.Y
, coord
.X
, coord
.Y
,
409 region
->Left
, region
->Top
, region
->Right
, region
->Bottom
);
411 width
= min( region
->Right
- region
->Left
+ 1, size
.X
- coord
.X
);
412 height
= min( region
->Bottom
- region
->Top
+ 1, size
.Y
- coord
.Y
);
414 if (width
> 0 && height
> 0)
416 for (y
= 0; y
< height
; y
++)
418 SERVER_START_REQ( write_console_output
)
420 req
->handle
= console_handle_unmap(hConsoleOutput
);
421 req
->x
= region
->Left
;
422 req
->y
= region
->Top
+ y
;
423 req
->mode
= CHAR_INFO_MODE_TEXTATTR
;
425 wine_server_add_data( req
, &lpBuffer
[(y
+ coord
.Y
) * size
.X
+ coord
.X
],
426 width
* sizeof(CHAR_INFO
));
427 if ((ret
= !wine_server_call_err( req
)))
429 width
= min( width
, reply
->width
- region
->Left
);
430 height
= min( height
, reply
->height
- region
->Top
);
437 region
->Bottom
= region
->Top
+ height
- 1;
438 region
->Right
= region
->Left
+ width
- 1;
443 /******************************************************************************
444 * WriteConsoleOutputCharacterA [KERNEL32.@] Copies character to consecutive
445 * cells in the console screen buffer
448 * hConsoleOutput [I] Handle to screen buffer
449 * str [I] Pointer to buffer with chars to write
450 * length [I] Number of cells to write to
451 * coord [I] Coords of first cell
452 * lpNumCharsWritten [O] Pointer to number of cells written
454 BOOL WINAPI
WriteConsoleOutputCharacterA( HANDLE hConsoleOutput
, LPCSTR str
, DWORD length
,
455 COORD coord
, LPDWORD lpNumCharsWritten
)
461 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput
,
462 debugstr_an(str
, length
), length
, coord
.X
, coord
.Y
, lpNumCharsWritten
);
464 lenW
= MultiByteToWideChar( GetConsoleOutputCP(), 0, str
, length
, NULL
, 0 );
466 if (lpNumCharsWritten
) *lpNumCharsWritten
= 0;
468 if (!(strW
= HeapAlloc( GetProcessHeap(), 0, lenW
* sizeof(WCHAR
) ))) return FALSE
;
469 MultiByteToWideChar( GetConsoleOutputCP(), 0, str
, length
, strW
, lenW
);
471 ret
= WriteConsoleOutputCharacterW( hConsoleOutput
, strW
, lenW
, coord
, lpNumCharsWritten
);
472 HeapFree( GetProcessHeap(), 0, strW
);
477 /******************************************************************************
478 * WriteConsoleOutputAttribute [KERNEL32.@] Sets attributes for some cells in
479 * the console screen buffer
482 * hConsoleOutput [I] Handle to screen buffer
483 * attr [I] Pointer to buffer with write attributes
484 * length [I] Number of cells to write to
485 * coord [I] Coords of first cell
486 * lpNumAttrsWritten [O] Pointer to number of cells written
493 BOOL WINAPI
WriteConsoleOutputAttribute( HANDLE hConsoleOutput
, CONST WORD
*attr
, DWORD length
,
494 COORD coord
, LPDWORD lpNumAttrsWritten
)
498 TRACE("(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput
,attr
,length
,coord
.X
,coord
.Y
,lpNumAttrsWritten
);
500 SERVER_START_REQ( write_console_output
)
502 req
->handle
= console_handle_unmap(hConsoleOutput
);
505 req
->mode
= CHAR_INFO_MODE_ATTR
;
507 wine_server_add_data( req
, attr
, length
* sizeof(WORD
) );
508 if ((ret
= !wine_server_call_err( req
)))
510 if (lpNumAttrsWritten
) *lpNumAttrsWritten
= reply
->written
;
518 /******************************************************************************
519 * FillConsoleOutputCharacterA [KERNEL32.@]
522 * hConsoleOutput [I] Handle to screen buffer
523 * ch [I] Character to write
524 * length [I] Number of cells to write to
525 * coord [I] Coords of first cell
526 * lpNumCharsWritten [O] Pointer to number of cells written
532 BOOL WINAPI
FillConsoleOutputCharacterA( HANDLE hConsoleOutput
, CHAR ch
, DWORD length
,
533 COORD coord
, LPDWORD lpNumCharsWritten
)
537 MultiByteToWideChar( GetConsoleOutputCP(), 0, &ch
, 1, &wch
, 1 );
538 return FillConsoleOutputCharacterW(hConsoleOutput
, wch
, length
, coord
, lpNumCharsWritten
);
542 /******************************************************************************
543 * FillConsoleOutputCharacterW [KERNEL32.@] Writes characters to console
546 * hConsoleOutput [I] Handle to screen buffer
547 * ch [I] Character to write
548 * length [I] Number of cells to write to
549 * coord [I] Coords of first cell
550 * lpNumCharsWritten [O] Pointer to number of cells written
556 BOOL WINAPI
FillConsoleOutputCharacterW( HANDLE hConsoleOutput
, WCHAR ch
, DWORD length
,
557 COORD coord
, LPDWORD lpNumCharsWritten
)
561 TRACE("(%p,%s,%ld,(%dx%d),%p)\n",
562 hConsoleOutput
, debugstr_wn(&ch
, 1), length
, coord
.X
, coord
.Y
, lpNumCharsWritten
);
564 SERVER_START_REQ( fill_console_output
)
566 req
->handle
= console_handle_unmap(hConsoleOutput
);
569 req
->mode
= CHAR_INFO_MODE_TEXT
;
573 if ((ret
= !wine_server_call_err( req
)))
575 if (lpNumCharsWritten
) *lpNumCharsWritten
= reply
->written
;
583 /******************************************************************************
584 * FillConsoleOutputAttribute [KERNEL32.@] Sets attributes for console
587 * hConsoleOutput [I] Handle to screen buffer
588 * attr [I] Color attribute to write
589 * length [I] Number of cells to write to
590 * coord [I] Coords of first cell
591 * lpNumAttrsWritten [O] Pointer to number of cells written
597 BOOL WINAPI
FillConsoleOutputAttribute( HANDLE hConsoleOutput
, WORD attr
, DWORD length
,
598 COORD coord
, LPDWORD lpNumAttrsWritten
)
602 TRACE("(%p,%d,%ld,(%dx%d),%p)\n",
603 hConsoleOutput
, attr
, length
, coord
.X
, coord
.Y
, lpNumAttrsWritten
);
605 SERVER_START_REQ( fill_console_output
)
607 req
->handle
= console_handle_unmap(hConsoleOutput
);
610 req
->mode
= CHAR_INFO_MODE_ATTR
;
612 req
->data
.attr
= attr
;
614 if ((ret
= !wine_server_call_err( req
)))
616 if (lpNumAttrsWritten
) *lpNumAttrsWritten
= reply
->written
;
624 /******************************************************************************
625 * ReadConsoleOutputCharacterA [KERNEL32.@]
628 BOOL WINAPI
ReadConsoleOutputCharacterA(HANDLE hConsoleOutput
, LPSTR lpstr
, DWORD count
,
629 COORD coord
, LPDWORD read_count
)
633 LPWSTR wptr
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(WCHAR
));
635 if (read_count
) *read_count
= 0;
636 if (!wptr
) return FALSE
;
638 if ((ret
= ReadConsoleOutputCharacterW( hConsoleOutput
, wptr
, count
, coord
, &read
)))
640 read
= WideCharToMultiByte( GetConsoleOutputCP(), 0, wptr
, read
, lpstr
, count
, NULL
, NULL
);
641 if (read_count
) *read_count
= read
;
643 HeapFree( GetProcessHeap(), 0, wptr
);
648 /******************************************************************************
649 * ReadConsoleOutputCharacterW [KERNEL32.@]
652 BOOL WINAPI
ReadConsoleOutputCharacterW( HANDLE hConsoleOutput
, LPWSTR buffer
, DWORD count
,
653 COORD coord
, LPDWORD read_count
)
657 TRACE( "(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput
, buffer
, count
, coord
.X
, coord
.Y
, read_count
);
659 SERVER_START_REQ( read_console_output
)
661 req
->handle
= console_handle_unmap(hConsoleOutput
);
664 req
->mode
= CHAR_INFO_MODE_TEXT
;
666 wine_server_set_reply( req
, buffer
, count
* sizeof(WCHAR
) );
667 if ((ret
= !wine_server_call_err( req
)))
669 if (read_count
) *read_count
= wine_server_reply_size(reply
) / sizeof(WCHAR
);
677 /******************************************************************************
678 * ReadConsoleOutputAttribute [KERNEL32.@]
680 BOOL WINAPI
ReadConsoleOutputAttribute(HANDLE hConsoleOutput
, LPWORD lpAttribute
, DWORD length
,
681 COORD coord
, LPDWORD read_count
)
685 TRACE("(%p,%p,%ld,%dx%d,%p)\n",
686 hConsoleOutput
, lpAttribute
, length
, coord
.X
, coord
.Y
, read_count
);
688 SERVER_START_REQ( read_console_output
)
690 req
->handle
= console_handle_unmap(hConsoleOutput
);
693 req
->mode
= CHAR_INFO_MODE_ATTR
;
695 wine_server_set_reply( req
, lpAttribute
, length
* sizeof(WORD
) );
696 if ((ret
= !wine_server_call_err( req
)))
698 if (read_count
) *read_count
= wine_server_reply_size(reply
) / sizeof(WORD
);
706 /******************************************************************************
707 * ReadConsoleOutputA [KERNEL32.@]
710 BOOL WINAPI
ReadConsoleOutputA( HANDLE hConsoleOutput
, LPCHAR_INFO lpBuffer
, COORD size
,
711 COORD coord
, LPSMALL_RECT region
)
716 ret
= ReadConsoleOutputW( hConsoleOutput
, lpBuffer
, size
, coord
, region
);
717 if (ret
&& region
->Right
>= region
->Left
)
719 for (y
= 0; y
<= region
->Bottom
- region
->Top
; y
++)
721 char_info_WtoA( &lpBuffer
[(coord
.Y
+ y
) * size
.X
+ coord
.X
],
722 region
->Right
- region
->Left
+ 1 );
729 /******************************************************************************
730 * ReadConsoleOutputW [KERNEL32.@]
732 * NOTE: The NT4 (sp5) kernel crashes on me if size is (0,0). I don't
733 * think we need to be *that* compatible. -- AJ
735 BOOL WINAPI
ReadConsoleOutputW( HANDLE hConsoleOutput
, LPCHAR_INFO lpBuffer
, COORD size
,
736 COORD coord
, LPSMALL_RECT region
)
738 int width
, height
, y
;
741 width
= min( region
->Right
- region
->Left
+ 1, size
.X
- coord
.X
);
742 height
= min( region
->Bottom
- region
->Top
+ 1, size
.Y
- coord
.Y
);
744 if (width
> 0 && height
> 0)
746 for (y
= 0; y
< height
; y
++)
748 SERVER_START_REQ( read_console_output
)
750 req
->handle
= console_handle_unmap(hConsoleOutput
);
751 req
->x
= region
->Left
;
752 req
->y
= region
->Top
+ y
;
753 req
->mode
= CHAR_INFO_MODE_TEXTATTR
;
755 wine_server_set_reply( req
, &lpBuffer
[(y
+coord
.Y
) * size
.X
+ coord
.X
],
756 width
* sizeof(CHAR_INFO
) );
757 if ((ret
= !wine_server_call_err( req
)))
759 width
= min( width
, reply
->width
- region
->Left
);
760 height
= min( height
, reply
->height
- region
->Top
);
767 region
->Bottom
= region
->Top
+ height
- 1;
768 region
->Right
= region
->Left
+ width
- 1;
773 /******************************************************************************
774 * ReadConsoleInputA [KERNEL32.@] Reads data from a console
777 * handle [I] Handle to console input buffer
778 * buffer [O] Address of buffer for read data
779 * count [I] Number of records to read
780 * pRead [O] Address of number of records read
786 BOOL WINAPI
ReadConsoleInputA( HANDLE handle
, PINPUT_RECORD buffer
, DWORD count
, LPDWORD pRead
)
790 if (!ReadConsoleInputW( handle
, buffer
, count
, &read
)) return FALSE
;
791 input_records_WtoA( buffer
, read
);
792 if (pRead
) *pRead
= read
;
797 /***********************************************************************
798 * PeekConsoleInputA (KERNEL32.@)
800 * Gets 'count' first events (or less) from input queue.
802 BOOL WINAPI
PeekConsoleInputA( HANDLE handle
, PINPUT_RECORD buffer
, DWORD count
, LPDWORD pRead
)
806 if (!PeekConsoleInputW( handle
, buffer
, count
, &read
)) return FALSE
;
807 input_records_WtoA( buffer
, read
);
808 if (pRead
) *pRead
= read
;
813 /***********************************************************************
814 * PeekConsoleInputW (KERNEL32.@)
816 BOOL WINAPI
PeekConsoleInputW( HANDLE handle
, PINPUT_RECORD buffer
, DWORD count
, LPDWORD read
)
819 SERVER_START_REQ( read_console_input
)
821 req
->handle
= console_handle_unmap(handle
);
823 wine_server_set_reply( req
, buffer
, count
* sizeof(INPUT_RECORD
) );
824 if ((ret
= !wine_server_call_err( req
)))
826 if (read
) *read
= count
? reply
->read
: 0;
834 /***********************************************************************
835 * GetNumberOfConsoleInputEvents (KERNEL32.@)
837 BOOL WINAPI
GetNumberOfConsoleInputEvents( HANDLE handle
, LPDWORD nrofevents
)
840 SERVER_START_REQ( read_console_input
)
842 req
->handle
= console_handle_unmap(handle
);
844 if ((ret
= !wine_server_call_err( req
)))
846 if (nrofevents
) *nrofevents
= reply
->read
;
854 /******************************************************************************
857 * Helper function for ReadConsole, ReadConsoleInput and FlushConsoleInputBuffer
860 * 0 for error, 1 for no INPUT_RECORD ready, 2 with INPUT_RECORD ready
862 enum read_console_input_return
{rci_error
= 0, rci_timeout
= 1, rci_gotone
= 2};
863 static enum read_console_input_return
read_console_input(HANDLE handle
, PINPUT_RECORD ir
, DWORD timeout
)
865 enum read_console_input_return ret
;
867 if (WaitForSingleObject(GetConsoleInputWaitHandle(), timeout
) != WAIT_OBJECT_0
)
869 SERVER_START_REQ( read_console_input
)
871 req
->handle
= console_handle_unmap(handle
);
873 wine_server_set_reply( req
, ir
, sizeof(INPUT_RECORD
) );
874 if (wine_server_call_err( req
) || !reply
->read
) ret
= rci_error
;
875 else ret
= rci_gotone
;
883 /***********************************************************************
884 * FlushConsoleInputBuffer (KERNEL32.@)
886 BOOL WINAPI
FlushConsoleInputBuffer( HANDLE handle
)
888 enum read_console_input_return last
;
891 while ((last
= read_console_input(handle
, &ir
, 0)) == rci_gotone
);
893 return last
== rci_timeout
;
897 /***********************************************************************
898 * SetConsoleTitleA (KERNEL32.@)
900 BOOL WINAPI
SetConsoleTitleA( LPCSTR title
)
905 DWORD len
= MultiByteToWideChar( GetConsoleOutputCP(), 0, title
, -1, NULL
, 0 );
906 if (!(titleW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
)))) return FALSE
;
907 MultiByteToWideChar( GetConsoleOutputCP(), 0, title
, -1, titleW
, len
);
908 ret
= SetConsoleTitleW(titleW
);
909 HeapFree(GetProcessHeap(), 0, titleW
);
914 /***********************************************************************
915 * GetConsoleTitleA (KERNEL32.@)
917 DWORD WINAPI
GetConsoleTitleA(LPSTR title
, DWORD size
)
919 WCHAR
*ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * size
);
923 ret
= GetConsoleTitleW( ptr
, size
);
926 WideCharToMultiByte( GetConsoleOutputCP(), 0, ptr
, ret
+ 1, title
, size
, NULL
, NULL
);
929 HeapFree(GetProcessHeap(), 0, ptr
);
934 /******************************************************************************
935 * GetConsoleTitleW [KERNEL32.@] Retrieves title string for console
938 * title [O] Address of buffer for title
939 * size [I] Size of buffer
942 * Success: Length of string copied
945 DWORD WINAPI
GetConsoleTitleW(LPWSTR title
, DWORD size
)
949 SERVER_START_REQ( get_console_input_info
)
952 wine_server_set_reply( req
, title
, (size
-1) * sizeof(WCHAR
) );
953 if (!wine_server_call_err( req
))
955 ret
= wine_server_reply_size(reply
) / sizeof(WCHAR
);
964 /***********************************************************************
965 * GetLargestConsoleWindowSize (KERNEL32.@)
968 * This should return a COORD, but calling convention for returning
969 * structures is different between Windows and gcc on i386.
974 #undef GetLargestConsoleWindowSize
975 DWORD WINAPI
GetLargestConsoleWindowSize(HANDLE hConsoleOutput
)
983 TRACE("(%p), returning %dx%d (%lx)\n", hConsoleOutput
, x
.c
.X
, x
.c
.Y
, x
.w
);
986 #endif /* defined(__i386__) */
989 /***********************************************************************
990 * GetLargestConsoleWindowSize (KERNEL32.@)
993 * This should return a COORD, but calling convention for returning
994 * structures is different between Windows and gcc on i386.
999 COORD WINAPI
GetLargestConsoleWindowSize(HANDLE hConsoleOutput
)
1004 TRACE("(%p), returning %dx%d\n", hConsoleOutput
, c
.X
, c
.Y
);
1007 #endif /* defined(__i386__) */
1009 static WCHAR
* S_EditString
/* = NULL */;
1010 static unsigned S_EditStrPos
/* = 0 */;
1012 /***********************************************************************
1013 * FreeConsole (KERNEL32.@)
1015 BOOL WINAPI
FreeConsole(VOID
)
1019 SERVER_START_REQ(free_console
)
1021 ret
= !wine_server_call_err( req
);
1027 /******************************************************************
1028 * start_console_renderer
1030 * helper for AllocConsole
1031 * starts the renderer process
1033 static BOOL
start_console_renderer_helper(const char* appname
, STARTUPINFOA
* si
,
1038 PROCESS_INFORMATION pi
;
1040 /* FIXME: use dynamic allocation for most of the buffers below */
1041 ret
= snprintf(buffer
, sizeof(buffer
), "%s --use-event=%d", appname
, (INT
)hEvent
);
1042 if ((ret
> -1) && (ret
< sizeof(buffer
)) &&
1043 CreateProcessA(NULL
, buffer
, NULL
, NULL
, TRUE
, DETACHED_PROCESS
,
1044 NULL
, NULL
, si
, &pi
))
1046 if (WaitForSingleObject(hEvent
, INFINITE
) != WAIT_OBJECT_0
) return FALSE
;
1048 TRACE("Started wineconsole pid=%08lx tid=%08lx\n",
1049 pi
.dwProcessId
, pi
.dwThreadId
);
1056 static BOOL
start_console_renderer(STARTUPINFOA
* si
)
1060 OBJECT_ATTRIBUTES attr
;
1063 attr
.Length
= sizeof(attr
);
1064 attr
.RootDirectory
= 0;
1065 attr
.Attributes
= OBJ_INHERIT
;
1066 attr
.ObjectName
= NULL
;
1067 attr
.SecurityDescriptor
= NULL
;
1068 attr
.SecurityQualityOfService
= NULL
;
1070 NtCreateEvent(&hEvent
, EVENT_ALL_ACCESS
, &attr
, TRUE
, FALSE
);
1071 if (!hEvent
) return FALSE
;
1073 /* first try environment variable */
1074 if ((p
= getenv("WINECONSOLE")) != NULL
)
1076 ret
= start_console_renderer_helper(p
, si
, hEvent
);
1078 ERR("Couldn't launch Wine console from WINECONSOLE env var (%s)... "
1079 "trying default access\n", p
);
1082 /* then try the regular PATH */
1084 ret
= start_console_renderer_helper("wineconsole", si
, hEvent
);
1086 CloseHandle(hEvent
);
1090 /***********************************************************************
1091 * AllocConsole (KERNEL32.@)
1093 * creates an xterm with a pty to our program
1095 BOOL WINAPI
AllocConsole(void)
1097 HANDLE handle_in
= INVALID_HANDLE_VALUE
;
1098 HANDLE handle_out
= INVALID_HANDLE_VALUE
;
1099 HANDLE handle_err
= INVALID_HANDLE_VALUE
;
1100 STARTUPINFOA siCurrent
;
1101 STARTUPINFOA siConsole
;
1103 SECURITY_ATTRIBUTES sa
;
1107 handle_in
= CreateFileA( "CONIN$", GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,
1108 0, NULL
, OPEN_EXISTING
, 0, 0 );
1110 if (handle_in
!= INVALID_HANDLE_VALUE
)
1112 /* we already have a console opened on this process, don't create a new one */
1113 CloseHandle(handle_in
);
1117 GetStartupInfoA(&siCurrent
);
1119 memset(&siConsole
, 0, sizeof(siConsole
));
1120 siConsole
.cb
= sizeof(siConsole
);
1121 /* setup a view arguments for wineconsole (it'll use them as default values) */
1122 if (siCurrent
.dwFlags
& STARTF_USECOUNTCHARS
)
1124 siConsole
.dwFlags
|= STARTF_USECOUNTCHARS
;
1125 siConsole
.dwXCountChars
= siCurrent
.dwXCountChars
;
1126 siConsole
.dwYCountChars
= siCurrent
.dwYCountChars
;
1128 if (siCurrent
.dwFlags
& STARTF_USEFILLATTRIBUTE
)
1130 siConsole
.dwFlags
|= STARTF_USEFILLATTRIBUTE
;
1131 siConsole
.dwFillAttribute
= siCurrent
.dwFillAttribute
;
1133 /* FIXME (should pass the unicode form) */
1134 if (siCurrent
.lpTitle
)
1135 siConsole
.lpTitle
= siCurrent
.lpTitle
;
1136 else if (GetModuleFileNameA(0, buffer
, sizeof(buffer
)))
1138 buffer
[sizeof(buffer
) - 1] = '\0';
1139 siConsole
.lpTitle
= buffer
;
1142 if (!start_console_renderer(&siConsole
))
1145 if( !(siCurrent
.dwFlags
& STARTF_USESTDHANDLES
) ) {
1146 /* all std I/O handles are inheritable by default */
1147 sa
.nLength
= sizeof(sa
);
1148 sa
.lpSecurityDescriptor
= NULL
;
1149 sa
.bInheritHandle
= TRUE
;
1151 handle_in
= CreateFileA( "CONIN$", GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,
1152 0, &sa
, OPEN_EXISTING
, 0, 0 );
1153 if (handle_in
== INVALID_HANDLE_VALUE
) goto the_end
;
1155 handle_out
= CreateFileA( "CONOUT$", GENERIC_READ
|GENERIC_WRITE
,
1156 0, &sa
, OPEN_EXISTING
, 0, 0 );
1157 if (handle_out
== INVALID_HANDLE_VALUE
) goto the_end
;
1159 if (!DuplicateHandle(GetCurrentProcess(), handle_out
, GetCurrentProcess(),
1160 &handle_err
, 0, TRUE
, DUPLICATE_SAME_ACCESS
))
1163 /* STARTF_USESTDHANDLES flag: use handles from StartupInfo */
1164 handle_in
= siCurrent
.hStdInput
;
1165 handle_out
= siCurrent
.hStdOutput
;
1166 handle_err
= siCurrent
.hStdError
;
1169 /* NT resets the STD_*_HANDLEs on console alloc */
1170 SetStdHandle(STD_INPUT_HANDLE
, handle_in
);
1171 SetStdHandle(STD_OUTPUT_HANDLE
, handle_out
);
1172 SetStdHandle(STD_ERROR_HANDLE
, handle_err
);
1174 SetLastError(ERROR_SUCCESS
);
1179 ERR("Can't allocate console\n");
1180 if (handle_in
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_in
);
1181 if (handle_out
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_out
);
1182 if (handle_err
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_err
);
1188 /***********************************************************************
1189 * ReadConsoleA (KERNEL32.@)
1191 BOOL WINAPI
ReadConsoleA(HANDLE hConsoleInput
, LPVOID lpBuffer
, DWORD nNumberOfCharsToRead
,
1192 LPDWORD lpNumberOfCharsRead
, LPVOID lpReserved
)
1194 LPWSTR ptr
= HeapAlloc(GetProcessHeap(), 0, nNumberOfCharsToRead
* sizeof(WCHAR
));
1198 if ((ret
= ReadConsoleW(hConsoleInput
, ptr
, nNumberOfCharsToRead
, &ncr
, NULL
)))
1199 ncr
= WideCharToMultiByte(CP_ACP
, 0, ptr
, ncr
, lpBuffer
, nNumberOfCharsToRead
, NULL
, NULL
);
1201 if (lpNumberOfCharsRead
) *lpNumberOfCharsRead
= ncr
;
1202 HeapFree(GetProcessHeap(), 0, ptr
);
1207 /***********************************************************************
1208 * ReadConsoleW (KERNEL32.@)
1210 BOOL WINAPI
ReadConsoleW(HANDLE hConsoleInput
, LPVOID lpBuffer
,
1211 DWORD nNumberOfCharsToRead
, LPDWORD lpNumberOfCharsRead
, LPVOID lpReserved
)
1214 LPWSTR xbuf
= (LPWSTR
)lpBuffer
;
1217 TRACE("(%p,%p,%ld,%p,%p)\n",
1218 hConsoleInput
, lpBuffer
, nNumberOfCharsToRead
, lpNumberOfCharsRead
, lpReserved
);
1220 if (!GetConsoleMode(hConsoleInput
, &mode
))
1223 if (mode
& ENABLE_LINE_INPUT
)
1225 if (!S_EditString
|| S_EditString
[S_EditStrPos
] == 0)
1227 HeapFree(GetProcessHeap(), 0, S_EditString
);
1228 if (!(S_EditString
= CONSOLE_Readline(hConsoleInput
)))
1232 charsread
= lstrlenW(&S_EditString
[S_EditStrPos
]);
1233 if (charsread
> nNumberOfCharsToRead
) charsread
= nNumberOfCharsToRead
;
1234 memcpy(xbuf
, &S_EditString
[S_EditStrPos
], charsread
* sizeof(WCHAR
));
1235 S_EditStrPos
+= charsread
;
1240 DWORD timeout
= INFINITE
;
1242 /* FIXME: should we read at least 1 char? The SDK does not say */
1243 /* wait for at least one available input record (it doesn't mean we'll have
1244 * chars stored in xbuf...)
1249 if (read_console_input(hConsoleInput
, &ir
, timeout
) != rci_gotone
) break;
1251 if (ir
.EventType
== KEY_EVENT
&& ir
.Event
.KeyEvent
.bKeyDown
&&
1252 ir
.Event
.KeyEvent
.uChar
.UnicodeChar
&&
1253 !(ir
.Event
.KeyEvent
.dwControlKeyState
& ENHANCED_KEY
))
1255 xbuf
[charsread
++] = ir
.Event
.KeyEvent
.uChar
.UnicodeChar
;
1257 } while (charsread
< nNumberOfCharsToRead
);
1258 /* nothing has been read */
1259 if (timeout
== INFINITE
) return FALSE
;
1262 if (lpNumberOfCharsRead
) *lpNumberOfCharsRead
= charsread
;
1268 /***********************************************************************
1269 * ReadConsoleInputW (KERNEL32.@)
1271 BOOL WINAPI
ReadConsoleInputW(HANDLE hConsoleInput
, PINPUT_RECORD lpBuffer
,
1272 DWORD nLength
, LPDWORD lpNumberOfEventsRead
)
1275 DWORD timeout
= INFINITE
;
1279 if (lpNumberOfEventsRead
) *lpNumberOfEventsRead
= 0;
1283 /* loop until we get at least one event */
1284 while (read_console_input(hConsoleInput
, &lpBuffer
[idx
], timeout
) == rci_gotone
&&
1288 if (lpNumberOfEventsRead
) *lpNumberOfEventsRead
= idx
;
1293 /******************************************************************************
1294 * WriteConsoleOutputCharacterW [KERNEL32.@] Copies character to consecutive
1295 * cells in the console screen buffer
1298 * hConsoleOutput [I] Handle to screen buffer
1299 * str [I] Pointer to buffer with chars to write
1300 * length [I] Number of cells to write to
1301 * coord [I] Coords of first cell
1302 * lpNumCharsWritten [O] Pointer to number of cells written
1309 BOOL WINAPI
WriteConsoleOutputCharacterW( HANDLE hConsoleOutput
, LPCWSTR str
, DWORD length
,
1310 COORD coord
, LPDWORD lpNumCharsWritten
)
1314 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput
,
1315 debugstr_wn(str
, length
), length
, coord
.X
, coord
.Y
, lpNumCharsWritten
);
1317 SERVER_START_REQ( write_console_output
)
1319 req
->handle
= console_handle_unmap(hConsoleOutput
);
1322 req
->mode
= CHAR_INFO_MODE_TEXT
;
1324 wine_server_add_data( req
, str
, length
* sizeof(WCHAR
) );
1325 if ((ret
= !wine_server_call_err( req
)))
1327 if (lpNumCharsWritten
) *lpNumCharsWritten
= reply
->written
;
1335 /******************************************************************************
1336 * SetConsoleTitleW [KERNEL32.@] Sets title bar string for console
1339 * title [I] Address of new title
1345 BOOL WINAPI
SetConsoleTitleW(LPCWSTR title
)
1349 TRACE("(%s)\n", debugstr_w(title
));
1350 SERVER_START_REQ( set_console_input_info
)
1353 req
->mask
= SET_CONSOLE_INPUT_INFO_TITLE
;
1354 wine_server_add_data( req
, title
, strlenW(title
) * sizeof(WCHAR
) );
1355 ret
= !wine_server_call_err( req
);
1362 /***********************************************************************
1363 * GetNumberOfConsoleMouseButtons (KERNEL32.@)
1365 BOOL WINAPI
GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons
)
1367 FIXME("(%p): stub\n", nrofbuttons
);
1372 /******************************************************************************
1373 * SetConsoleInputExeNameW [KERNEL32.@]
1378 BOOL WINAPI
SetConsoleInputExeNameW(LPCWSTR name
)
1380 FIXME("(%s): stub!\n", debugstr_w(name
));
1382 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1386 /******************************************************************************
1387 * SetConsoleInputExeNameA [KERNEL32.@]
1392 BOOL WINAPI
SetConsoleInputExeNameA(LPCSTR name
)
1394 int len
= MultiByteToWideChar(CP_ACP
, 0, name
, -1, NULL
, 0);
1395 LPWSTR xptr
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1398 if (!xptr
) return FALSE
;
1400 MultiByteToWideChar(CP_ACP
, 0, name
, -1, xptr
, len
);
1401 ret
= SetConsoleInputExeNameW(xptr
);
1402 HeapFree(GetProcessHeap(), 0, xptr
);
1407 /******************************************************************
1408 * CONSOLE_DefaultHandler
1410 * Final control event handler
1412 static BOOL WINAPI
CONSOLE_DefaultHandler(DWORD dwCtrlType
)
1414 FIXME("Terminating process %lx on event %lx\n", GetCurrentProcessId(), dwCtrlType
);
1416 /* should never go here */
1420 /******************************************************************************
1421 * SetConsoleCtrlHandler [KERNEL32.@] Adds function to calling process list
1424 * func [I] Address of handler function
1425 * add [I] Handler to add or remove
1432 struct ConsoleHandler
1434 PHANDLER_ROUTINE handler
;
1435 struct ConsoleHandler
* next
;
1438 static struct ConsoleHandler CONSOLE_DefaultConsoleHandler
= {CONSOLE_DefaultHandler
, NULL
};
1439 static struct ConsoleHandler
* CONSOLE_Handlers
= &CONSOLE_DefaultConsoleHandler
;
1441 static CRITICAL_SECTION CONSOLE_CritSect
;
1442 static CRITICAL_SECTION_DEBUG critsect_debug
=
1444 0, 0, &CONSOLE_CritSect
,
1445 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
1446 0, 0, { 0, (DWORD
)(__FILE__
": CONSOLE_CritSect") }
1448 static CRITICAL_SECTION CONSOLE_CritSect
= { &critsect_debug
, -1, 0, 0, 0, 0 };
1450 /*****************************************************************************/
1452 /******************************************************************
1453 * SetConsoleCtrlHandler (KERNEL32.@)
1455 BOOL WINAPI
SetConsoleCtrlHandler(PHANDLER_ROUTINE func
, BOOL add
)
1459 TRACE("(%p,%i)\n", func
, add
);
1463 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1465 NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
|= 1;
1467 NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
&= ~1;
1468 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1472 struct ConsoleHandler
* ch
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct ConsoleHandler
));
1474 if (!ch
) return FALSE
;
1476 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1477 ch
->next
= CONSOLE_Handlers
;
1478 CONSOLE_Handlers
= ch
;
1479 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1483 struct ConsoleHandler
** ch
;
1484 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1485 for (ch
= &CONSOLE_Handlers
; *ch
; ch
= &(*ch
)->next
)
1487 if ((*ch
)->handler
== func
) break;
1491 struct ConsoleHandler
* rch
= *ch
;
1494 if (rch
== &CONSOLE_DefaultConsoleHandler
)
1496 ERR("Who's trying to remove default handler???\n");
1497 SetLastError(ERROR_INVALID_PARAMETER
);
1503 HeapFree(GetProcessHeap(), 0, rch
);
1508 WARN("Attempt to remove non-installed CtrlHandler %p\n", func
);
1509 SetLastError(ERROR_INVALID_PARAMETER
);
1512 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1517 static WINE_EXCEPTION_FILTER(CONSOLE_CtrlEventHandler
)
1519 TRACE("(%lx)\n", GetExceptionCode());
1520 return EXCEPTION_EXECUTE_HANDLER
;
1523 /******************************************************************
1524 * CONSOLE_SendEventThread
1526 * Internal helper to pass an event to the list on installed handlers
1528 static DWORD WINAPI
CONSOLE_SendEventThread(void* pmt
)
1530 DWORD event
= (DWORD
)pmt
;
1531 struct ConsoleHandler
* ch
;
1533 if (event
== CTRL_C_EVENT
)
1535 BOOL caught_by_dbg
= TRUE
;
1536 /* First, try to pass the ctrl-C event to the debugger (if any)
1537 * If it continues, there's nothing more to do
1538 * Otherwise, we need to send the ctrl-C event to the handlers
1542 RaiseException( DBG_CONTROL_C
, 0, 0, NULL
);
1544 __EXCEPT(CONSOLE_CtrlEventHandler
)
1546 caught_by_dbg
= FALSE
;
1549 if (caught_by_dbg
) return 0;
1550 /* the debugger didn't continue... so, pass to ctrl handlers */
1552 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1553 for (ch
= CONSOLE_Handlers
; ch
; ch
= ch
->next
)
1555 if (ch
->handler(event
)) break;
1557 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1561 /******************************************************************
1562 * CONSOLE_HandleCtrlC
1564 * Check whether the shall manipulate CtrlC events
1566 int CONSOLE_HandleCtrlC(unsigned sig
)
1568 /* FIXME: better test whether a console is attached to this process ??? */
1569 extern unsigned CONSOLE_GetNumHistoryEntries(void);
1570 if (CONSOLE_GetNumHistoryEntries() == (unsigned)-1) return 0;
1572 /* check if we have to ignore ctrl-C events */
1573 if (!(NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
& 1))
1575 /* Create a separate thread to signal all the events.
1576 * This is needed because:
1577 * - this function can be called in an Unix signal handler (hence on an
1578 * different stack than the thread that's running). This breaks the
1579 * Win32 exception mechanisms (where the thread's stack is checked).
1580 * - since the current thread, while processing the signal, can hold the
1581 * console critical section, we need another execution environment where
1582 * we can wait on this critical section
1584 CreateThread(NULL
, 0, CONSOLE_SendEventThread
, (void*)CTRL_C_EVENT
, 0, NULL
);
1589 /******************************************************************************
1590 * GenerateConsoleCtrlEvent [KERNEL32.@] Simulate a CTRL-C or CTRL-BREAK
1593 * dwCtrlEvent [I] Type of event
1594 * dwProcessGroupID [I] Process group ID to send event to
1598 * Failure: False (and *should* [but doesn't] set LastError)
1600 BOOL WINAPI
GenerateConsoleCtrlEvent(DWORD dwCtrlEvent
,
1601 DWORD dwProcessGroupID
)
1605 TRACE("(%ld, %ld)\n", dwCtrlEvent
, dwProcessGroupID
);
1607 if (dwCtrlEvent
!= CTRL_C_EVENT
&& dwCtrlEvent
!= CTRL_BREAK_EVENT
)
1609 ERR("Invalid event %ld for PGID %ld\n", dwCtrlEvent
, dwProcessGroupID
);
1613 SERVER_START_REQ( send_console_signal
)
1615 req
->signal
= dwCtrlEvent
;
1616 req
->group_id
= dwProcessGroupID
;
1617 ret
= !wine_server_call_err( req
);
1621 /* FIXME: shall this function be synchronous, ie only return when all events
1622 * have been handled by all processes in the given group ?
1623 * As of today, we don't wait...
1629 /******************************************************************************
1630 * CreateConsoleScreenBuffer [KERNEL32.@] Creates a console screen buffer
1633 * dwDesiredAccess [I] Access flag
1634 * dwShareMode [I] Buffer share mode
1635 * sa [I] Security attributes
1636 * dwFlags [I] Type of buffer to create
1637 * lpScreenBufferData [I] Reserved
1640 * Should call SetLastError
1643 * Success: Handle to new console screen buffer
1644 * Failure: INVALID_HANDLE_VALUE
1646 HANDLE WINAPI
CreateConsoleScreenBuffer(DWORD dwDesiredAccess
, DWORD dwShareMode
,
1647 LPSECURITY_ATTRIBUTES sa
, DWORD dwFlags
,
1648 LPVOID lpScreenBufferData
)
1650 HANDLE ret
= INVALID_HANDLE_VALUE
;
1652 TRACE("(%ld,%ld,%p,%ld,%p)\n",
1653 dwDesiredAccess
, dwShareMode
, sa
, dwFlags
, lpScreenBufferData
);
1655 if (dwFlags
!= CONSOLE_TEXTMODE_BUFFER
|| lpScreenBufferData
!= NULL
)
1657 SetLastError(ERROR_INVALID_PARAMETER
);
1658 return INVALID_HANDLE_VALUE
;
1661 SERVER_START_REQ(create_console_output
)
1664 req
->access
= dwDesiredAccess
;
1665 req
->share
= dwShareMode
;
1666 req
->inherit
= (sa
&& sa
->bInheritHandle
);
1667 if (!wine_server_call_err( req
)) ret
= reply
->handle_out
;
1675 /***********************************************************************
1676 * GetConsoleScreenBufferInfo (KERNEL32.@)
1678 BOOL WINAPI
GetConsoleScreenBufferInfo(HANDLE hConsoleOutput
, LPCONSOLE_SCREEN_BUFFER_INFO csbi
)
1682 SERVER_START_REQ(get_console_output_info
)
1684 req
->handle
= console_handle_unmap(hConsoleOutput
);
1685 if ((ret
= !wine_server_call_err( req
)))
1687 csbi
->dwSize
.X
= reply
->width
;
1688 csbi
->dwSize
.Y
= reply
->height
;
1689 csbi
->dwCursorPosition
.X
= reply
->cursor_x
;
1690 csbi
->dwCursorPosition
.Y
= reply
->cursor_y
;
1691 csbi
->wAttributes
= reply
->attr
;
1692 csbi
->srWindow
.Left
= reply
->win_left
;
1693 csbi
->srWindow
.Right
= reply
->win_right
;
1694 csbi
->srWindow
.Top
= reply
->win_top
;
1695 csbi
->srWindow
.Bottom
= reply
->win_bottom
;
1696 csbi
->dwMaximumWindowSize
.X
= reply
->max_width
;
1697 csbi
->dwMaximumWindowSize
.Y
= reply
->max_height
;
1702 TRACE("(%p,(%d,%d) (%d,%d) %d (%d,%d-%d,%d) (%d,%d)\n",
1703 hConsoleOutput
, csbi
->dwSize
.X
, csbi
->dwSize
.Y
,
1704 csbi
->dwCursorPosition
.X
, csbi
->dwCursorPosition
.Y
,
1706 csbi
->srWindow
.Left
, csbi
->srWindow
.Top
, csbi
->srWindow
.Right
, csbi
->srWindow
.Bottom
,
1707 csbi
->dwMaximumWindowSize
.X
, csbi
->dwMaximumWindowSize
.Y
);
1713 /******************************************************************************
1714 * SetConsoleActiveScreenBuffer [KERNEL32.@] Sets buffer to current console
1720 BOOL WINAPI
SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput
)
1724 TRACE("(%p)\n", hConsoleOutput
);
1726 SERVER_START_REQ( set_console_input_info
)
1729 req
->mask
= SET_CONSOLE_INPUT_INFO_ACTIVE_SB
;
1730 req
->active_sb
= hConsoleOutput
;
1731 ret
= !wine_server_call_err( req
);
1738 /***********************************************************************
1739 * GetConsoleMode (KERNEL32.@)
1741 BOOL WINAPI
GetConsoleMode(HANDLE hcon
, LPDWORD mode
)
1745 SERVER_START_REQ(get_console_mode
)
1747 req
->handle
= console_handle_unmap(hcon
);
1748 ret
= !wine_server_call_err( req
);
1749 if (ret
&& mode
) *mode
= reply
->mode
;
1756 /******************************************************************************
1757 * SetConsoleMode [KERNEL32.@] Sets input mode of console's input buffer
1760 * hcon [I] Handle to console input or screen buffer
1761 * mode [I] Input or output mode to set
1768 * ENABLE_PROCESSED_INPUT 0x01
1769 * ENABLE_LINE_INPUT 0x02
1770 * ENABLE_ECHO_INPUT 0x04
1771 * ENABLE_WINDOW_INPUT 0x08
1772 * ENABLE_MOUSE_INPUT 0x10
1774 BOOL WINAPI
SetConsoleMode(HANDLE hcon
, DWORD mode
)
1778 SERVER_START_REQ(set_console_mode
)
1780 req
->handle
= console_handle_unmap(hcon
);
1782 ret
= !wine_server_call_err( req
);
1785 /* FIXME: when resetting a console input to editline mode, I think we should
1786 * empty the S_EditString buffer
1789 TRACE("(%p,%lx) retval == %d\n", hcon
, mode
, ret
);
1795 /******************************************************************
1796 * CONSOLE_WriteChars
1798 * WriteConsoleOutput helper: hides server call semantics
1799 * writes a string at a given pos with standard attribute
1801 int CONSOLE_WriteChars(HANDLE hCon
, LPCWSTR lpBuffer
, int nc
, COORD
* pos
)
1807 SERVER_START_REQ( write_console_output
)
1809 req
->handle
= console_handle_unmap(hCon
);
1812 req
->mode
= CHAR_INFO_MODE_TEXTSTDATTR
;
1814 wine_server_add_data( req
, lpBuffer
, nc
* sizeof(WCHAR
) );
1815 if (!wine_server_call_err( req
)) written
= reply
->written
;
1819 if (written
> 0) pos
->X
+= written
;
1823 /******************************************************************
1826 * WriteConsoleOutput helper: handles passing to next line (+scrolling if necessary)
1829 static int next_line(HANDLE hCon
, CONSOLE_SCREEN_BUFFER_INFO
* csbi
)
1835 csbi
->dwCursorPosition
.X
= 0;
1836 csbi
->dwCursorPosition
.Y
++;
1838 if (csbi
->dwCursorPosition
.Y
< csbi
->dwSize
.Y
) return 1;
1841 src
.Bottom
= csbi
->dwSize
.Y
- 1;
1843 src
.Right
= csbi
->dwSize
.X
- 1;
1848 ci
.Attributes
= csbi
->wAttributes
;
1849 ci
.Char
.UnicodeChar
= ' ';
1851 csbi
->dwCursorPosition
.Y
--;
1852 if (!ScrollConsoleScreenBufferW(hCon
, &src
, NULL
, dst
, &ci
))
1857 /******************************************************************
1860 * WriteConsoleOutput helper: writes a block of non special characters
1861 * Block can spread on several lines, and wrapping, if needed, is
1865 static int write_block(HANDLE hCon
, CONSOLE_SCREEN_BUFFER_INFO
* csbi
,
1866 DWORD mode
, LPCWSTR ptr
, int len
)
1868 int blk
; /* number of chars to write on current line */
1869 int done
; /* number of chars already written */
1871 if (len
<= 0) return 1;
1873 if (mode
& ENABLE_WRAP_AT_EOL_OUTPUT
) /* writes remaining on next line */
1875 for (done
= 0; done
< len
; done
+= blk
)
1877 blk
= min(len
- done
, csbi
->dwSize
.X
- csbi
->dwCursorPosition
.X
);
1879 if (CONSOLE_WriteChars(hCon
, ptr
+ done
, blk
, &csbi
->dwCursorPosition
) != blk
)
1881 if (csbi
->dwCursorPosition
.X
== csbi
->dwSize
.X
&& !next_line(hCon
, csbi
))
1887 int pos
= csbi
->dwCursorPosition
.X
;
1888 /* FIXME: we could reduce the number of loops
1889 * but, in most cases we wouldn't gain lots of time (it would only
1890 * happen if we're asked to overwrite more than twice the part of the line,
1893 for (blk
= done
= 0; done
< len
; done
+= blk
)
1895 blk
= min(len
- done
, csbi
->dwSize
.X
- csbi
->dwCursorPosition
.X
);
1897 csbi
->dwCursorPosition
.X
= pos
;
1898 if (CONSOLE_WriteChars(hCon
, ptr
+ done
, blk
, &csbi
->dwCursorPosition
) != blk
)
1906 /***********************************************************************
1907 * WriteConsoleW (KERNEL32.@)
1909 BOOL WINAPI
WriteConsoleW(HANDLE hConsoleOutput
, LPCVOID lpBuffer
, DWORD nNumberOfCharsToWrite
,
1910 LPDWORD lpNumberOfCharsWritten
, LPVOID lpReserved
)
1914 const WCHAR
* psz
= lpBuffer
;
1915 CONSOLE_SCREEN_BUFFER_INFO csbi
;
1918 TRACE("%p %s %ld %p %p\n",
1919 hConsoleOutput
, debugstr_wn(lpBuffer
, nNumberOfCharsToWrite
),
1920 nNumberOfCharsToWrite
, lpNumberOfCharsWritten
, lpReserved
);
1922 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= 0;
1924 if (!GetConsoleMode(hConsoleOutput
, &mode
) ||
1925 !GetConsoleScreenBufferInfo(hConsoleOutput
, &csbi
))
1928 if (mode
& ENABLE_PROCESSED_OUTPUT
)
1932 for (i
= 0; i
< nNumberOfCharsToWrite
; i
++)
1936 case '\b': case '\t': case '\n': case '\a': case '\r':
1937 /* don't handle here the i-th char... done below */
1938 if ((k
= i
- first
) > 0)
1940 if (!write_block(hConsoleOutput
, &csbi
, mode
, &psz
[first
], k
))
1950 if (csbi
.dwCursorPosition
.X
> 0) csbi
.dwCursorPosition
.X
--;
1954 WCHAR tmp
[8] = {' ',' ',' ',' ',' ',' ',' ',' '};
1956 if (!write_block(hConsoleOutput
, &csbi
, mode
, tmp
,
1957 ((csbi
.dwCursorPosition
.X
+ 8) & ~7) - csbi
.dwCursorPosition
.X
))
1962 next_line(hConsoleOutput
, &csbi
);
1968 csbi
.dwCursorPosition
.X
= 0;
1976 /* write the remaining block (if any) if processed output is enabled, or the
1977 * entire buffer otherwise
1979 if ((k
= nNumberOfCharsToWrite
- first
) > 0)
1981 if (!write_block(hConsoleOutput
, &csbi
, mode
, &psz
[first
], k
))
1987 SetConsoleCursorPosition(hConsoleOutput
, csbi
.dwCursorPosition
);
1988 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= nw
;
1993 /***********************************************************************
1994 * WriteConsoleA (KERNEL32.@)
1996 BOOL WINAPI
WriteConsoleA(HANDLE hConsoleOutput
, LPCVOID lpBuffer
, DWORD nNumberOfCharsToWrite
,
1997 LPDWORD lpNumberOfCharsWritten
, LPVOID lpReserved
)
2003 n
= MultiByteToWideChar(CP_ACP
, 0, lpBuffer
, nNumberOfCharsToWrite
, NULL
, 0);
2005 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= 0;
2006 xstring
= HeapAlloc(GetProcessHeap(), 0, n
* sizeof(WCHAR
));
2007 if (!xstring
) return 0;
2009 MultiByteToWideChar(CP_ACP
, 0, lpBuffer
, nNumberOfCharsToWrite
, xstring
, n
);
2011 ret
= WriteConsoleW(hConsoleOutput
, xstring
, n
, lpNumberOfCharsWritten
, 0);
2013 HeapFree(GetProcessHeap(), 0, xstring
);
2018 /******************************************************************************
2019 * SetConsoleCursorPosition [KERNEL32.@]
2020 * Sets the cursor position in console
2023 * hConsoleOutput [I] Handle of console screen buffer
2024 * dwCursorPosition [I] New cursor position coordinates
2028 BOOL WINAPI
SetConsoleCursorPosition(HANDLE hcon
, COORD pos
)
2031 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2035 TRACE("%p %d %d\n", hcon
, pos
.X
, pos
.Y
);
2037 SERVER_START_REQ(set_console_output_info
)
2039 req
->handle
= console_handle_unmap(hcon
);
2040 req
->cursor_x
= pos
.X
;
2041 req
->cursor_y
= pos
.Y
;
2042 req
->mask
= SET_CONSOLE_OUTPUT_INFO_CURSOR_POS
;
2043 ret
= !wine_server_call_err( req
);
2047 if (!ret
|| !GetConsoleScreenBufferInfo(hcon
, &csbi
))
2050 /* if cursor is no longer visible, scroll the visible window... */
2051 w
= csbi
.srWindow
.Right
- csbi
.srWindow
.Left
+ 1;
2052 h
= csbi
.srWindow
.Bottom
- csbi
.srWindow
.Top
+ 1;
2053 if (pos
.X
< csbi
.srWindow
.Left
)
2055 csbi
.srWindow
.Left
= min(pos
.X
, csbi
.dwSize
.X
- w
);
2058 else if (pos
.X
> csbi
.srWindow
.Right
)
2060 csbi
.srWindow
.Left
= max(pos
.X
, w
) - w
+ 1;
2063 csbi
.srWindow
.Right
= csbi
.srWindow
.Left
+ w
- 1;
2065 if (pos
.Y
< csbi
.srWindow
.Top
)
2067 csbi
.srWindow
.Top
= min(pos
.Y
, csbi
.dwSize
.Y
- h
);
2070 else if (pos
.Y
> csbi
.srWindow
.Bottom
)
2072 csbi
.srWindow
.Top
= max(pos
.Y
, h
) - h
+ 1;
2075 csbi
.srWindow
.Bottom
= csbi
.srWindow
.Top
+ h
- 1;
2077 ret
= (do_move
) ? SetConsoleWindowInfo(hcon
, TRUE
, &csbi
.srWindow
) : TRUE
;
2082 /******************************************************************************
2083 * GetConsoleCursorInfo [KERNEL32.@] Gets size and visibility of console
2086 * hcon [I] Handle to console screen buffer
2087 * cinfo [O] Address of cursor information
2093 BOOL WINAPI
GetConsoleCursorInfo(HANDLE hCon
, LPCONSOLE_CURSOR_INFO cinfo
)
2097 SERVER_START_REQ(get_console_output_info
)
2099 req
->handle
= console_handle_unmap(hCon
);
2100 ret
= !wine_server_call_err( req
);
2103 cinfo
->dwSize
= reply
->cursor_size
;
2104 cinfo
->bVisible
= reply
->cursor_visible
;
2109 TRACE("(%p) returning (%ld,%d)\n", hCon
, cinfo
->dwSize
, cinfo
->bVisible
);
2114 /******************************************************************************
2115 * SetConsoleCursorInfo [KERNEL32.@] Sets size and visibility of cursor
2118 * hcon [I] Handle to console screen buffer
2119 * cinfo [I] Address of cursor information
2124 BOOL WINAPI
SetConsoleCursorInfo(HANDLE hCon
, LPCONSOLE_CURSOR_INFO cinfo
)
2128 TRACE("(%p,%ld,%d)\n", hCon
, cinfo
->dwSize
, cinfo
->bVisible
);
2129 SERVER_START_REQ(set_console_output_info
)
2131 req
->handle
= console_handle_unmap(hCon
);
2132 req
->cursor_size
= cinfo
->dwSize
;
2133 req
->cursor_visible
= cinfo
->bVisible
;
2134 req
->mask
= SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM
;
2135 ret
= !wine_server_call_err( req
);
2142 /******************************************************************************
2143 * SetConsoleWindowInfo [KERNEL32.@] Sets size and position of console
2146 * hcon [I] Handle to console screen buffer
2147 * bAbsolute [I] Coordinate type flag
2148 * window [I] Address of new window rectangle
2153 BOOL WINAPI
SetConsoleWindowInfo(HANDLE hCon
, BOOL bAbsolute
, LPSMALL_RECT window
)
2155 SMALL_RECT p
= *window
;
2158 TRACE("(%p,%d,(%d,%d-%d,%d))\n", hCon
, bAbsolute
, p
.Left
, p
.Top
, p
.Right
, p
.Bottom
);
2162 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2164 if (!GetConsoleScreenBufferInfo(hCon
, &csbi
))
2166 p
.Left
+= csbi
.srWindow
.Left
;
2167 p
.Top
+= csbi
.srWindow
.Top
;
2168 p
.Right
+= csbi
.srWindow
.Right
;
2169 p
.Bottom
+= csbi
.srWindow
.Bottom
;
2171 SERVER_START_REQ(set_console_output_info
)
2173 req
->handle
= console_handle_unmap(hCon
);
2174 req
->win_left
= p
.Left
;
2175 req
->win_top
= p
.Top
;
2176 req
->win_right
= p
.Right
;
2177 req
->win_bottom
= p
.Bottom
;
2178 req
->mask
= SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW
;
2179 ret
= !wine_server_call_err( req
);
2187 /******************************************************************************
2188 * SetConsoleTextAttribute [KERNEL32.@] Sets colors for text
2190 * Sets the foreground and background color attributes of characters
2191 * written to the screen buffer.
2197 BOOL WINAPI
SetConsoleTextAttribute(HANDLE hConsoleOutput
, WORD wAttr
)
2201 TRACE("(%p,%d)\n", hConsoleOutput
, wAttr
);
2202 SERVER_START_REQ(set_console_output_info
)
2204 req
->handle
= console_handle_unmap(hConsoleOutput
);
2206 req
->mask
= SET_CONSOLE_OUTPUT_INFO_ATTR
;
2207 ret
= !wine_server_call_err( req
);
2214 /******************************************************************************
2215 * SetConsoleScreenBufferSize [KERNEL32.@] Changes size of console
2218 * hConsoleOutput [I] Handle to console screen buffer
2219 * dwSize [I] New size in character rows and cols
2225 BOOL WINAPI
SetConsoleScreenBufferSize(HANDLE hConsoleOutput
, COORD dwSize
)
2229 TRACE("(%p,(%d,%d))\n", hConsoleOutput
, dwSize
.X
, dwSize
.Y
);
2230 SERVER_START_REQ(set_console_output_info
)
2232 req
->handle
= console_handle_unmap(hConsoleOutput
);
2233 req
->width
= dwSize
.X
;
2234 req
->height
= dwSize
.Y
;
2235 req
->mask
= SET_CONSOLE_OUTPUT_INFO_SIZE
;
2236 ret
= !wine_server_call_err( req
);
2243 /******************************************************************************
2244 * ScrollConsoleScreenBufferA [KERNEL32.@]
2247 BOOL WINAPI
ScrollConsoleScreenBufferA(HANDLE hConsoleOutput
, LPSMALL_RECT lpScrollRect
,
2248 LPSMALL_RECT lpClipRect
, COORD dwDestOrigin
,
2253 ciw
.Attributes
= lpFill
->Attributes
;
2254 MultiByteToWideChar(CP_ACP
, 0, &lpFill
->Char
.AsciiChar
, 1, &ciw
.Char
.UnicodeChar
, 1);
2256 return ScrollConsoleScreenBufferW(hConsoleOutput
, lpScrollRect
, lpClipRect
,
2257 dwDestOrigin
, &ciw
);
2260 /******************************************************************
2261 * CONSOLE_FillLineUniform
2263 * Helper function for ScrollConsoleScreenBufferW
2264 * Fills a part of a line with a constant character info
2266 void CONSOLE_FillLineUniform(HANDLE hConsoleOutput
, int i
, int j
, int len
, LPCHAR_INFO lpFill
)
2268 SERVER_START_REQ( fill_console_output
)
2270 req
->handle
= console_handle_unmap(hConsoleOutput
);
2271 req
->mode
= CHAR_INFO_MODE_TEXTATTR
;
2276 req
->data
.ch
= lpFill
->Char
.UnicodeChar
;
2277 req
->data
.attr
= lpFill
->Attributes
;
2278 wine_server_call_err( req
);
2283 /******************************************************************************
2284 * ScrollConsoleScreenBufferW [KERNEL32.@]
2288 BOOL WINAPI
ScrollConsoleScreenBufferW(HANDLE hConsoleOutput
, LPSMALL_RECT lpScrollRect
,
2289 LPSMALL_RECT lpClipRect
, COORD dwDestOrigin
,
2297 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2302 TRACE("(%p,(%d,%d-%d,%d),(%d,%d-%d,%d),%d-%d,%p)\n", hConsoleOutput
,
2303 lpScrollRect
->Left
, lpScrollRect
->Top
,
2304 lpScrollRect
->Right
, lpScrollRect
->Bottom
,
2305 lpClipRect
->Left
, lpClipRect
->Top
,
2306 lpClipRect
->Right
, lpClipRect
->Bottom
,
2307 dwDestOrigin
.X
, dwDestOrigin
.Y
, lpFill
);
2309 TRACE("(%p,(%d,%d-%d,%d),(nil),%d-%d,%p)\n", hConsoleOutput
,
2310 lpScrollRect
->Left
, lpScrollRect
->Top
,
2311 lpScrollRect
->Right
, lpScrollRect
->Bottom
,
2312 dwDestOrigin
.X
, dwDestOrigin
.Y
, lpFill
);
2314 if (!GetConsoleScreenBufferInfo(hConsoleOutput
, &csbi
))
2317 src
.X
= lpScrollRect
->Left
;
2318 src
.Y
= lpScrollRect
->Top
;
2320 /* step 1: get dst rect */
2321 dst
.Left
= dwDestOrigin
.X
;
2322 dst
.Top
= dwDestOrigin
.Y
;
2323 dst
.Right
= dst
.Left
+ (lpScrollRect
->Right
- lpScrollRect
->Left
);
2324 dst
.Bottom
= dst
.Top
+ (lpScrollRect
->Bottom
- lpScrollRect
->Top
);
2326 /* step 2a: compute the final clip rect (optional passed clip and screen buffer limits */
2329 clip
.Left
= max(0, lpClipRect
->Left
);
2330 clip
.Right
= min(csbi
.dwSize
.X
- 1, lpClipRect
->Right
);
2331 clip
.Top
= max(0, lpClipRect
->Top
);
2332 clip
.Bottom
= min(csbi
.dwSize
.Y
- 1, lpClipRect
->Bottom
);
2337 clip
.Right
= csbi
.dwSize
.X
- 1;
2339 clip
.Bottom
= csbi
.dwSize
.Y
- 1;
2341 if (clip
.Left
> clip
.Right
|| clip
.Top
> clip
.Bottom
) return FALSE
;
2343 /* step 2b: clip dst rect */
2344 if (dst
.Left
< clip
.Left
) {src
.X
+= clip
.Left
- dst
.Left
; dst
.Left
= clip
.Left
;}
2345 if (dst
.Top
< clip
.Top
) {src
.Y
+= clip
.Top
- dst
.Top
; dst
.Top
= clip
.Top
;}
2346 if (dst
.Right
> clip
.Right
) dst
.Right
= clip
.Right
;
2347 if (dst
.Bottom
> clip
.Bottom
) dst
.Bottom
= clip
.Bottom
;
2349 /* step 3: transfer the bits */
2350 SERVER_START_REQ(move_console_output
)
2352 req
->handle
= console_handle_unmap(hConsoleOutput
);
2355 req
->x_dst
= dst
.Left
;
2356 req
->y_dst
= dst
.Top
;
2357 req
->w
= dst
.Right
- dst
.Left
+ 1;
2358 req
->h
= dst
.Bottom
- dst
.Top
+ 1;
2359 ret
= !wine_server_call_err( req
);
2363 if (!ret
) return FALSE
;
2365 /* step 4: clean out the exposed part */
2367 /* have to write cell [i,j] if it is not in dst rect (because it has already
2368 * been written to by the scroll) and is in clip (we shall not write
2371 for (j
= max(lpScrollRect
->Top
, clip
.Top
); j
<= min(lpScrollRect
->Bottom
, clip
.Bottom
); j
++)
2373 inside
= dst
.Top
<= j
&& j
<= dst
.Bottom
;
2375 for (i
= max(lpScrollRect
->Left
, clip
.Left
); i
<= min(lpScrollRect
->Right
, clip
.Right
); i
++)
2377 if (inside
&& dst
.Left
<= i
&& i
<= dst
.Right
)
2381 CONSOLE_FillLineUniform(hConsoleOutput
, start
, j
, i
- start
, lpFill
);
2387 if (start
== -1) start
= i
;
2391 CONSOLE_FillLineUniform(hConsoleOutput
, start
, j
, i
- start
, lpFill
);
2398 /* ====================================================================
2400 * Console manipulation functions
2402 * ====================================================================*/
2404 /* some missing functions...
2405 * FIXME: those are likely to be defined as undocumented function in kernel32 (or part of them)
2406 * should get the right API and implement them
2407 * GetConsoleCommandHistory[AW] (dword dword dword)
2408 * GetConsoleCommandHistoryLength[AW]
2409 * SetConsoleCommandHistoryMode
2410 * SetConsoleNumberOfCommands[AW]
2412 int CONSOLE_GetHistory(int idx
, WCHAR
* buf
, int buf_len
)
2416 SERVER_START_REQ( get_console_input_history
)
2420 if (buf
&& buf_len
> 1)
2422 wine_server_set_reply( req
, buf
, (buf_len
- 1) * sizeof(WCHAR
) );
2424 if (!wine_server_call_err( req
))
2426 if (buf
) buf
[wine_server_reply_size(reply
) / sizeof(WCHAR
)] = 0;
2427 len
= reply
->total
/ sizeof(WCHAR
) + 1;
2434 /******************************************************************
2435 * CONSOLE_AppendHistory
2439 BOOL
CONSOLE_AppendHistory(const WCHAR
* ptr
)
2441 size_t len
= strlenW(ptr
);
2444 while (len
&& (ptr
[len
- 1] == '\n' || ptr
[len
- 1] == '\r')) len
--;
2446 SERVER_START_REQ( append_console_input_history
)
2449 wine_server_add_data( req
, ptr
, len
* sizeof(WCHAR
) );
2450 ret
= !wine_server_call_err( req
);
2456 /******************************************************************
2457 * CONSOLE_GetNumHistoryEntries
2461 unsigned CONSOLE_GetNumHistoryEntries(void)
2464 SERVER_START_REQ(get_console_input_info
)
2467 if (!wine_server_call_err( req
)) ret
= reply
->history_index
;
2473 /******************************************************************
2474 * CONSOLE_GetEditionMode
2478 BOOL
CONSOLE_GetEditionMode(HANDLE hConIn
, int* mode
)
2480 unsigned ret
= FALSE
;
2481 SERVER_START_REQ(get_console_input_info
)
2483 req
->handle
= console_handle_unmap(hConIn
);
2484 if ((ret
= !wine_server_call_err( req
)))
2485 *mode
= reply
->edition_mode
;