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,2005 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"
56 WINE_DEFAULT_DEBUG_CHANNEL(console
);
58 static UINT console_input_codepage
;
59 static UINT console_output_codepage
;
61 static const WCHAR coninW
[] = {'C','O','N','I','N','$',0};
62 static const WCHAR conoutW
[] = {'C','O','N','O','U','T','$',0};
64 /* map input records to ASCII */
65 static void input_records_WtoA( INPUT_RECORD
*buffer
, int count
)
70 for (i
= 0; i
< count
; i
++)
72 if (buffer
[i
].EventType
!= KEY_EVENT
) continue;
73 WideCharToMultiByte( GetConsoleCP(), 0,
74 &buffer
[i
].Event
.KeyEvent
.uChar
.UnicodeChar
, 1, &ch
, 1, NULL
, NULL
);
75 buffer
[i
].Event
.KeyEvent
.uChar
.AsciiChar
= ch
;
79 /* map input records to Unicode */
80 static void input_records_AtoW( INPUT_RECORD
*buffer
, int count
)
85 for (i
= 0; i
< count
; i
++)
87 if (buffer
[i
].EventType
!= KEY_EVENT
) continue;
88 MultiByteToWideChar( GetConsoleCP(), 0,
89 &buffer
[i
].Event
.KeyEvent
.uChar
.AsciiChar
, 1, &ch
, 1 );
90 buffer
[i
].Event
.KeyEvent
.uChar
.UnicodeChar
= ch
;
94 /* map char infos to ASCII */
95 static void char_info_WtoA( CHAR_INFO
*buffer
, int count
)
101 WideCharToMultiByte( GetConsoleOutputCP(), 0, &buffer
->Char
.UnicodeChar
, 1,
102 &ch
, 1, NULL
, NULL
);
103 buffer
->Char
.AsciiChar
= ch
;
108 /* map char infos to Unicode */
109 static void char_info_AtoW( CHAR_INFO
*buffer
, int count
)
115 MultiByteToWideChar( GetConsoleOutputCP(), 0, &buffer
->Char
.AsciiChar
, 1, &ch
, 1 );
116 buffer
->Char
.UnicodeChar
= ch
;
122 /******************************************************************************
123 * GetConsoleWindow [KERNEL32.@]
125 HWND WINAPI
GetConsoleWindow(VOID
)
132 /******************************************************************************
133 * GetConsoleCP [KERNEL32.@] Returns the OEM code page for the console
138 UINT WINAPI
GetConsoleCP(VOID
)
140 if (!console_input_codepage
)
142 console_input_codepage
= GetOEMCP();
143 TRACE("%u\n", console_input_codepage
);
145 return console_input_codepage
;
149 /******************************************************************************
150 * SetConsoleCP [KERNEL32.@]
152 BOOL WINAPI
SetConsoleCP(UINT cp
)
154 if (!IsValidCodePage( cp
)) return FALSE
;
155 console_input_codepage
= cp
;
160 /***********************************************************************
161 * GetConsoleOutputCP (KERNEL32.@)
163 UINT WINAPI
GetConsoleOutputCP(VOID
)
165 if (!console_output_codepage
)
167 console_output_codepage
= GetOEMCP();
168 TRACE("%u\n", console_output_codepage
);
170 return console_output_codepage
;
174 /******************************************************************************
175 * SetConsoleOutputCP [KERNEL32.@] Set the output codepage used by the console
178 * cp [I] code page to set
184 BOOL WINAPI
SetConsoleOutputCP(UINT cp
)
186 if (!IsValidCodePage( cp
)) return FALSE
;
187 console_output_codepage
= cp
;
192 /***********************************************************************
195 BOOL WINAPI
Beep( DWORD dwFreq
, DWORD dwDur
)
197 static const char beep
= '\a';
198 /* dwFreq and dwDur are ignored by Win95 */
199 if (isatty(2)) write( 2, &beep
, 1 );
204 /******************************************************************
205 * OpenConsoleW (KERNEL32.@)
208 * Open a handle to the current process console.
209 * Returns INVALID_HANDLE_VALUE on failure.
211 HANDLE WINAPI
OpenConsoleW(LPCWSTR name
, DWORD access
, BOOL inherit
, DWORD creation
)
216 if (strcmpiW(coninW
, name
) == 0)
218 else if (strcmpiW(conoutW
, name
) == 0)
222 SetLastError(ERROR_INVALID_NAME
);
223 return INVALID_HANDLE_VALUE
;
225 if (creation
!= OPEN_EXISTING
)
227 SetLastError(ERROR_INVALID_PARAMETER
);
228 return INVALID_HANDLE_VALUE
;
231 SERVER_START_REQ( open_console
)
234 req
->access
= access
;
235 req
->share
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
236 req
->inherit
= inherit
;
238 wine_server_call_err( req
);
243 ret
= console_handle_map(ret
);
246 /* likely, we're not attached to wineconsole
247 * let's try to return a handle to the unix-console
249 int fd
= open("/dev/tty", output
? O_WRONLY
: O_RDONLY
);
250 ret
= INVALID_HANDLE_VALUE
;
253 DWORD attr
= (output
? GENERIC_WRITE
: GENERIC_READ
) | SYNCHRONIZE
;
254 wine_server_fd_to_handle(fd
, attr
, inherit
, &ret
);
261 /******************************************************************
262 * VerifyConsoleIoHandle (KERNEL32.@)
266 BOOL WINAPI
VerifyConsoleIoHandle(HANDLE handle
)
270 if (!is_console_handle(handle
)) return FALSE
;
271 SERVER_START_REQ(get_console_mode
)
273 req
->handle
= console_handle_unmap(handle
);
274 ret
= !wine_server_call_err( req
);
280 /******************************************************************
281 * DuplicateConsoleHandle (KERNEL32.@)
285 HANDLE WINAPI
DuplicateConsoleHandle(HANDLE handle
, DWORD access
, BOOL inherit
,
290 if (!is_console_handle(handle
) ||
291 !DuplicateHandle(GetCurrentProcess(), console_handle_unmap(handle
),
292 GetCurrentProcess(), &ret
, access
, inherit
, options
))
293 return INVALID_HANDLE_VALUE
;
294 return console_handle_map(ret
);
297 /******************************************************************
298 * CloseConsoleHandle (KERNEL32.@)
302 BOOL WINAPI
CloseConsoleHandle(HANDLE handle
)
304 if (!is_console_handle(handle
))
306 SetLastError(ERROR_INVALID_PARAMETER
);
309 return CloseHandle(console_handle_unmap(handle
));
312 /******************************************************************
313 * GetConsoleInputWaitHandle (KERNEL32.@)
317 HANDLE WINAPI
GetConsoleInputWaitHandle(void)
319 static HANDLE console_wait_event
;
321 /* FIXME: this is not thread safe */
322 if (!console_wait_event
)
324 SERVER_START_REQ(get_console_wait_event
)
326 if (!wine_server_call_err( req
)) console_wait_event
= reply
->handle
;
330 return console_wait_event
;
334 /******************************************************************************
335 * WriteConsoleInputA [KERNEL32.@]
337 BOOL WINAPI
WriteConsoleInputA( HANDLE handle
, const INPUT_RECORD
*buffer
,
338 DWORD count
, LPDWORD written
)
343 if (!(recW
= HeapAlloc( GetProcessHeap(), 0, count
* sizeof(*recW
) ))) return FALSE
;
344 memcpy( recW
, buffer
, count
*sizeof(*recW
) );
345 input_records_AtoW( recW
, count
);
346 ret
= WriteConsoleInputW( handle
, recW
, count
, written
);
347 HeapFree( GetProcessHeap(), 0, recW
);
352 /******************************************************************************
353 * WriteConsoleInputW [KERNEL32.@]
355 BOOL WINAPI
WriteConsoleInputW( HANDLE handle
, const INPUT_RECORD
*buffer
,
356 DWORD count
, LPDWORD written
)
360 TRACE("(%p,%p,%ld,%p)\n", handle
, buffer
, count
, written
);
362 if (written
) *written
= 0;
363 SERVER_START_REQ( write_console_input
)
365 req
->handle
= console_handle_unmap(handle
);
366 wine_server_add_data( req
, buffer
, count
* sizeof(INPUT_RECORD
) );
367 if ((ret
= !wine_server_call_err( req
)) && written
)
368 *written
= reply
->written
;
376 /***********************************************************************
377 * WriteConsoleOutputA (KERNEL32.@)
379 BOOL WINAPI
WriteConsoleOutputA( HANDLE hConsoleOutput
, const CHAR_INFO
*lpBuffer
,
380 COORD size
, COORD coord
, LPSMALL_RECT region
)
384 COORD new_size
, new_coord
;
387 new_size
.X
= min( region
->Right
- region
->Left
+ 1, size
.X
- coord
.X
);
388 new_size
.Y
= min( region
->Bottom
- region
->Top
+ 1, size
.Y
- coord
.Y
);
390 if (new_size
.X
<= 0 || new_size
.Y
<= 0)
392 region
->Bottom
= region
->Top
+ new_size
.Y
- 1;
393 region
->Right
= region
->Left
+ new_size
.X
- 1;
397 /* only copy the useful rectangle */
398 if (!(ciw
= HeapAlloc( GetProcessHeap(), 0, sizeof(CHAR_INFO
) * new_size
.X
* new_size
.Y
)))
400 for (y
= 0; y
< new_size
.Y
; y
++)
402 memcpy( &ciw
[y
* new_size
.X
], &lpBuffer
[(y
+ coord
.Y
) * size
.X
+ coord
.X
],
403 new_size
.X
* sizeof(CHAR_INFO
) );
404 char_info_AtoW( &ciw
[ y
* new_size
.X
], new_size
.X
);
406 new_coord
.X
= new_coord
.Y
= 0;
407 ret
= WriteConsoleOutputW( hConsoleOutput
, ciw
, new_size
, new_coord
, region
);
408 HeapFree( GetProcessHeap(), 0, ciw
);
413 /***********************************************************************
414 * WriteConsoleOutputW (KERNEL32.@)
416 BOOL WINAPI
WriteConsoleOutputW( HANDLE hConsoleOutput
, const CHAR_INFO
*lpBuffer
,
417 COORD size
, COORD coord
, LPSMALL_RECT region
)
419 int width
, height
, y
;
422 TRACE("(%p,%p,(%d,%d),(%d,%d),(%d,%dx%d,%d)\n",
423 hConsoleOutput
, lpBuffer
, size
.X
, size
.Y
, coord
.X
, coord
.Y
,
424 region
->Left
, region
->Top
, region
->Right
, region
->Bottom
);
426 width
= min( region
->Right
- region
->Left
+ 1, size
.X
- coord
.X
);
427 height
= min( region
->Bottom
- region
->Top
+ 1, size
.Y
- coord
.Y
);
429 if (width
> 0 && height
> 0)
431 for (y
= 0; y
< height
; y
++)
433 SERVER_START_REQ( write_console_output
)
435 req
->handle
= console_handle_unmap(hConsoleOutput
);
436 req
->x
= region
->Left
;
437 req
->y
= region
->Top
+ y
;
438 req
->mode
= CHAR_INFO_MODE_TEXTATTR
;
440 wine_server_add_data( req
, &lpBuffer
[(y
+ coord
.Y
) * size
.X
+ coord
.X
],
441 width
* sizeof(CHAR_INFO
));
442 if ((ret
= !wine_server_call_err( req
)))
444 width
= min( width
, reply
->width
- region
->Left
);
445 height
= min( height
, reply
->height
- region
->Top
);
452 region
->Bottom
= region
->Top
+ height
- 1;
453 region
->Right
= region
->Left
+ width
- 1;
458 /******************************************************************************
459 * WriteConsoleOutputCharacterA [KERNEL32.@]
461 * See WriteConsoleOutputCharacterW.
463 BOOL WINAPI
WriteConsoleOutputCharacterA( HANDLE hConsoleOutput
, LPCSTR str
, DWORD length
,
464 COORD coord
, LPDWORD lpNumCharsWritten
)
470 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput
,
471 debugstr_an(str
, length
), length
, coord
.X
, coord
.Y
, lpNumCharsWritten
);
473 lenW
= MultiByteToWideChar( GetConsoleOutputCP(), 0, str
, length
, NULL
, 0 );
475 if (lpNumCharsWritten
) *lpNumCharsWritten
= 0;
477 if (!(strW
= HeapAlloc( GetProcessHeap(), 0, lenW
* sizeof(WCHAR
) ))) return FALSE
;
478 MultiByteToWideChar( GetConsoleOutputCP(), 0, str
, length
, strW
, lenW
);
480 ret
= WriteConsoleOutputCharacterW( hConsoleOutput
, strW
, lenW
, coord
, lpNumCharsWritten
);
481 HeapFree( GetProcessHeap(), 0, strW
);
486 /******************************************************************************
487 * WriteConsoleOutputAttribute [KERNEL32.@] Sets attributes for some cells in
488 * the console screen buffer
491 * hConsoleOutput [I] Handle to screen buffer
492 * attr [I] Pointer to buffer with write attributes
493 * length [I] Number of cells to write to
494 * coord [I] Coords of first cell
495 * lpNumAttrsWritten [O] Pointer to number of cells written
502 BOOL WINAPI
WriteConsoleOutputAttribute( HANDLE hConsoleOutput
, CONST WORD
*attr
, DWORD length
,
503 COORD coord
, LPDWORD lpNumAttrsWritten
)
507 TRACE("(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput
,attr
,length
,coord
.X
,coord
.Y
,lpNumAttrsWritten
);
509 SERVER_START_REQ( write_console_output
)
511 req
->handle
= console_handle_unmap(hConsoleOutput
);
514 req
->mode
= CHAR_INFO_MODE_ATTR
;
516 wine_server_add_data( req
, attr
, length
* sizeof(WORD
) );
517 if ((ret
= !wine_server_call_err( req
)))
519 if (lpNumAttrsWritten
) *lpNumAttrsWritten
= reply
->written
;
527 /******************************************************************************
528 * FillConsoleOutputCharacterA [KERNEL32.@]
530 * See FillConsoleOutputCharacterW.
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 * See GetConsoleTitleW.
919 DWORD WINAPI
GetConsoleTitleA(LPSTR title
, DWORD size
)
921 WCHAR
*ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * size
);
925 ret
= GetConsoleTitleW( ptr
, size
);
928 WideCharToMultiByte( GetConsoleOutputCP(), 0, ptr
, ret
+ 1, title
, size
, NULL
, NULL
);
931 HeapFree(GetProcessHeap(), 0, ptr
);
936 /******************************************************************************
937 * GetConsoleTitleW [KERNEL32.@] Retrieves title string for console
940 * title [O] Address of buffer for title
941 * size [I] Size of buffer
944 * Success: Length of string copied
947 DWORD WINAPI
GetConsoleTitleW(LPWSTR title
, DWORD size
)
951 SERVER_START_REQ( get_console_input_info
)
954 wine_server_set_reply( req
, title
, (size
-1) * sizeof(WCHAR
) );
955 if (!wine_server_call_err( req
))
957 ret
= wine_server_reply_size(reply
) / sizeof(WCHAR
);
966 /***********************************************************************
967 * GetLargestConsoleWindowSize (KERNEL32.@)
970 * This should return a COORD, but calling convention for returning
971 * structures is different between Windows and gcc on i386.
976 #undef GetLargestConsoleWindowSize
977 DWORD WINAPI
GetLargestConsoleWindowSize(HANDLE hConsoleOutput
)
985 TRACE("(%p), returning %dx%d (%lx)\n", hConsoleOutput
, x
.c
.X
, x
.c
.Y
, x
.w
);
988 #endif /* defined(__i386__) */
991 /***********************************************************************
992 * GetLargestConsoleWindowSize (KERNEL32.@)
995 * This should return a COORD, but calling convention for returning
996 * structures is different between Windows and gcc on i386.
1001 COORD WINAPI
GetLargestConsoleWindowSize(HANDLE hConsoleOutput
)
1006 TRACE("(%p), returning %dx%d\n", hConsoleOutput
, c
.X
, c
.Y
);
1009 #endif /* defined(__i386__) */
1011 static WCHAR
* S_EditString
/* = NULL */;
1012 static unsigned S_EditStrPos
/* = 0 */;
1014 /***********************************************************************
1015 * FreeConsole (KERNEL32.@)
1017 BOOL WINAPI
FreeConsole(VOID
)
1021 SERVER_START_REQ(free_console
)
1023 ret
= !wine_server_call_err( req
);
1029 /******************************************************************
1030 * start_console_renderer
1032 * helper for AllocConsole
1033 * starts the renderer process
1035 static BOOL
start_console_renderer_helper(const char* appname
, STARTUPINFOA
* si
,
1040 PROCESS_INFORMATION pi
;
1042 /* FIXME: use dynamic allocation for most of the buffers below */
1043 ret
= snprintf(buffer
, sizeof(buffer
), "%s --use-event=%d", appname
, (INT
)hEvent
);
1044 if ((ret
> -1) && (ret
< sizeof(buffer
)) &&
1045 CreateProcessA(NULL
, buffer
, NULL
, NULL
, TRUE
, DETACHED_PROCESS
,
1046 NULL
, NULL
, si
, &pi
))
1048 if (WaitForSingleObject(hEvent
, INFINITE
) != WAIT_OBJECT_0
) return FALSE
;
1050 TRACE("Started wineconsole pid=%08lx tid=%08lx\n",
1051 pi
.dwProcessId
, pi
.dwThreadId
);
1058 static BOOL
start_console_renderer(STARTUPINFOA
* si
)
1062 OBJECT_ATTRIBUTES attr
;
1065 attr
.Length
= sizeof(attr
);
1066 attr
.RootDirectory
= 0;
1067 attr
.Attributes
= OBJ_INHERIT
;
1068 attr
.ObjectName
= NULL
;
1069 attr
.SecurityDescriptor
= NULL
;
1070 attr
.SecurityQualityOfService
= NULL
;
1072 NtCreateEvent(&hEvent
, EVENT_ALL_ACCESS
, &attr
, TRUE
, FALSE
);
1073 if (!hEvent
) return FALSE
;
1075 /* first try environment variable */
1076 if ((p
= getenv("WINECONSOLE")) != NULL
)
1078 ret
= start_console_renderer_helper(p
, si
, hEvent
);
1080 ERR("Couldn't launch Wine console from WINECONSOLE env var (%s)... "
1081 "trying default access\n", p
);
1084 /* then try the regular PATH */
1086 ret
= start_console_renderer_helper("wineconsole", si
, hEvent
);
1088 CloseHandle(hEvent
);
1092 /***********************************************************************
1093 * AllocConsole (KERNEL32.@)
1095 * creates an xterm with a pty to our program
1097 BOOL WINAPI
AllocConsole(void)
1099 HANDLE handle_in
= INVALID_HANDLE_VALUE
;
1100 HANDLE handle_out
= INVALID_HANDLE_VALUE
;
1101 HANDLE handle_err
= INVALID_HANDLE_VALUE
;
1102 STARTUPINFOA siCurrent
;
1103 STARTUPINFOA siConsole
;
1108 handle_in
= OpenConsoleW( coninW
, GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,
1109 FALSE
, OPEN_EXISTING
);
1111 if (VerifyConsoleIoHandle(handle_in
))
1113 /* we already have a console opened on this process, don't create a new one */
1114 CloseHandle(handle_in
);
1117 /* happens when we're running on a Unix console */
1118 if (handle_in
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_in
);
1120 GetStartupInfoA(&siCurrent
);
1122 memset(&siConsole
, 0, sizeof(siConsole
));
1123 siConsole
.cb
= sizeof(siConsole
);
1124 /* setup a view arguments for wineconsole (it'll use them as default values) */
1125 if (siCurrent
.dwFlags
& STARTF_USECOUNTCHARS
)
1127 siConsole
.dwFlags
|= STARTF_USECOUNTCHARS
;
1128 siConsole
.dwXCountChars
= siCurrent
.dwXCountChars
;
1129 siConsole
.dwYCountChars
= siCurrent
.dwYCountChars
;
1131 if (siCurrent
.dwFlags
& STARTF_USEFILLATTRIBUTE
)
1133 siConsole
.dwFlags
|= STARTF_USEFILLATTRIBUTE
;
1134 siConsole
.dwFillAttribute
= siCurrent
.dwFillAttribute
;
1136 if (siCurrent
.dwFlags
& STARTF_USESHOWWINDOW
)
1138 siConsole
.dwFlags
|= STARTF_USESHOWWINDOW
;
1139 siConsole
.wShowWindow
= siCurrent
.wShowWindow
;
1141 /* FIXME (should pass the unicode form) */
1142 if (siCurrent
.lpTitle
)
1143 siConsole
.lpTitle
= siCurrent
.lpTitle
;
1144 else if (GetModuleFileNameA(0, buffer
, sizeof(buffer
)))
1146 buffer
[sizeof(buffer
) - 1] = '\0';
1147 siConsole
.lpTitle
= buffer
;
1150 if (!start_console_renderer(&siConsole
))
1153 if( !(siCurrent
.dwFlags
& STARTF_USESTDHANDLES
) ) {
1154 /* all std I/O handles are inheritable by default */
1155 handle_in
= OpenConsoleW( coninW
, GENERIC_READ
|GENERIC_WRITE
|SYNCHRONIZE
,
1156 TRUE
, OPEN_EXISTING
);
1157 if (handle_in
== INVALID_HANDLE_VALUE
) goto the_end
;
1159 handle_out
= OpenConsoleW( conoutW
, GENERIC_READ
|GENERIC_WRITE
,
1160 TRUE
, OPEN_EXISTING
);
1161 if (handle_out
== INVALID_HANDLE_VALUE
) goto the_end
;
1163 if (!DuplicateHandle(GetCurrentProcess(), handle_out
, GetCurrentProcess(),
1164 &handle_err
, 0, TRUE
, DUPLICATE_SAME_ACCESS
))
1167 /* STARTF_USESTDHANDLES flag: use handles from StartupInfo */
1168 handle_in
= siCurrent
.hStdInput
;
1169 handle_out
= siCurrent
.hStdOutput
;
1170 handle_err
= siCurrent
.hStdError
;
1173 /* NT resets the STD_*_HANDLEs on console alloc */
1174 SetStdHandle(STD_INPUT_HANDLE
, handle_in
);
1175 SetStdHandle(STD_OUTPUT_HANDLE
, handle_out
);
1176 SetStdHandle(STD_ERROR_HANDLE
, handle_err
);
1178 SetLastError(ERROR_SUCCESS
);
1183 ERR("Can't allocate console\n");
1184 if (handle_in
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_in
);
1185 if (handle_out
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_out
);
1186 if (handle_err
!= INVALID_HANDLE_VALUE
) CloseHandle(handle_err
);
1192 /***********************************************************************
1193 * ReadConsoleA (KERNEL32.@)
1195 BOOL WINAPI
ReadConsoleA(HANDLE hConsoleInput
, LPVOID lpBuffer
, DWORD nNumberOfCharsToRead
,
1196 LPDWORD lpNumberOfCharsRead
, LPVOID lpReserved
)
1198 LPWSTR ptr
= HeapAlloc(GetProcessHeap(), 0, nNumberOfCharsToRead
* sizeof(WCHAR
));
1202 if ((ret
= ReadConsoleW(hConsoleInput
, ptr
, nNumberOfCharsToRead
, &ncr
, NULL
)))
1203 ncr
= WideCharToMultiByte(CP_ACP
, 0, ptr
, ncr
, lpBuffer
, nNumberOfCharsToRead
, NULL
, NULL
);
1205 if (lpNumberOfCharsRead
) *lpNumberOfCharsRead
= ncr
;
1206 HeapFree(GetProcessHeap(), 0, ptr
);
1211 /***********************************************************************
1212 * ReadConsoleW (KERNEL32.@)
1214 BOOL WINAPI
ReadConsoleW(HANDLE hConsoleInput
, LPVOID lpBuffer
,
1215 DWORD nNumberOfCharsToRead
, LPDWORD lpNumberOfCharsRead
, LPVOID lpReserved
)
1218 LPWSTR xbuf
= (LPWSTR
)lpBuffer
;
1221 TRACE("(%p,%p,%ld,%p,%p)\n",
1222 hConsoleInput
, lpBuffer
, nNumberOfCharsToRead
, lpNumberOfCharsRead
, lpReserved
);
1224 if (!GetConsoleMode(hConsoleInput
, &mode
))
1227 if (mode
& ENABLE_LINE_INPUT
)
1229 if (!S_EditString
|| S_EditString
[S_EditStrPos
] == 0)
1231 HeapFree(GetProcessHeap(), 0, S_EditString
);
1232 if (!(S_EditString
= CONSOLE_Readline(hConsoleInput
)))
1236 charsread
= lstrlenW(&S_EditString
[S_EditStrPos
]);
1237 if (charsread
> nNumberOfCharsToRead
) charsread
= nNumberOfCharsToRead
;
1238 memcpy(xbuf
, &S_EditString
[S_EditStrPos
], charsread
* sizeof(WCHAR
));
1239 S_EditStrPos
+= charsread
;
1244 DWORD timeout
= INFINITE
;
1246 /* FIXME: should we read at least 1 char? The SDK does not say */
1247 /* wait for at least one available input record (it doesn't mean we'll have
1248 * chars stored in xbuf...)
1253 if (read_console_input(hConsoleInput
, &ir
, timeout
) != rci_gotone
) break;
1255 if (ir
.EventType
== KEY_EVENT
&& ir
.Event
.KeyEvent
.bKeyDown
&&
1256 ir
.Event
.KeyEvent
.uChar
.UnicodeChar
&&
1257 !(ir
.Event
.KeyEvent
.dwControlKeyState
& ENHANCED_KEY
))
1259 xbuf
[charsread
++] = ir
.Event
.KeyEvent
.uChar
.UnicodeChar
;
1261 } while (charsread
< nNumberOfCharsToRead
);
1262 /* nothing has been read */
1263 if (timeout
== INFINITE
) return FALSE
;
1266 if (lpNumberOfCharsRead
) *lpNumberOfCharsRead
= charsread
;
1272 /***********************************************************************
1273 * ReadConsoleInputW (KERNEL32.@)
1275 BOOL WINAPI
ReadConsoleInputW(HANDLE hConsoleInput
, PINPUT_RECORD lpBuffer
,
1276 DWORD nLength
, LPDWORD lpNumberOfEventsRead
)
1279 DWORD timeout
= INFINITE
;
1283 if (lpNumberOfEventsRead
) *lpNumberOfEventsRead
= 0;
1287 /* loop until we get at least one event */
1288 while (read_console_input(hConsoleInput
, &lpBuffer
[idx
], timeout
) == rci_gotone
&&
1292 if (lpNumberOfEventsRead
) *lpNumberOfEventsRead
= idx
;
1297 /******************************************************************************
1298 * WriteConsoleOutputCharacterW [KERNEL32.@]
1300 * Copy character to consecutive cells in the console screen buffer.
1303 * hConsoleOutput [I] Handle to screen buffer
1304 * str [I] Pointer to buffer with chars to write
1305 * length [I] Number of cells to write to
1306 * coord [I] Coords of first cell
1307 * lpNumCharsWritten [O] Pointer to number of cells written
1314 BOOL WINAPI
WriteConsoleOutputCharacterW( HANDLE hConsoleOutput
, LPCWSTR str
, DWORD length
,
1315 COORD coord
, LPDWORD lpNumCharsWritten
)
1319 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput
,
1320 debugstr_wn(str
, length
), length
, coord
.X
, coord
.Y
, lpNumCharsWritten
);
1322 SERVER_START_REQ( write_console_output
)
1324 req
->handle
= console_handle_unmap(hConsoleOutput
);
1327 req
->mode
= CHAR_INFO_MODE_TEXT
;
1329 wine_server_add_data( req
, str
, length
* sizeof(WCHAR
) );
1330 if ((ret
= !wine_server_call_err( req
)))
1332 if (lpNumCharsWritten
) *lpNumCharsWritten
= reply
->written
;
1340 /******************************************************************************
1341 * SetConsoleTitleW [KERNEL32.@] Sets title bar string for console
1344 * title [I] Address of new title
1350 BOOL WINAPI
SetConsoleTitleW(LPCWSTR title
)
1354 TRACE("(%s)\n", debugstr_w(title
));
1355 SERVER_START_REQ( set_console_input_info
)
1358 req
->mask
= SET_CONSOLE_INPUT_INFO_TITLE
;
1359 wine_server_add_data( req
, title
, strlenW(title
) * sizeof(WCHAR
) );
1360 ret
= !wine_server_call_err( req
);
1367 /***********************************************************************
1368 * GetNumberOfConsoleMouseButtons (KERNEL32.@)
1370 BOOL WINAPI
GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons
)
1372 FIXME("(%p): stub\n", nrofbuttons
);
1377 /******************************************************************************
1378 * SetConsoleInputExeNameW [KERNEL32.@]
1383 BOOL WINAPI
SetConsoleInputExeNameW(LPCWSTR name
)
1385 FIXME("(%s): stub!\n", debugstr_w(name
));
1387 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1391 /******************************************************************************
1392 * SetConsoleInputExeNameA [KERNEL32.@]
1397 BOOL WINAPI
SetConsoleInputExeNameA(LPCSTR name
)
1399 int len
= MultiByteToWideChar(CP_ACP
, 0, name
, -1, NULL
, 0);
1400 LPWSTR xptr
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1403 if (!xptr
) return FALSE
;
1405 MultiByteToWideChar(CP_ACP
, 0, name
, -1, xptr
, len
);
1406 ret
= SetConsoleInputExeNameW(xptr
);
1407 HeapFree(GetProcessHeap(), 0, xptr
);
1412 /******************************************************************
1413 * CONSOLE_DefaultHandler
1415 * Final control event handler
1417 static BOOL WINAPI
CONSOLE_DefaultHandler(DWORD dwCtrlType
)
1419 FIXME("Terminating process %lx on event %lx\n", GetCurrentProcessId(), dwCtrlType
);
1421 /* should never go here */
1425 /******************************************************************************
1426 * SetConsoleCtrlHandler [KERNEL32.@] Adds function to calling process list
1429 * func [I] Address of handler function
1430 * add [I] Handler to add or remove
1437 struct ConsoleHandler
1439 PHANDLER_ROUTINE handler
;
1440 struct ConsoleHandler
* next
;
1443 static struct ConsoleHandler CONSOLE_DefaultConsoleHandler
= {CONSOLE_DefaultHandler
, NULL
};
1444 static struct ConsoleHandler
* CONSOLE_Handlers
= &CONSOLE_DefaultConsoleHandler
;
1446 static CRITICAL_SECTION CONSOLE_CritSect
;
1447 static CRITICAL_SECTION_DEBUG critsect_debug
=
1449 0, 0, &CONSOLE_CritSect
,
1450 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
1451 0, 0, { (DWORD_PTR
)(__FILE__
": CONSOLE_CritSect") }
1453 static CRITICAL_SECTION CONSOLE_CritSect
= { &critsect_debug
, -1, 0, 0, 0, 0 };
1455 /*****************************************************************************/
1457 /******************************************************************
1458 * SetConsoleCtrlHandler (KERNEL32.@)
1460 BOOL WINAPI
SetConsoleCtrlHandler(PHANDLER_ROUTINE func
, BOOL add
)
1464 TRACE("(%p,%i)\n", func
, add
);
1468 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1470 NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
|= 1;
1472 NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
&= ~1;
1473 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1477 struct ConsoleHandler
* ch
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct ConsoleHandler
));
1479 if (!ch
) return FALSE
;
1481 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1482 ch
->next
= CONSOLE_Handlers
;
1483 CONSOLE_Handlers
= ch
;
1484 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1488 struct ConsoleHandler
** ch
;
1489 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1490 for (ch
= &CONSOLE_Handlers
; *ch
; ch
= &(*ch
)->next
)
1492 if ((*ch
)->handler
== func
) break;
1496 struct ConsoleHandler
* rch
= *ch
;
1499 if (rch
== &CONSOLE_DefaultConsoleHandler
)
1501 ERR("Who's trying to remove default handler???\n");
1502 SetLastError(ERROR_INVALID_PARAMETER
);
1508 HeapFree(GetProcessHeap(), 0, rch
);
1513 WARN("Attempt to remove non-installed CtrlHandler %p\n", func
);
1514 SetLastError(ERROR_INVALID_PARAMETER
);
1517 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1522 static WINE_EXCEPTION_FILTER(CONSOLE_CtrlEventHandler
)
1524 TRACE("(%lx)\n", GetExceptionCode());
1525 return EXCEPTION_EXECUTE_HANDLER
;
1528 /******************************************************************
1529 * CONSOLE_SendEventThread
1531 * Internal helper to pass an event to the list on installed handlers
1533 static DWORD WINAPI
CONSOLE_SendEventThread(void* pmt
)
1535 DWORD event
= (DWORD
)pmt
;
1536 struct ConsoleHandler
* ch
;
1538 if (event
== CTRL_C_EVENT
)
1540 BOOL caught_by_dbg
= TRUE
;
1541 /* First, try to pass the ctrl-C event to the debugger (if any)
1542 * If it continues, there's nothing more to do
1543 * Otherwise, we need to send the ctrl-C event to the handlers
1547 RaiseException( DBG_CONTROL_C
, 0, 0, NULL
);
1549 __EXCEPT(CONSOLE_CtrlEventHandler
)
1551 caught_by_dbg
= FALSE
;
1554 if (caught_by_dbg
) return 0;
1555 /* the debugger didn't continue... so, pass to ctrl handlers */
1557 RtlEnterCriticalSection(&CONSOLE_CritSect
);
1558 for (ch
= CONSOLE_Handlers
; ch
; ch
= ch
->next
)
1560 if (ch
->handler(event
)) break;
1562 RtlLeaveCriticalSection(&CONSOLE_CritSect
);
1566 /******************************************************************
1567 * CONSOLE_HandleCtrlC
1569 * Check whether the shall manipulate CtrlC events
1571 int CONSOLE_HandleCtrlC(unsigned sig
)
1573 /* FIXME: better test whether a console is attached to this process ??? */
1574 extern unsigned CONSOLE_GetNumHistoryEntries(void);
1575 if (CONSOLE_GetNumHistoryEntries() == (unsigned)-1) return 0;
1577 /* check if we have to ignore ctrl-C events */
1578 if (!(NtCurrentTeb()->Peb
->ProcessParameters
->ConsoleFlags
& 1))
1580 /* Create a separate thread to signal all the events.
1581 * This is needed because:
1582 * - this function can be called in an Unix signal handler (hence on an
1583 * different stack than the thread that's running). This breaks the
1584 * Win32 exception mechanisms (where the thread's stack is checked).
1585 * - since the current thread, while processing the signal, can hold the
1586 * console critical section, we need another execution environment where
1587 * we can wait on this critical section
1589 CreateThread(NULL
, 0, CONSOLE_SendEventThread
, (void*)CTRL_C_EVENT
, 0, NULL
);
1594 /******************************************************************************
1595 * GenerateConsoleCtrlEvent [KERNEL32.@] Simulate a CTRL-C or CTRL-BREAK
1598 * dwCtrlEvent [I] Type of event
1599 * dwProcessGroupID [I] Process group ID to send event to
1603 * Failure: False (and *should* [but doesn't] set LastError)
1605 BOOL WINAPI
GenerateConsoleCtrlEvent(DWORD dwCtrlEvent
,
1606 DWORD dwProcessGroupID
)
1610 TRACE("(%ld, %ld)\n", dwCtrlEvent
, dwProcessGroupID
);
1612 if (dwCtrlEvent
!= CTRL_C_EVENT
&& dwCtrlEvent
!= CTRL_BREAK_EVENT
)
1614 ERR("Invalid event %ld for PGID %ld\n", dwCtrlEvent
, dwProcessGroupID
);
1618 SERVER_START_REQ( send_console_signal
)
1620 req
->signal
= dwCtrlEvent
;
1621 req
->group_id
= dwProcessGroupID
;
1622 ret
= !wine_server_call_err( req
);
1626 /* FIXME: shall this function be synchronous, ie only return when all events
1627 * have been handled by all processes in the given group ?
1628 * As of today, we don't wait...
1634 /******************************************************************************
1635 * CreateConsoleScreenBuffer [KERNEL32.@] Creates a console screen buffer
1638 * dwDesiredAccess [I] Access flag
1639 * dwShareMode [I] Buffer share mode
1640 * sa [I] Security attributes
1641 * dwFlags [I] Type of buffer to create
1642 * lpScreenBufferData [I] Reserved
1645 * Should call SetLastError
1648 * Success: Handle to new console screen buffer
1649 * Failure: INVALID_HANDLE_VALUE
1651 HANDLE WINAPI
CreateConsoleScreenBuffer(DWORD dwDesiredAccess
, DWORD dwShareMode
,
1652 LPSECURITY_ATTRIBUTES sa
, DWORD dwFlags
,
1653 LPVOID lpScreenBufferData
)
1655 HANDLE ret
= INVALID_HANDLE_VALUE
;
1657 TRACE("(%ld,%ld,%p,%ld,%p)\n",
1658 dwDesiredAccess
, dwShareMode
, sa
, dwFlags
, lpScreenBufferData
);
1660 if (dwFlags
!= CONSOLE_TEXTMODE_BUFFER
|| lpScreenBufferData
!= NULL
)
1662 SetLastError(ERROR_INVALID_PARAMETER
);
1663 return INVALID_HANDLE_VALUE
;
1666 SERVER_START_REQ(create_console_output
)
1669 req
->access
= dwDesiredAccess
;
1670 req
->share
= dwShareMode
;
1671 req
->inherit
= (sa
&& sa
->bInheritHandle
);
1672 if (!wine_server_call_err( req
)) ret
= reply
->handle_out
;
1680 /***********************************************************************
1681 * GetConsoleScreenBufferInfo (KERNEL32.@)
1683 BOOL WINAPI
GetConsoleScreenBufferInfo(HANDLE hConsoleOutput
, LPCONSOLE_SCREEN_BUFFER_INFO csbi
)
1687 SERVER_START_REQ(get_console_output_info
)
1689 req
->handle
= console_handle_unmap(hConsoleOutput
);
1690 if ((ret
= !wine_server_call_err( req
)))
1692 csbi
->dwSize
.X
= reply
->width
;
1693 csbi
->dwSize
.Y
= reply
->height
;
1694 csbi
->dwCursorPosition
.X
= reply
->cursor_x
;
1695 csbi
->dwCursorPosition
.Y
= reply
->cursor_y
;
1696 csbi
->wAttributes
= reply
->attr
;
1697 csbi
->srWindow
.Left
= reply
->win_left
;
1698 csbi
->srWindow
.Right
= reply
->win_right
;
1699 csbi
->srWindow
.Top
= reply
->win_top
;
1700 csbi
->srWindow
.Bottom
= reply
->win_bottom
;
1701 csbi
->dwMaximumWindowSize
.X
= reply
->max_width
;
1702 csbi
->dwMaximumWindowSize
.Y
= reply
->max_height
;
1707 TRACE("(%p,(%d,%d) (%d,%d) %d (%d,%d-%d,%d) (%d,%d)\n",
1708 hConsoleOutput
, csbi
->dwSize
.X
, csbi
->dwSize
.Y
,
1709 csbi
->dwCursorPosition
.X
, csbi
->dwCursorPosition
.Y
,
1711 csbi
->srWindow
.Left
, csbi
->srWindow
.Top
, csbi
->srWindow
.Right
, csbi
->srWindow
.Bottom
,
1712 csbi
->dwMaximumWindowSize
.X
, csbi
->dwMaximumWindowSize
.Y
);
1718 /******************************************************************************
1719 * SetConsoleActiveScreenBuffer [KERNEL32.@] Sets buffer to current console
1725 BOOL WINAPI
SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput
)
1729 TRACE("(%p)\n", hConsoleOutput
);
1731 SERVER_START_REQ( set_console_input_info
)
1734 req
->mask
= SET_CONSOLE_INPUT_INFO_ACTIVE_SB
;
1735 req
->active_sb
= hConsoleOutput
;
1736 ret
= !wine_server_call_err( req
);
1743 /***********************************************************************
1744 * GetConsoleMode (KERNEL32.@)
1746 BOOL WINAPI
GetConsoleMode(HANDLE hcon
, LPDWORD mode
)
1750 SERVER_START_REQ(get_console_mode
)
1752 req
->handle
= console_handle_unmap(hcon
);
1753 ret
= !wine_server_call_err( req
);
1754 if (ret
&& mode
) *mode
= reply
->mode
;
1761 /******************************************************************************
1762 * SetConsoleMode [KERNEL32.@] Sets input mode of console's input buffer
1765 * hcon [I] Handle to console input or screen buffer
1766 * mode [I] Input or output mode to set
1773 * ENABLE_PROCESSED_INPUT 0x01
1774 * ENABLE_LINE_INPUT 0x02
1775 * ENABLE_ECHO_INPUT 0x04
1776 * ENABLE_WINDOW_INPUT 0x08
1777 * ENABLE_MOUSE_INPUT 0x10
1779 BOOL WINAPI
SetConsoleMode(HANDLE hcon
, DWORD mode
)
1783 SERVER_START_REQ(set_console_mode
)
1785 req
->handle
= console_handle_unmap(hcon
);
1787 ret
= !wine_server_call_err( req
);
1790 /* FIXME: when resetting a console input to editline mode, I think we should
1791 * empty the S_EditString buffer
1794 TRACE("(%p,%lx) retval == %d\n", hcon
, mode
, ret
);
1800 /******************************************************************
1801 * CONSOLE_WriteChars
1803 * WriteConsoleOutput helper: hides server call semantics
1804 * writes a string at a given pos with standard attribute
1806 static int CONSOLE_WriteChars(HANDLE hCon
, LPCWSTR lpBuffer
, int nc
, COORD
* pos
)
1812 SERVER_START_REQ( write_console_output
)
1814 req
->handle
= console_handle_unmap(hCon
);
1817 req
->mode
= CHAR_INFO_MODE_TEXTSTDATTR
;
1819 wine_server_add_data( req
, lpBuffer
, nc
* sizeof(WCHAR
) );
1820 if (!wine_server_call_err( req
)) written
= reply
->written
;
1824 if (written
> 0) pos
->X
+= written
;
1828 /******************************************************************
1831 * WriteConsoleOutput helper: handles passing to next line (+scrolling if necessary)
1834 static int next_line(HANDLE hCon
, CONSOLE_SCREEN_BUFFER_INFO
* csbi
)
1840 csbi
->dwCursorPosition
.X
= 0;
1841 csbi
->dwCursorPosition
.Y
++;
1843 if (csbi
->dwCursorPosition
.Y
< csbi
->dwSize
.Y
) return 1;
1846 src
.Bottom
= csbi
->dwSize
.Y
- 1;
1848 src
.Right
= csbi
->dwSize
.X
- 1;
1853 ci
.Attributes
= csbi
->wAttributes
;
1854 ci
.Char
.UnicodeChar
= ' ';
1856 csbi
->dwCursorPosition
.Y
--;
1857 if (!ScrollConsoleScreenBufferW(hCon
, &src
, NULL
, dst
, &ci
))
1862 /******************************************************************
1865 * WriteConsoleOutput helper: writes a block of non special characters
1866 * Block can spread on several lines, and wrapping, if needed, is
1870 static int write_block(HANDLE hCon
, CONSOLE_SCREEN_BUFFER_INFO
* csbi
,
1871 DWORD mode
, LPCWSTR ptr
, int len
)
1873 int blk
; /* number of chars to write on current line */
1874 int done
; /* number of chars already written */
1876 if (len
<= 0) return 1;
1878 if (mode
& ENABLE_WRAP_AT_EOL_OUTPUT
) /* writes remaining on next line */
1880 for (done
= 0; done
< len
; done
+= blk
)
1882 blk
= min(len
- done
, csbi
->dwSize
.X
- csbi
->dwCursorPosition
.X
);
1884 if (CONSOLE_WriteChars(hCon
, ptr
+ done
, blk
, &csbi
->dwCursorPosition
) != blk
)
1886 if (csbi
->dwCursorPosition
.X
== csbi
->dwSize
.X
&& !next_line(hCon
, csbi
))
1892 int pos
= csbi
->dwCursorPosition
.X
;
1893 /* FIXME: we could reduce the number of loops
1894 * but, in most cases we wouldn't gain lots of time (it would only
1895 * happen if we're asked to overwrite more than twice the part of the line,
1898 for (blk
= done
= 0; done
< len
; done
+= blk
)
1900 blk
= min(len
- done
, csbi
->dwSize
.X
- csbi
->dwCursorPosition
.X
);
1902 csbi
->dwCursorPosition
.X
= pos
;
1903 if (CONSOLE_WriteChars(hCon
, ptr
+ done
, blk
, &csbi
->dwCursorPosition
) != blk
)
1911 /***********************************************************************
1912 * WriteConsoleW (KERNEL32.@)
1914 BOOL WINAPI
WriteConsoleW(HANDLE hConsoleOutput
, LPCVOID lpBuffer
, DWORD nNumberOfCharsToWrite
,
1915 LPDWORD lpNumberOfCharsWritten
, LPVOID lpReserved
)
1919 const WCHAR
* psz
= lpBuffer
;
1920 CONSOLE_SCREEN_BUFFER_INFO csbi
;
1923 TRACE("%p %s %ld %p %p\n",
1924 hConsoleOutput
, debugstr_wn(lpBuffer
, nNumberOfCharsToWrite
),
1925 nNumberOfCharsToWrite
, lpNumberOfCharsWritten
, lpReserved
);
1927 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= 0;
1929 if (!GetConsoleMode(hConsoleOutput
, &mode
) ||
1930 !GetConsoleScreenBufferInfo(hConsoleOutput
, &csbi
))
1933 if (mode
& ENABLE_PROCESSED_OUTPUT
)
1937 for (i
= 0; i
< nNumberOfCharsToWrite
; i
++)
1941 case '\b': case '\t': case '\n': case '\a': case '\r':
1942 /* don't handle here the i-th char... done below */
1943 if ((k
= i
- first
) > 0)
1945 if (!write_block(hConsoleOutput
, &csbi
, mode
, &psz
[first
], k
))
1955 if (csbi
.dwCursorPosition
.X
> 0) csbi
.dwCursorPosition
.X
--;
1959 WCHAR tmp
[8] = {' ',' ',' ',' ',' ',' ',' ',' '};
1961 if (!write_block(hConsoleOutput
, &csbi
, mode
, tmp
,
1962 ((csbi
.dwCursorPosition
.X
+ 8) & ~7) - csbi
.dwCursorPosition
.X
))
1967 next_line(hConsoleOutput
, &csbi
);
1973 csbi
.dwCursorPosition
.X
= 0;
1981 /* write the remaining block (if any) if processed output is enabled, or the
1982 * entire buffer otherwise
1984 if ((k
= nNumberOfCharsToWrite
- first
) > 0)
1986 if (!write_block(hConsoleOutput
, &csbi
, mode
, &psz
[first
], k
))
1992 SetConsoleCursorPosition(hConsoleOutput
, csbi
.dwCursorPosition
);
1993 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= nw
;
1998 /***********************************************************************
1999 * WriteConsoleA (KERNEL32.@)
2001 BOOL WINAPI
WriteConsoleA(HANDLE hConsoleOutput
, LPCVOID lpBuffer
, DWORD nNumberOfCharsToWrite
,
2002 LPDWORD lpNumberOfCharsWritten
, LPVOID lpReserved
)
2008 n
= MultiByteToWideChar(CP_ACP
, 0, lpBuffer
, nNumberOfCharsToWrite
, NULL
, 0);
2010 if (lpNumberOfCharsWritten
) *lpNumberOfCharsWritten
= 0;
2011 xstring
= HeapAlloc(GetProcessHeap(), 0, n
* sizeof(WCHAR
));
2012 if (!xstring
) return 0;
2014 MultiByteToWideChar(CP_ACP
, 0, lpBuffer
, nNumberOfCharsToWrite
, xstring
, n
);
2016 ret
= WriteConsoleW(hConsoleOutput
, xstring
, n
, lpNumberOfCharsWritten
, 0);
2018 HeapFree(GetProcessHeap(), 0, xstring
);
2023 /******************************************************************************
2024 * SetConsoleCursorPosition [KERNEL32.@]
2025 * Sets the cursor position in console
2028 * hConsoleOutput [I] Handle of console screen buffer
2029 * dwCursorPosition [I] New cursor position coordinates
2035 BOOL WINAPI
SetConsoleCursorPosition(HANDLE hcon
, COORD pos
)
2038 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2042 TRACE("%p %d %d\n", hcon
, pos
.X
, pos
.Y
);
2044 SERVER_START_REQ(set_console_output_info
)
2046 req
->handle
= console_handle_unmap(hcon
);
2047 req
->cursor_x
= pos
.X
;
2048 req
->cursor_y
= pos
.Y
;
2049 req
->mask
= SET_CONSOLE_OUTPUT_INFO_CURSOR_POS
;
2050 ret
= !wine_server_call_err( req
);
2054 if (!ret
|| !GetConsoleScreenBufferInfo(hcon
, &csbi
))
2057 /* if cursor is no longer visible, scroll the visible window... */
2058 w
= csbi
.srWindow
.Right
- csbi
.srWindow
.Left
+ 1;
2059 h
= csbi
.srWindow
.Bottom
- csbi
.srWindow
.Top
+ 1;
2060 if (pos
.X
< csbi
.srWindow
.Left
)
2062 csbi
.srWindow
.Left
= min(pos
.X
, csbi
.dwSize
.X
- w
);
2065 else if (pos
.X
> csbi
.srWindow
.Right
)
2067 csbi
.srWindow
.Left
= max(pos
.X
, w
) - w
+ 1;
2070 csbi
.srWindow
.Right
= csbi
.srWindow
.Left
+ w
- 1;
2072 if (pos
.Y
< csbi
.srWindow
.Top
)
2074 csbi
.srWindow
.Top
= min(pos
.Y
, csbi
.dwSize
.Y
- h
);
2077 else if (pos
.Y
> csbi
.srWindow
.Bottom
)
2079 csbi
.srWindow
.Top
= max(pos
.Y
, h
) - h
+ 1;
2082 csbi
.srWindow
.Bottom
= csbi
.srWindow
.Top
+ h
- 1;
2084 ret
= (do_move
) ? SetConsoleWindowInfo(hcon
, TRUE
, &csbi
.srWindow
) : TRUE
;
2089 /******************************************************************************
2090 * GetConsoleCursorInfo [KERNEL32.@] Gets size and visibility of console
2093 * hcon [I] Handle to console screen buffer
2094 * cinfo [O] Address of cursor information
2100 BOOL WINAPI
GetConsoleCursorInfo(HANDLE hCon
, LPCONSOLE_CURSOR_INFO cinfo
)
2104 SERVER_START_REQ(get_console_output_info
)
2106 req
->handle
= console_handle_unmap(hCon
);
2107 ret
= !wine_server_call_err( req
);
2110 cinfo
->dwSize
= reply
->cursor_size
;
2111 cinfo
->bVisible
= reply
->cursor_visible
;
2116 TRACE("(%p) returning (%ld,%d)\n", hCon
, cinfo
->dwSize
, cinfo
->bVisible
);
2121 /******************************************************************************
2122 * SetConsoleCursorInfo [KERNEL32.@] Sets size and visibility of cursor
2125 * hcon [I] Handle to console screen buffer
2126 * cinfo [I] Address of cursor information
2131 BOOL WINAPI
SetConsoleCursorInfo(HANDLE hCon
, LPCONSOLE_CURSOR_INFO cinfo
)
2135 TRACE("(%p,%ld,%d)\n", hCon
, cinfo
->dwSize
, cinfo
->bVisible
);
2136 SERVER_START_REQ(set_console_output_info
)
2138 req
->handle
= console_handle_unmap(hCon
);
2139 req
->cursor_size
= cinfo
->dwSize
;
2140 req
->cursor_visible
= cinfo
->bVisible
;
2141 req
->mask
= SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM
;
2142 ret
= !wine_server_call_err( req
);
2149 /******************************************************************************
2150 * SetConsoleWindowInfo [KERNEL32.@] Sets size and position of console
2153 * hcon [I] Handle to console screen buffer
2154 * bAbsolute [I] Coordinate type flag
2155 * window [I] Address of new window rectangle
2160 BOOL WINAPI
SetConsoleWindowInfo(HANDLE hCon
, BOOL bAbsolute
, LPSMALL_RECT window
)
2162 SMALL_RECT p
= *window
;
2165 TRACE("(%p,%d,(%d,%d-%d,%d))\n", hCon
, bAbsolute
, p
.Left
, p
.Top
, p
.Right
, p
.Bottom
);
2169 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2171 if (!GetConsoleScreenBufferInfo(hCon
, &csbi
))
2173 p
.Left
+= csbi
.srWindow
.Left
;
2174 p
.Top
+= csbi
.srWindow
.Top
;
2175 p
.Right
+= csbi
.srWindow
.Right
;
2176 p
.Bottom
+= csbi
.srWindow
.Bottom
;
2178 SERVER_START_REQ(set_console_output_info
)
2180 req
->handle
= console_handle_unmap(hCon
);
2181 req
->win_left
= p
.Left
;
2182 req
->win_top
= p
.Top
;
2183 req
->win_right
= p
.Right
;
2184 req
->win_bottom
= p
.Bottom
;
2185 req
->mask
= SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW
;
2186 ret
= !wine_server_call_err( req
);
2194 /******************************************************************************
2195 * SetConsoleTextAttribute [KERNEL32.@] Sets colors for text
2197 * Sets the foreground and background color attributes of characters
2198 * written to the screen buffer.
2204 BOOL WINAPI
SetConsoleTextAttribute(HANDLE hConsoleOutput
, WORD wAttr
)
2208 TRACE("(%p,%d)\n", hConsoleOutput
, wAttr
);
2209 SERVER_START_REQ(set_console_output_info
)
2211 req
->handle
= console_handle_unmap(hConsoleOutput
);
2213 req
->mask
= SET_CONSOLE_OUTPUT_INFO_ATTR
;
2214 ret
= !wine_server_call_err( req
);
2221 /******************************************************************************
2222 * SetConsoleScreenBufferSize [KERNEL32.@] Changes size of console
2225 * hConsoleOutput [I] Handle to console screen buffer
2226 * dwSize [I] New size in character rows and cols
2232 BOOL WINAPI
SetConsoleScreenBufferSize(HANDLE hConsoleOutput
, COORD dwSize
)
2236 TRACE("(%p,(%d,%d))\n", hConsoleOutput
, dwSize
.X
, dwSize
.Y
);
2237 SERVER_START_REQ(set_console_output_info
)
2239 req
->handle
= console_handle_unmap(hConsoleOutput
);
2240 req
->width
= dwSize
.X
;
2241 req
->height
= dwSize
.Y
;
2242 req
->mask
= SET_CONSOLE_OUTPUT_INFO_SIZE
;
2243 ret
= !wine_server_call_err( req
);
2250 /******************************************************************************
2251 * ScrollConsoleScreenBufferA [KERNEL32.@]
2254 BOOL WINAPI
ScrollConsoleScreenBufferA(HANDLE hConsoleOutput
, LPSMALL_RECT lpScrollRect
,
2255 LPSMALL_RECT lpClipRect
, COORD dwDestOrigin
,
2260 ciw
.Attributes
= lpFill
->Attributes
;
2261 MultiByteToWideChar(CP_ACP
, 0, &lpFill
->Char
.AsciiChar
, 1, &ciw
.Char
.UnicodeChar
, 1);
2263 return ScrollConsoleScreenBufferW(hConsoleOutput
, lpScrollRect
, lpClipRect
,
2264 dwDestOrigin
, &ciw
);
2267 /******************************************************************
2268 * CONSOLE_FillLineUniform
2270 * Helper function for ScrollConsoleScreenBufferW
2271 * Fills a part of a line with a constant character info
2273 void CONSOLE_FillLineUniform(HANDLE hConsoleOutput
, int i
, int j
, int len
, LPCHAR_INFO lpFill
)
2275 SERVER_START_REQ( fill_console_output
)
2277 req
->handle
= console_handle_unmap(hConsoleOutput
);
2278 req
->mode
= CHAR_INFO_MODE_TEXTATTR
;
2283 req
->data
.ch
= lpFill
->Char
.UnicodeChar
;
2284 req
->data
.attr
= lpFill
->Attributes
;
2285 wine_server_call_err( req
);
2290 /******************************************************************************
2291 * ScrollConsoleScreenBufferW [KERNEL32.@]
2295 BOOL WINAPI
ScrollConsoleScreenBufferW(HANDLE hConsoleOutput
, LPSMALL_RECT lpScrollRect
,
2296 LPSMALL_RECT lpClipRect
, COORD dwDestOrigin
,
2304 CONSOLE_SCREEN_BUFFER_INFO csbi
;
2309 TRACE("(%p,(%d,%d-%d,%d),(%d,%d-%d,%d),%d-%d,%p)\n", hConsoleOutput
,
2310 lpScrollRect
->Left
, lpScrollRect
->Top
,
2311 lpScrollRect
->Right
, lpScrollRect
->Bottom
,
2312 lpClipRect
->Left
, lpClipRect
->Top
,
2313 lpClipRect
->Right
, lpClipRect
->Bottom
,
2314 dwDestOrigin
.X
, dwDestOrigin
.Y
, lpFill
);
2316 TRACE("(%p,(%d,%d-%d,%d),(nil),%d-%d,%p)\n", hConsoleOutput
,
2317 lpScrollRect
->Left
, lpScrollRect
->Top
,
2318 lpScrollRect
->Right
, lpScrollRect
->Bottom
,
2319 dwDestOrigin
.X
, dwDestOrigin
.Y
, lpFill
);
2321 if (!GetConsoleScreenBufferInfo(hConsoleOutput
, &csbi
))
2324 src
.X
= lpScrollRect
->Left
;
2325 src
.Y
= lpScrollRect
->Top
;
2327 /* step 1: get dst rect */
2328 dst
.Left
= dwDestOrigin
.X
;
2329 dst
.Top
= dwDestOrigin
.Y
;
2330 dst
.Right
= dst
.Left
+ (lpScrollRect
->Right
- lpScrollRect
->Left
);
2331 dst
.Bottom
= dst
.Top
+ (lpScrollRect
->Bottom
- lpScrollRect
->Top
);
2333 /* step 2a: compute the final clip rect (optional passed clip and screen buffer limits */
2336 clip
.Left
= max(0, lpClipRect
->Left
);
2337 clip
.Right
= min(csbi
.dwSize
.X
- 1, lpClipRect
->Right
);
2338 clip
.Top
= max(0, lpClipRect
->Top
);
2339 clip
.Bottom
= min(csbi
.dwSize
.Y
- 1, lpClipRect
->Bottom
);
2344 clip
.Right
= csbi
.dwSize
.X
- 1;
2346 clip
.Bottom
= csbi
.dwSize
.Y
- 1;
2348 if (clip
.Left
> clip
.Right
|| clip
.Top
> clip
.Bottom
) return FALSE
;
2350 /* step 2b: clip dst rect */
2351 if (dst
.Left
< clip
.Left
) {src
.X
+= clip
.Left
- dst
.Left
; dst
.Left
= clip
.Left
;}
2352 if (dst
.Top
< clip
.Top
) {src
.Y
+= clip
.Top
- dst
.Top
; dst
.Top
= clip
.Top
;}
2353 if (dst
.Right
> clip
.Right
) dst
.Right
= clip
.Right
;
2354 if (dst
.Bottom
> clip
.Bottom
) dst
.Bottom
= clip
.Bottom
;
2356 /* step 3: transfer the bits */
2357 SERVER_START_REQ(move_console_output
)
2359 req
->handle
= console_handle_unmap(hConsoleOutput
);
2362 req
->x_dst
= dst
.Left
;
2363 req
->y_dst
= dst
.Top
;
2364 req
->w
= dst
.Right
- dst
.Left
+ 1;
2365 req
->h
= dst
.Bottom
- dst
.Top
+ 1;
2366 ret
= !wine_server_call_err( req
);
2370 if (!ret
) return FALSE
;
2372 /* step 4: clean out the exposed part */
2374 /* have to write cell [i,j] if it is not in dst rect (because it has already
2375 * been written to by the scroll) and is in clip (we shall not write
2378 for (j
= max(lpScrollRect
->Top
, clip
.Top
); j
<= min(lpScrollRect
->Bottom
, clip
.Bottom
); j
++)
2380 inside
= dst
.Top
<= j
&& j
<= dst
.Bottom
;
2382 for (i
= max(lpScrollRect
->Left
, clip
.Left
); i
<= min(lpScrollRect
->Right
, clip
.Right
); i
++)
2384 if (inside
&& dst
.Left
<= i
&& i
<= dst
.Right
)
2388 CONSOLE_FillLineUniform(hConsoleOutput
, start
, j
, i
- start
, lpFill
);
2394 if (start
== -1) start
= i
;
2398 CONSOLE_FillLineUniform(hConsoleOutput
, start
, j
, i
- start
, lpFill
);
2405 /* ====================================================================
2407 * Console manipulation functions
2409 * ====================================================================*/
2411 /* some missing functions...
2412 * FIXME: those are likely to be defined as undocumented function in kernel32 (or part of them)
2413 * should get the right API and implement them
2414 * GetConsoleCommandHistory[AW] (dword dword dword)
2415 * GetConsoleCommandHistoryLength[AW]
2416 * SetConsoleCommandHistoryMode
2417 * SetConsoleNumberOfCommands[AW]
2419 int CONSOLE_GetHistory(int idx
, WCHAR
* buf
, int buf_len
)
2423 SERVER_START_REQ( get_console_input_history
)
2427 if (buf
&& buf_len
> 1)
2429 wine_server_set_reply( req
, buf
, (buf_len
- 1) * sizeof(WCHAR
) );
2431 if (!wine_server_call_err( req
))
2433 if (buf
) buf
[wine_server_reply_size(reply
) / sizeof(WCHAR
)] = 0;
2434 len
= reply
->total
/ sizeof(WCHAR
) + 1;
2441 /******************************************************************
2442 * CONSOLE_AppendHistory
2446 BOOL
CONSOLE_AppendHistory(const WCHAR
* ptr
)
2448 size_t len
= strlenW(ptr
);
2451 while (len
&& (ptr
[len
- 1] == '\n' || ptr
[len
- 1] == '\r')) len
--;
2453 SERVER_START_REQ( append_console_input_history
)
2456 wine_server_add_data( req
, ptr
, len
* sizeof(WCHAR
) );
2457 ret
= !wine_server_call_err( req
);
2463 /******************************************************************
2464 * CONSOLE_GetNumHistoryEntries
2468 unsigned CONSOLE_GetNumHistoryEntries(void)
2471 SERVER_START_REQ(get_console_input_info
)
2474 if (!wine_server_call_err( req
)) ret
= reply
->history_index
;
2480 /******************************************************************
2481 * CONSOLE_GetEditionMode
2485 BOOL
CONSOLE_GetEditionMode(HANDLE hConIn
, int* mode
)
2487 unsigned ret
= FALSE
;
2488 SERVER_START_REQ(get_console_input_info
)
2490 req
->handle
= console_handle_unmap(hConIn
);
2491 if ((ret
= !wine_server_call_err( req
)))
2492 *mode
= reply
->edition_mode
;