?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement NtAccessCheck.
[wine/gsoc-2012-control.git] / dlls / kernel / console.c
blob5cfe916e277a4dc6b3f45eda2456aecef3b6ad59
1 /*
2 * Win32 console functions
3 *
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
10 *
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.
15 *
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.
20 *
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
24 */
25
26 /* Reference applications:
27 * - IDA (interactive disassembler) full version 3.75. Works.
28 * - LYNX/W32. Works mostly, some keys crash it.
29 */
30
31 #include "config.h"
32 #include "wine/port.h"
33
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <string.h>
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <assert.h>
41
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winnls.h"
45 #include "winerror.h"
46 #include "wincon.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"
52 #include "excpt.h"
53 #include "console_private.h"
54 #include "kernel_private.h"
55 #include "thread.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(console);
58
59 static UINT console_input_codepage;
60 static UINT console_output_codepage;
61
62
63 /* map input records to ASCII */
64 static void input_records_WtoA( INPUT_RECORD *buffer, int count )
65 {
66 int i;
67 char ch;
68
69 for (i = 0; i < count; i++)
70 {
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;
75 }
76 }
77
78 /* map input records to Unicode */
79 static void input_records_AtoW( INPUT_RECORD *buffer, int count )
80 {
81 int i;
82 WCHAR ch;
83
84 for (i = 0; i < count; i++)
85 {
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;
90 }
91 }
92
93 /* map char infos to ASCII */
94 static void char_info_WtoA( CHAR_INFO *buffer, int count )
95 {
96 char ch;
97
98 while (count-- > 0)
99 {
100 WideCharToMultiByte( GetConsoleOutputCP(), 0, &buffer->Char.UnicodeChar, 1,
101 &ch, 1, NULL, NULL );
102 buffer->Char.AsciiChar = ch;
103 buffer++;
104 }
105 }
106
107 /* map char infos to Unicode */
108 static void char_info_AtoW( CHAR_INFO *buffer, int count )
109 {
110 WCHAR ch;
111
112 while (count-- > 0)
113 {
114 MultiByteToWideChar( GetConsoleOutputCP(), 0, &buffer->Char.AsciiChar, 1, &ch, 1 );
115 buffer->Char.UnicodeChar = ch;
116 buffer++;
117 }
118 }
119
120
121 /******************************************************************************
122 * GetConsoleWindow [KERNEL32.@]
123 */
124 HWND WINAPI GetConsoleWindow(VOID)
125 {
126 FIXME("stub\n");
127 return NULL;
128 }
129
130
131 /******************************************************************************
132 * GetConsoleCP [KERNEL32.@] Returns the OEM code page for the console
133 *
134 * RETURNS
135 * Code page code
136 */
137 UINT WINAPI GetConsoleCP(VOID)
138 {
139 if (!console_input_codepage)
140 {
141 console_input_codepage = GetOEMCP();
142 TRACE("%u\n", console_input_codepage);
143 }
144 return console_input_codepage;
145 }
146
147
148 /******************************************************************************
149 * SetConsoleCP [KERNEL32.@]
150 */
151 BOOL WINAPI SetConsoleCP(UINT cp)
152 {
153 if (!IsValidCodePage( cp )) return FALSE;
154 console_input_codepage = cp;
155 return TRUE;
156 }
157
158
159 /***********************************************************************
160 * GetConsoleOutputCP (KERNEL32.@)
161 */
162 UINT WINAPI GetConsoleOutputCP(VOID)
163 {
164 if (!console_output_codepage)
165 {
166 console_output_codepage = GetOEMCP();
167 TRACE("%u\n", console_output_codepage);
168 }
169 return console_output_codepage;
170 }
171
172
173 /******************************************************************************
174 * SetConsoleOutputCP [KERNEL32.@] Set the output codepage used by the console
175 *
176 * PARAMS
177 * cp [I] code page to set
178 *
179 * RETURNS
180 * Success: TRUE
181 * Failure: FALSE
182 */
183 BOOL WINAPI SetConsoleOutputCP(UINT cp)
184 {
185 if (!IsValidCodePage( cp )) return FALSE;
186 console_output_codepage = cp;
187 return TRUE;
188 }
189
190
191 /***********************************************************************
192 * Beep (KERNEL32.@)
193 */
194 BOOL WINAPI Beep( DWORD dwFreq, DWORD dwDur )
195 {
196 static const char beep = '\a';
197 /* dwFreq and dwDur are ignored by Win95 */
198 if (isatty(2)) write( 2, &beep, 1 );
199 return TRUE;
200 }
201
202
203 /******************************************************************
204 * OpenConsoleW (KERNEL32.@)
205 *
206 * Undocumented
207 * Open a handle to the current process console.
208 * Returns INVALID_HANDLE_VALUE on failure.
209 */
210 HANDLE WINAPI OpenConsoleW(LPCWSTR name, DWORD access, BOOL inherit, DWORD creation)
211 {
212 static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
213 static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
214 BOOL output;
215 HANDLE ret;
216
217 if (strcmpiW(coninW, name) == 0)
218 output = FALSE;
219 else if (strcmpiW(conoutW, name) == 0)
220 output = TRUE;
221 else
222 {
223 SetLastError(ERROR_INVALID_NAME);
224 return INVALID_HANDLE_VALUE;
225 }
226 if (creation != OPEN_EXISTING)
227 {
228 SetLastError(ERROR_INVALID_PARAMETER);
229 return INVALID_HANDLE_VALUE;
230 }
231
232 SERVER_START_REQ( open_console )
233 {
234 req->from = output;
235 req->access = access;
236 req->share = FILE_SHARE_READ | FILE_SHARE_WRITE;
237 req->inherit = inherit;
238 SetLastError(0);
239 wine_server_call_err( req );
240 ret = reply->handle;
241 }
242 SERVER_END_REQ;
243 return ret ? console_handle_map(ret) : INVALID_HANDLE_VALUE;
244 }
245
246 /******************************************************************
247 * VerifyConsoleIoHandle (KERNEL32.@)
248 *
249 * Undocumented
250 */
251 BOOL WINAPI VerifyConsoleIoHandle(HANDLE handle)
252 {
253 BOOL ret;
254
255 if (!is_console_handle(handle)) return FALSE;
256 SERVER_START_REQ(get_console_mode)
257 {
258 req->handle = console_handle_unmap(handle);
259 ret = !wine_server_call_err( req );
260 }
261 SERVER_END_REQ;
262 return ret;
263 }
264
265 /******************************************************************
266 * DuplicateConsoleHandle (KERNEL32.@)
267 *
268 * Undocumented
269 */
270 HANDLE WINAPI DuplicateConsoleHandle(HANDLE handle, DWORD access, BOOL inherit,
271 DWORD options)
272 {
273 HANDLE ret;
274
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);
280 }
281
282 /******************************************************************
283 * CloseConsoleHandle (KERNEL32.@)
284 *
285 * Undocumented
286 */
287 BOOL WINAPI CloseConsoleHandle(HANDLE handle)
288 {
289 if (!is_console_handle(handle))
290 {
291 SetLastError(ERROR_INVALID_PARAMETER);
292 return FALSE;
293 }
294 return CloseHandle(console_handle_unmap(handle));
295 }
296
297 /******************************************************************
298 * GetConsoleInputWaitHandle (KERNEL32.@)
299 *
300 * Undocumented
301 */
302 HANDLE WINAPI GetConsoleInputWaitHandle(void)
303 {
304 static HANDLE console_wait_event;
305
306 /* FIXME: this is not thread safe */
307 if (!console_wait_event)
308 {
309 SERVER_START_REQ(get_console_wait_event)
310 {
311 if (!wine_server_call_err( req )) console_wait_event = reply->handle;
312 }
313 SERVER_END_REQ;
314 }
315 return console_wait_event;
316 }
317
318
319 /******************************************************************************
320 * WriteConsoleInputA [KERNEL32.@]
321 */
322 BOOL WINAPI WriteConsoleInputA( HANDLE handle, const INPUT_RECORD *buffer,
323 DWORD count, LPDWORD written )
324 {
325 INPUT_RECORD *recW;
326 BOOL ret;
327
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 );
333 return ret;
334 }
335
336
337 /******************************************************************************
338 * WriteConsoleInputW [KERNEL32.@]
339 */
340 BOOL WINAPI WriteConsoleInputW( HANDLE handle, const INPUT_RECORD *buffer,
341 DWORD count, LPDWORD written )
342 {
343 BOOL ret;
344
345 TRACE("(%p,%p,%ld,%p)\n", handle, buffer, count, written);
346
347 if (written) *written = 0;
348 SERVER_START_REQ( write_console_input )
349 {
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;
354 }
355 SERVER_END_REQ;
356
357 return ret;
358 }
359
360
361 /***********************************************************************
362 * WriteConsoleOutputA (KERNEL32.@)
363 */
364 BOOL WINAPI WriteConsoleOutputA( HANDLE hConsoleOutput, const CHAR_INFO *lpBuffer,
365 COORD size, COORD coord, LPSMALL_RECT region )
366 {
367 int y;
368 BOOL ret;
369 COORD new_size, new_coord;
370 CHAR_INFO *ciw;
371
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 );
374
375 if (new_size.X <= 0 || new_size.Y <= 0)
376 {
377 region->Bottom = region->Top + new_size.Y - 1;
378 region->Right = region->Left + new_size.X - 1;
379 return TRUE;
380 }
381
382 /* only copy the useful rectangle */
383 if (!(ciw = HeapAlloc( GetProcessHeap(), 0, sizeof(CHAR_INFO) * new_size.X * new_size.Y )))
384 return FALSE;
385 for (y = 0; y < new_size.Y; y++)
386 {
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[ y * new_size.X ], new_size.X );
390 }
391 new_coord.X = new_coord.Y = 0;
392 ret = WriteConsoleOutputW( hConsoleOutput, ciw, new_size, new_coord, region );
393 HeapFree( GetProcessHeap(), 0, ciw );
394 return ret;
395 }
396
397
398 /***********************************************************************
399 * WriteConsoleOutputW (KERNEL32.@)
400 */
401 BOOL WINAPI WriteConsoleOutputW( HANDLE hConsoleOutput, const CHAR_INFO *lpBuffer,
402 COORD size, COORD coord, LPSMALL_RECT region )
403 {
404 int width, height, y;
405 BOOL ret = TRUE;
406
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);
410
411 width = min( region->Right - region->Left + 1, size.X - coord.X );
412 height = min( region->Bottom - region->Top + 1, size.Y - coord.Y );
413
414 if (width > 0 && height > 0)
415 {
416 for (y = 0; y < height; y++)
417 {
418 SERVER_START_REQ( write_console_output )
419 {
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;
424 req->wrap = FALSE;
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 )))
428 {
429 width = min( width, reply->width - region->Left );
430 height = min( height, reply->height - region->Top );
431 }
432 }
433 SERVER_END_REQ;
434 if (!ret) break;
435 }
436 }
437 region->Bottom = region->Top + height - 1;
438 region->Right = region->Left + width - 1;
439 return ret;
440 }
441
442
443 /******************************************************************************
444 * WriteConsoleOutputCharacterA [KERNEL32.@] Copies character to consecutive
445 * cells in the console screen buffer
446 *
447 * PARAMS
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
453 */
454 BOOL WINAPI WriteConsoleOutputCharacterA( HANDLE hConsoleOutput, LPCSTR str, DWORD length,
455 COORD coord, LPDWORD lpNumCharsWritten )
456 {
457 BOOL ret;
458 LPWSTR strW;
459 DWORD lenW;
460
461 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput,
462 debugstr_an(str, length), length, coord.X, coord.Y, lpNumCharsWritten);
463
464 lenW = MultiByteToWideChar( GetConsoleOutputCP(), 0, str, length, NULL, 0 );
465
466 if (lpNumCharsWritten) *lpNumCharsWritten = 0;
467
468 if (!(strW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) ))) return FALSE;
469 MultiByteToWideChar( GetConsoleOutputCP(), 0, str, length, strW, lenW );
470
471 ret = WriteConsoleOutputCharacterW( hConsoleOutput, strW, lenW, coord, lpNumCharsWritten );
472 HeapFree( GetProcessHeap(), 0, strW );
473 return ret;
474 }
475
476
477 /******************************************************************************
478 * WriteConsoleOutputAttribute [KERNEL32.@] Sets attributes for some cells in
479 * the console screen buffer
480 *
481 * PARAMS
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
487 *
488 * RETURNS
489 * Success: TRUE
490 * Failure: FALSE
491 *
492 */
493 BOOL WINAPI WriteConsoleOutputAttribute( HANDLE hConsoleOutput, CONST WORD *attr, DWORD length,
494 COORD coord, LPDWORD lpNumAttrsWritten )
495 {
496 BOOL ret;
497
498 TRACE("(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput,attr,length,coord.X,coord.Y,lpNumAttrsWritten);
499
500 SERVER_START_REQ( write_console_output )
501 {
502 req->handle = console_handle_unmap(hConsoleOutput);
503 req->x = coord.X;
504 req->y = coord.Y;
505 req->mode = CHAR_INFO_MODE_ATTR;
506 req->wrap = TRUE;
507 wine_server_add_data( req, attr, length * sizeof(WORD) );
508 if ((ret = !wine_server_call_err( req )))
509 {
510 if (lpNumAttrsWritten) *lpNumAttrsWritten = reply->written;
511 }
512 }
513 SERVER_END_REQ;
514 return ret;
515 }
516
517
518 /******************************************************************************
519 * FillConsoleOutputCharacterA [KERNEL32.@]
520 *
521 * PARAMS
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
527 *
528 * RETURNS
529 * Success: TRUE
530 * Failure: FALSE
531 */
532 BOOL WINAPI FillConsoleOutputCharacterA( HANDLE hConsoleOutput, CHAR ch, DWORD length,
533 COORD coord, LPDWORD lpNumCharsWritten )
534 {
535 WCHAR wch;
536
537 MultiByteToWideChar( GetConsoleOutputCP(), 0, &ch, 1, &wch, 1 );
538 return FillConsoleOutputCharacterW(hConsoleOutput, wch, length, coord, lpNumCharsWritten);
539 }
540
541
542 /******************************************************************************
543 * FillConsoleOutputCharacterW [KERNEL32.@] Writes characters to console
544 *
545 * PARAMS
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
551 *
552 * RETURNS
553 * Success: TRUE
554 * Failure: FALSE
555 */
556 BOOL WINAPI FillConsoleOutputCharacterW( HANDLE hConsoleOutput, WCHAR ch, DWORD length,
557 COORD coord, LPDWORD lpNumCharsWritten)
558 {
559 BOOL ret;
560
561 TRACE("(%p,%s,%ld,(%dx%d),%p)\n",
562 hConsoleOutput, debugstr_wn(&ch, 1), length, coord.X, coord.Y, lpNumCharsWritten);
563
564 SERVER_START_REQ( fill_console_output )
565 {
566 req->handle = console_handle_unmap(hConsoleOutput);
567 req->x = coord.X;
568 req->y = coord.Y;
569 req->mode = CHAR_INFO_MODE_TEXT;
570 req->wrap = TRUE;
571 req->data.ch = ch;
572 req->count = length;
573 if ((ret = !wine_server_call_err( req )))
574 {
575 if (lpNumCharsWritten) *lpNumCharsWritten = reply->written;
576 }
577 }
578 SERVER_END_REQ;
579 return ret;
580 }
581
582
583 /******************************************************************************
584 * FillConsoleOutputAttribute [KERNEL32.@] Sets attributes for console
585 *
586 * PARAMS
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
592 *
593 * RETURNS
594 * Success: TRUE
595 * Failure: FALSE
596 */
597 BOOL WINAPI FillConsoleOutputAttribute( HANDLE hConsoleOutput, WORD attr, DWORD length,
598 COORD coord, LPDWORD lpNumAttrsWritten )
599 {
600 BOOL ret;
601
602 TRACE("(%p,%d,%ld,(%dx%d),%p)\n",
603 hConsoleOutput, attr, length, coord.X, coord.Y, lpNumAttrsWritten);
604
605 SERVER_START_REQ( fill_console_output )
606 {
607 req->handle = console_handle_unmap(hConsoleOutput);
608 req->x = coord.X;
609 req->y = coord.Y;
610 req->mode = CHAR_INFO_MODE_ATTR;
611 req->wrap = TRUE;
612 req->data.attr = attr;
613 req->count = length;
614 if ((ret = !wine_server_call_err( req )))
615 {
616 if (lpNumAttrsWritten) *lpNumAttrsWritten = reply->written;
617 }
618 }
619 SERVER_END_REQ;
620 return ret;
621 }
622
623
624 /******************************************************************************
625 * ReadConsoleOutputCharacterA [KERNEL32.@]
626 *
627 */
628 BOOL WINAPI ReadConsoleOutputCharacterA(HANDLE hConsoleOutput, LPSTR lpstr, DWORD count,
629 COORD coord, LPDWORD read_count)
630 {
631 DWORD read;
632 BOOL ret;
633 LPWSTR wptr = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
634
635 if (read_count) *read_count = 0;
636 if (!wptr) return FALSE;
637
638 if ((ret = ReadConsoleOutputCharacterW( hConsoleOutput, wptr, count, coord, &read )))
639 {
640 read = WideCharToMultiByte( GetConsoleOutputCP(), 0, wptr, read, lpstr, count, NULL, NULL);
641 if (read_count) *read_count = read;
642 }
643 HeapFree( GetProcessHeap(), 0, wptr );
644 return ret;
645 }
646
647
648 /******************************************************************************
649 * ReadConsoleOutputCharacterW [KERNEL32.@]
650 *
651 */
652 BOOL WINAPI ReadConsoleOutputCharacterW( HANDLE hConsoleOutput, LPWSTR buffer, DWORD count,
653 COORD coord, LPDWORD read_count )
654 {
655 BOOL ret;
656
657 TRACE( "(%p,%p,%ld,%dx%d,%p)\n", hConsoleOutput, buffer, count, coord.X, coord.Y, read_count );
658
659 SERVER_START_REQ( read_console_output )
660 {
661 req->handle = console_handle_unmap(hConsoleOutput);
662 req->x = coord.X;
663 req->y = coord.Y;
664 req->mode = CHAR_INFO_MODE_TEXT;
665 req->wrap = TRUE;
666 wine_server_set_reply( req, buffer, count * sizeof(WCHAR) );
667 if ((ret = !wine_server_call_err( req )))
668 {
669 if (read_count) *read_count = wine_server_reply_size(reply) / sizeof(WCHAR);
670 }
671 }
672 SERVER_END_REQ;
673 return ret;
674 }
675
676
677 /******************************************************************************
678 * ReadConsoleOutputAttribute [KERNEL32.@]
679 */
680 BOOL WINAPI ReadConsoleOutputAttribute(HANDLE hConsoleOutput, LPWORD lpAttribute, DWORD length,
681 COORD coord, LPDWORD read_count)
682 {
683 BOOL ret;
684
685 TRACE("(%p,%p,%ld,%dx%d,%p)\n",
686 hConsoleOutput, lpAttribute, length, coord.X, coord.Y, read_count);
687
688 SERVER_START_REQ( read_console_output )
689 {
690 req->handle = console_handle_unmap(hConsoleOutput);
691 req->x = coord.X;
692 req->y = coord.Y;
693 req->mode = CHAR_INFO_MODE_ATTR;
694 req->wrap = TRUE;
695 wine_server_set_reply( req, lpAttribute, length * sizeof(WORD) );
696 if ((ret = !wine_server_call_err( req )))
697 {
698 if (read_count) *read_count = wine_server_reply_size(reply) / sizeof(WORD);
699 }
700 }
701 SERVER_END_REQ;
702 return ret;
703 }
704
705
706 /******************************************************************************
707 * ReadConsoleOutputA [KERNEL32.@]
708 *
709 */
710 BOOL WINAPI ReadConsoleOutputA( HANDLE hConsoleOutput, LPCHAR_INFO lpBuffer, COORD size,
711 COORD coord, LPSMALL_RECT region )
712 {
713 BOOL ret;
714 int y;
715
716 ret = ReadConsoleOutputW( hConsoleOutput, lpBuffer, size, coord, region );
717 if (ret && region->Right >= region->Left)
718 {
719 for (y = 0; y <= region->Bottom - region->Top; y++)
720 {
721 char_info_WtoA( &lpBuffer[(coord.Y + y) * size.X + coord.X],
722 region->Right - region->Left + 1 );
723 }
724 }
725 return ret;
726 }
727
728
729 /******************************************************************************
730 * ReadConsoleOutputW [KERNEL32.@]
731 *
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
734 */
735 BOOL WINAPI ReadConsoleOutputW( HANDLE hConsoleOutput, LPCHAR_INFO lpBuffer, COORD size,
736 COORD coord, LPSMALL_RECT region )
737 {
738 int width, height, y;
739 BOOL ret = TRUE;
740
741 width = min( region->Right - region->Left + 1, size.X - coord.X );
742 height = min( region->Bottom - region->Top + 1, size.Y - coord.Y );
743
744 if (width > 0 && height > 0)
745 {
746 for (y = 0; y < height; y++)
747 {
748 SERVER_START_REQ( read_console_output )
749 {
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;
754 req->wrap = FALSE;
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 )))
758 {
759 width = min( width, reply->width - region->Left );
760 height = min( height, reply->height - region->Top );
761 }
762 }
763 SERVER_END_REQ;
764 if (!ret) break;
765 }
766 }
767 region->Bottom = region->Top + height - 1;
768 region->Right = region->Left + width - 1;
769 return ret;
770 }
771
772
773 /******************************************************************************
774 * ReadConsoleInputA [KERNEL32.@] Reads data from a console
775 *
776 * PARAMS
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
781 *
782 * RETURNS
783 * Success: TRUE
784 * Failure: FALSE
785 */
786 BOOL WINAPI ReadConsoleInputA( HANDLE handle, PINPUT_RECORD buffer, DWORD count, LPDWORD pRead )
787 {
788 DWORD read;
789
790 if (!ReadConsoleInputW( handle, buffer, count, &read )) return FALSE;
791 input_records_WtoA( buffer, read );
792 if (pRead) *pRead = read;
793 return TRUE;
794 }
795
796
797 /***********************************************************************
798 * PeekConsoleInputA (KERNEL32.@)
799 *
800 * Gets 'count' first events (or less) from input queue.
801 */
802 BOOL WINAPI PeekConsoleInputA( HANDLE handle, PINPUT_RECORD buffer, DWORD count, LPDWORD pRead )
803 {
804 DWORD read;
805
806 if (!PeekConsoleInputW( handle, buffer, count, &read )) return FALSE;
807 input_records_WtoA( buffer, read );
808 if (pRead) *pRead = read;
809 return TRUE;
810 }
811
812
813 /***********************************************************************
814 * PeekConsoleInputW (KERNEL32.@)
815 */
816 BOOL WINAPI PeekConsoleInputW( HANDLE handle, PINPUT_RECORD buffer, DWORD count, LPDWORD read )
817 {
818 BOOL ret;
819 SERVER_START_REQ( read_console_input )
820 {
821 req->handle = console_handle_unmap(handle);
822 req->flush = FALSE;
823 wine_server_set_reply( req, buffer, count * sizeof(INPUT_RECORD) );
824 if ((ret = !wine_server_call_err( req )))
825 {
826 if (read) *read = count ? reply->read : 0;
827 }
828 }
829 SERVER_END_REQ;
830 return ret;
831 }
832
833
834 /***********************************************************************
835 * GetNumberOfConsoleInputEvents (KERNEL32.@)
836 */
837 BOOL WINAPI GetNumberOfConsoleInputEvents( HANDLE handle, LPDWORD nrofevents )
838 {
839 BOOL ret;
840 SERVER_START_REQ( read_console_input )
841 {
842 req->handle = console_handle_unmap(handle);
843 req->flush = FALSE;
844 if ((ret = !wine_server_call_err( req )))
845 {
846 if (nrofevents) *nrofevents = reply->read;
847 }
848 }
849 SERVER_END_REQ;
850 return ret;
851 }
852
853
854 /******************************************************************************
855 * read_console_input
856 *
857 * Helper function for ReadConsole, ReadConsoleInput and FlushConsoleInputBuffer
858 *
859 * Returns
860 * 0 for error, 1 for no INPUT_RECORD ready, 2 with INPUT_RECORD ready
861 */
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)
864 {
865 enum read_console_input_return ret;
866
867 if (WaitForSingleObject(GetConsoleInputWaitHandle(), timeout) != WAIT_OBJECT_0)
868 return rci_timeout;
869 SERVER_START_REQ( read_console_input )
870 {
871 req->handle = console_handle_unmap(handle);
872 req->flush = TRUE;
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;
876 }
877 SERVER_END_REQ;
878
879 return ret;
880 }
881
882
883 /***********************************************************************
884 * FlushConsoleInputBuffer (KERNEL32.@)
885 */
886 BOOL WINAPI FlushConsoleInputBuffer( HANDLE handle )
887 {
888 enum read_console_input_return last;
889 INPUT_RECORD ir;
890
891 while ((last = read_console_input(handle, &ir, 0)) == rci_gotone);
892
893 return last == rci_timeout;
894 }
895
896
897 /***********************************************************************
898 * SetConsoleTitleA (KERNEL32.@)
899 */
900 BOOL WINAPI SetConsoleTitleA( LPCSTR title )
901 {
902 LPWSTR titleW;
903 BOOL ret;
904
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);
910 return ret;
911 }
912
913
914 /***********************************************************************
915 * GetConsoleTitleA (KERNEL32.@)
916 */
917 DWORD WINAPI GetConsoleTitleA(LPSTR title, DWORD size)
918 {
919 WCHAR *ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * size);
920 DWORD ret;
921
922 if (!ptr) return 0;
923 ret = GetConsoleTitleW( ptr, size );
924 if (ret)
925 {
926 WideCharToMultiByte( GetConsoleOutputCP(), 0, ptr, ret + 1, title, size, NULL, NULL);
927 ret = strlen(title);
928 }
929 HeapFree(GetProcessHeap(), 0, ptr);
930 return ret;
931 }
932
933
934 /******************************************************************************
935 * GetConsoleTitleW [KERNEL32.@] Retrieves title string for console
936 *
937 * PARAMS
938 * title [O] Address of buffer for title
939 * size [I] Size of buffer
940 *
941 * RETURNS
942 * Success: Length of string copied
943 * Failure: 0
944 */
945 DWORD WINAPI GetConsoleTitleW(LPWSTR title, DWORD size)
946 {
947 DWORD ret = 0;
948
949 SERVER_START_REQ( get_console_input_info )
950 {
951 req->handle = 0;
952 wine_server_set_reply( req, title, (size-1) * sizeof(WCHAR) );
953 if (!wine_server_call_err( req ))
954 {
955 ret = wine_server_reply_size(reply) / sizeof(WCHAR);
956 title[ret] = 0;
957 }
958 }
959 SERVER_END_REQ;
960 return ret;
961 }
962
963
964 /***********************************************************************
965 * GetLargestConsoleWindowSize (KERNEL32.@)
966 *
967 * NOTE
968 * This should return a COORD, but calling convention for returning
969 * structures is different between Windows and gcc on i386.
970 *
971 * VERSION: [i386]
972 */
973 #ifdef __i386__
974 #undef GetLargestConsoleWindowSize
975 DWORD WINAPI GetLargestConsoleWindowSize(HANDLE hConsoleOutput)
976 {
977 union {
978 COORD c;
979 DWORD w;
980 } x;
981 x.c.X = 80;
982 x.c.Y = 24;
983 TRACE("(%p), returning %dx%d (%lx)\n", hConsoleOutput, x.c.X, x.c.Y, x.w);
984 return x.w;
985 }
986 #endif /* defined(__i386__) */
987
988
989 /***********************************************************************
990 * GetLargestConsoleWindowSize (KERNEL32.@)
991 *
992 * NOTE
993 * This should return a COORD, but calling convention for returning
994 * structures is different between Windows and gcc on i386.
995 *
996 * VERSION: [!i386]
997 */
998 #ifndef __i386__
999 COORD WINAPI GetLargestConsoleWindowSize(HANDLE hConsoleOutput)
1000 {
1001 COORD c;
1002 c.X = 80;
1003 c.Y = 24;
1004 TRACE("(%p), returning %dx%d\n", hConsoleOutput, c.X, c.Y);
1005 return c;
1006 }
1007 #endif /* defined(__i386__) */
1008
1009 static WCHAR* S_EditString /* = NULL */;
1010 static unsigned S_EditStrPos /* = 0 */;
1011
1012 /***********************************************************************
1013 * FreeConsole (KERNEL32.@)
1014 */
1015 BOOL WINAPI FreeConsole(VOID)
1016 {
1017 BOOL ret;
1018
1019 SERVER_START_REQ(free_console)
1020 {
1021 ret = !wine_server_call_err( req );
1022 }
1023 SERVER_END_REQ;
1024 return ret;
1025 }
1026
1027 /******************************************************************
1028 * start_console_renderer
1029 *
1030 * helper for AllocConsole
1031 * starts the renderer process
1032 */
1033 static BOOL start_console_renderer_helper(const char* appname, STARTUPINFOA* si,
1034 HANDLE hEvent)
1035 {
1036 char buffer[1024];
1037 int ret;
1038 PROCESS_INFORMATION pi;
1039
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))
1045 {
1046 if (WaitForSingleObject(hEvent, INFINITE) != WAIT_OBJECT_0) return FALSE;
1047
1048 TRACE("Started wineconsole pid=%08lx tid=%08lx\n",
1049 pi.dwProcessId, pi.dwThreadId);
1050
1051 return TRUE;
1052 }
1053 return FALSE;
1054 }
1055
1056 static BOOL start_console_renderer(STARTUPINFOA* si)
1057 {
1058 HANDLE hEvent = 0;
1059 LPSTR p;
1060 OBJECT_ATTRIBUTES attr;
1061 BOOL ret = FALSE;
1062
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;
1069
1070 NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE);
1071 if (!hEvent) return FALSE;
1072
1073 /* first try environment variable */
1074 if ((p = getenv("WINECONSOLE")) != NULL)
1075 {
1076 ret = start_console_renderer_helper(p, si, hEvent);
1077 if (!ret)
1078 ERR("Couldn't launch Wine console from WINECONSOLE env var (%s)... "
1079 "trying default access\n", p);
1080 }
1081
1082 /* then try the regular PATH */
1083 if (!ret)
1084 ret = start_console_renderer_helper("wineconsole", si, hEvent);
1085
1086 CloseHandle(hEvent);
1087 return ret;
1088 }
1089
1090 /***********************************************************************
1091 * AllocConsole (KERNEL32.@)
1092 *
1093 * creates an xterm with a pty to our program
1094 */
1095 BOOL WINAPI AllocConsole(void)
1096 {
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;
1102 char buffer[1024];
1103 SECURITY_ATTRIBUTES sa;
1104
1105 TRACE("()\n");
1106
1107 handle_in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
1108 0, NULL, OPEN_EXISTING, 0, 0 );
1109
1110 if (handle_in != INVALID_HANDLE_VALUE)
1111 {
1112 /* we already have a console opened on this process, don't create a new one */
1113 CloseHandle(handle_in);
1114 return FALSE;
1115 }
1116
1117 GetStartupInfoA(&siCurrent);
1118
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)
1123 {
1124 siConsole.dwFlags |= STARTF_USECOUNTCHARS;
1125 siConsole.dwXCountChars = siCurrent.dwXCountChars;
1126 siConsole.dwYCountChars = siCurrent.dwYCountChars;
1127 }
1128 if (siCurrent.dwFlags & STARTF_USEFILLATTRIBUTE)
1129 {
1130 siConsole.dwFlags |= STARTF_USEFILLATTRIBUTE;
1131 siConsole.dwFillAttribute = siCurrent.dwFillAttribute;
1132 }
1133 if (siCurrent.dwFlags & STARTF_USESHOWWINDOW)
1134 {
1135 siConsole.dwFlags |= STARTF_USESHOWWINDOW;
1136 siConsole.wShowWindow = siCurrent.wShowWindow;
1137 }
1138 /* FIXME (should pass the unicode form) */
1139 if (siCurrent.lpTitle)
1140 siConsole.lpTitle = siCurrent.lpTitle;
1141 else if (GetModuleFileNameA(0, buffer, sizeof(buffer)))
1142 {
1143 buffer[sizeof(buffer) - 1] = '\0';
1144 siConsole.lpTitle = buffer;
1145 }
1146
1147 if (!start_console_renderer(&siConsole))
1148 goto the_end;
1149
1150 if( !(siCurrent.dwFlags & STARTF_USESTDHANDLES) ) {
1151 /* all std I/O handles are inheritable by default */
1152 sa.nLength = sizeof(sa);
1153 sa.lpSecurityDescriptor = NULL;
1154 sa.bInheritHandle = TRUE;
1155
1156 handle_in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
1157 0, &sa, OPEN_EXISTING, 0, 0 );
1158 if (handle_in == INVALID_HANDLE_VALUE) goto the_end;
1159
1160 handle_out = CreateFileA( "CONOUT$", GENERIC_READ|GENERIC_WRITE,
1161 0, &sa, OPEN_EXISTING, 0, 0 );
1162 if (handle_out == INVALID_HANDLE_VALUE) goto the_end;
1163
1164 if (!DuplicateHandle(GetCurrentProcess(), handle_out, GetCurrentProcess(),
1165 &handle_err, 0, TRUE, DUPLICATE_SAME_ACCESS))
1166 goto the_end;
1167 } else {
1168 /* STARTF_USESTDHANDLES flag: use handles from StartupInfo */
1169 handle_in = siCurrent.hStdInput;
1170 handle_out = siCurrent.hStdOutput;
1171 handle_err = siCurrent.hStdError;
1172 }
1173
1174 /* NT resets the STD_*_HANDLEs on console alloc */
1175 SetStdHandle(STD_INPUT_HANDLE, handle_in);
1176 SetStdHandle(STD_OUTPUT_HANDLE, handle_out);
1177 SetStdHandle(STD_ERROR_HANDLE, handle_err);
1178
1179 SetLastError(ERROR_SUCCESS);
1180
1181 return TRUE;
1182
1183 the_end:
1184 ERR("Can't allocate console\n");
1185 if (handle_in != INVALID_HANDLE_VALUE) CloseHandle(handle_in);
1186 if (handle_out != INVALID_HANDLE_VALUE) CloseHandle(handle_out);
1187 if (handle_err != INVALID_HANDLE_VALUE) CloseHandle(handle_err);
1188 FreeConsole();
1189 return FALSE;
1190 }
1191
1192
1193 /***********************************************************************
1194 * ReadConsoleA (KERNEL32.@)
1195 */
1196 BOOL WINAPI ReadConsoleA(HANDLE hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead,
1197 LPDWORD lpNumberOfCharsRead, LPVOID lpReserved)
1198 {
1199 LPWSTR ptr = HeapAlloc(GetProcessHeap(), 0, nNumberOfCharsToRead * sizeof(WCHAR));
1200 DWORD ncr = 0;
1201 BOOL ret;
1202
1203 if ((ret = ReadConsoleW(hConsoleInput, ptr, nNumberOfCharsToRead, &ncr, NULL)))
1204 ncr = WideCharToMultiByte(CP_ACP, 0, ptr, ncr, lpBuffer, nNumberOfCharsToRead, NULL, NULL);
1205
1206 if (lpNumberOfCharsRead) *lpNumberOfCharsRead = ncr;
1207 HeapFree(GetProcessHeap(), 0, ptr);
1208
1209 return ret;
1210 }
1211
1212 /***********************************************************************
1213 * ReadConsoleW (KERNEL32.@)
1214 */
1215 BOOL WINAPI ReadConsoleW(HANDLE hConsoleInput, LPVOID lpBuffer,
1216 DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, LPVOID lpReserved)
1217 {
1218 DWORD charsread;
1219 LPWSTR xbuf = (LPWSTR)lpBuffer;
1220 DWORD mode;
1221
1222 TRACE("(%p,%p,%ld,%p,%p)\n",
1223 hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved);
1224
1225 if (!GetConsoleMode(hConsoleInput, &mode))
1226 return FALSE;
1227
1228 if (mode & ENABLE_LINE_INPUT)
1229 {
1230 if (!S_EditString || S_EditString[S_EditStrPos] == 0)
1231 {
1232 HeapFree(GetProcessHeap(), 0, S_EditString);
1233 if (!(S_EditString = CONSOLE_Readline(hConsoleInput)))
1234 return FALSE;
1235 S_EditStrPos = 0;
1236 }
1237 charsread = lstrlenW(&S_EditString[S_EditStrPos]);
1238 if (charsread > nNumberOfCharsToRead) charsread = nNumberOfCharsToRead;
1239 memcpy(xbuf, &S_EditString[S_EditStrPos], charsread * sizeof(WCHAR));
1240 S_EditStrPos += charsread;
1241 }
1242 else
1243 {
1244 INPUT_RECORD ir;
1245 DWORD timeout = INFINITE;
1246
1247 /* FIXME: should we read at least 1 char? The SDK does not say */
1248 /* wait for at least one available input record (it doesn't mean we'll have
1249 * chars stored in xbuf...)
1250 */
1251 charsread = 0;
1252 do
1253 {
1254 if (read_console_input(hConsoleInput, &ir, timeout) != rci_gotone) break;
1255 timeout = 0;
1256 if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown &&
1257 ir.Event.KeyEvent.uChar.UnicodeChar &&
1258 !(ir.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
1259 {
1260 xbuf[charsread++] = ir.Event.KeyEvent.uChar.UnicodeChar;
1261 }
1262 } while (charsread < nNumberOfCharsToRead);
1263 /* nothing has been read */
1264 if (timeout == INFINITE) return FALSE;
1265 }
1266
1267 if (lpNumberOfCharsRead) *lpNumberOfCharsRead = charsread;
1268
1269 return TRUE;
1270 }
1271
1272
1273 /***********************************************************************
1274 * ReadConsoleInputW (KERNEL32.@)
1275 */
1276 BOOL WINAPI ReadConsoleInputW(HANDLE hConsoleInput, PINPUT_RECORD lpBuffer,
1277 DWORD nLength, LPDWORD lpNumberOfEventsRead)
1278 {
1279 DWORD idx = 0;
1280 DWORD timeout = INFINITE;
1281
1282 if (!nLength)
1283 {
1284 if (lpNumberOfEventsRead) *lpNumberOfEventsRead = 0;
1285 return TRUE;
1286 }
1287
1288 /* loop until we get at least one event */
1289 while (read_console_input(hConsoleInput, &lpBuffer[idx], timeout) == rci_gotone &&
1290 ++idx < nLength)
1291 timeout = 0;
1292
1293 if (lpNumberOfEventsRead) *lpNumberOfEventsRead = idx;
1294 return idx != 0;
1295 }
1296
1297
1298 /******************************************************************************
1299 * WriteConsoleOutputCharacterW [KERNEL32.@] Copies character to consecutive
1300 * cells in the console screen buffer
1301 *
1302 * PARAMS
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
1308 *
1309 * RETURNS
1310 * Success: TRUE
1311 * Failure: FALSE
1312 *
1313 */
1314 BOOL WINAPI WriteConsoleOutputCharacterW( HANDLE hConsoleOutput, LPCWSTR str, DWORD length,
1315 COORD coord, LPDWORD lpNumCharsWritten )
1316 {
1317 BOOL ret;
1318
1319 TRACE("(%p,%s,%ld,%dx%d,%p)\n", hConsoleOutput,
1320 debugstr_wn(str, length), length, coord.X, coord.Y, lpNumCharsWritten);
1321
1322 SERVER_START_REQ( write_console_output )
1323 {
1324 req->handle = console_handle_unmap(hConsoleOutput);
1325 req->x = coord.X;
1326 req->y = coord.Y;
1327 req->mode = CHAR_INFO_MODE_TEXT;
1328 req->wrap = TRUE;
1329 wine_server_add_data( req, str, length * sizeof(WCHAR) );
1330 if ((ret = !wine_server_call_err( req )))
1331 {
1332 if (lpNumCharsWritten) *lpNumCharsWritten = reply->written;
1333 }
1334 }
1335 SERVER_END_REQ;
1336 return ret;
1337 }
1338
1339
1340 /******************************************************************************
1341 * SetConsoleTitleW [KERNEL32.@] Sets title bar string for console
1342 *
1343 * PARAMS
1344 * title [I] Address of new title
1345 *
1346 * RETURNS
1347 * Success: TRUE
1348 * Failure: FALSE
1349 */
1350 BOOL WINAPI SetConsoleTitleW(LPCWSTR title)
1351 {
1352 BOOL ret;
1353
1354 TRACE("(%s)\n", debugstr_w(title));
1355 SERVER_START_REQ( set_console_input_info )
1356 {
1357 req->handle = 0;
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 );
1361 }
1362 SERVER_END_REQ;
1363 return ret;
1364 }
1365
1366
1367 /***********************************************************************
1368 * GetNumberOfConsoleMouseButtons (KERNEL32.@)
1369 */
1370 BOOL WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons)
1371 {
1372 FIXME("(%p): stub\n", nrofbuttons);
1373 *nrofbuttons = 2;
1374 return TRUE;
1375 }
1376
1377 /******************************************************************************
1378 * SetConsoleInputExeNameW [KERNEL32.@]
1379 *
1380 * BUGS
1381 * Unimplemented
1382 */
1383 BOOL WINAPI SetConsoleInputExeNameW(LPCWSTR name)
1384 {
1385 FIXME("(%s): stub!\n", debugstr_w(name));
1386
1387 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1388 return TRUE;
1389 }
1390
1391 /******************************************************************************
1392 * SetConsoleInputExeNameA [KERNEL32.@]
1393 *
1394 * BUGS
1395 * Unimplemented
1396 */
1397 BOOL WINAPI SetConsoleInputExeNameA(LPCSTR name)
1398 {
1399 int len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
1400 LPWSTR xptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1401 BOOL ret;
1402
1403 if (!xptr) return FALSE;
1404
1405 MultiByteToWideChar(CP_ACP, 0, name, -1, xptr, len);
1406 ret = SetConsoleInputExeNameW(xptr);
1407 HeapFree(GetProcessHeap(), 0, xptr);
1408
1409 return ret;
1410 }
1411
1412 /******************************************************************
1413 * CONSOLE_DefaultHandler
1414 *
1415 * Final control event handler
1416 */
1417 static BOOL WINAPI CONSOLE_DefaultHandler(DWORD dwCtrlType)
1418 {
1419 FIXME("Terminating process %lx on event %lx\n", GetCurrentProcessId(), dwCtrlType);
1420 ExitProcess(0);
1421 /* should never go here */
1422 return TRUE;
1423 }
1424
1425 /******************************************************************************
1426 * SetConsoleCtrlHandler [KERNEL32.@] Adds function to calling process list
1427 *
1428 * PARAMS
1429 * func [I] Address of handler function
1430 * add [I] Handler to add or remove
1431 *
1432 * RETURNS
1433 * Success: TRUE
1434 * Failure: FALSE
1435 */
1436
1437 struct ConsoleHandler
1438 {
1439 PHANDLER_ROUTINE handler;
1440 struct ConsoleHandler* next;
1441 };
1442
1443 static struct ConsoleHandler CONSOLE_DefaultConsoleHandler = {CONSOLE_DefaultHandler, NULL};
1444 static struct ConsoleHandler* CONSOLE_Handlers = &CONSOLE_DefaultConsoleHandler;
1445
1446 static CRITICAL_SECTION CONSOLE_CritSect;
1447 static CRITICAL_SECTION_DEBUG critsect_debug =
1448 {
1449 0, 0, &CONSOLE_CritSect,
1450 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
1451 0, 0, { 0, (DWORD)(__FILE__ ": CONSOLE_CritSect") }
1452 };
1453 static CRITICAL_SECTION CONSOLE_CritSect = { &critsect_debug, -1, 0, 0, 0, 0 };
1454
1455 /*****************************************************************************/
1456
1457 /******************************************************************
1458 * SetConsoleCtrlHandler (KERNEL32.@)
1459 */
1460 BOOL WINAPI SetConsoleCtrlHandler(PHANDLER_ROUTINE func, BOOL add)
1461 {
1462 BOOL ret = TRUE;
1463
1464 TRACE("(%p,%i)\n", func, add);
1465
1466 if (!func)
1467 {
1468 RtlEnterCriticalSection(&CONSOLE_CritSect);
1469 if (add)
1470 NtCurrentTeb()->Peb->ProcessParameters->ConsoleFlags |= 1;
1471 else
1472 NtCurrentTeb()->Peb->ProcessParameters->ConsoleFlags &= ~1;
1473 RtlLeaveCriticalSection(&CONSOLE_CritSect);
1474 }
1475 else if (add)
1476 {
1477 struct ConsoleHandler* ch = HeapAlloc(GetProcessHeap(), 0, sizeof(struct ConsoleHandler));
1478
1479 if (!ch) return FALSE;
1480 ch->handler = func;
1481 RtlEnterCriticalSection(&CONSOLE_CritSect);
1482 ch->next = CONSOLE_Handlers;
1483 CONSOLE_Handlers = ch;
1484 RtlLeaveCriticalSection(&CONSOLE_CritSect);
1485 }
1486 else
1487 {
1488 struct ConsoleHandler** ch;
1489 RtlEnterCriticalSection(&CONSOLE_CritSect);
1490 for (ch = &CONSOLE_Handlers; *ch; ch = &(*ch)->next)
1491 {
1492 if ((*ch)->handler == func) break;
1493 }
1494 if (*ch)
1495 {
1496 struct ConsoleHandler* rch = *ch;
1497
1498 /* sanity check */
1499 if (rch == &CONSOLE_DefaultConsoleHandler)
1500 {
1501 ERR("Who's trying to remove default handler???\n");
1502 SetLastError(ERROR_INVALID_PARAMETER);
1503 ret = FALSE;
1504 }
1505 else
1506 {
1507 *ch = rch->next;
1508 HeapFree(GetProcessHeap(), 0, rch);
1509 }
1510 }
1511 else
1512 {
1513 WARN("Attempt to remove non-installed CtrlHandler %p\n", func);
1514 SetLastError(ERROR_INVALID_PARAMETER);
1515 ret = FALSE;
1516 }
1517 RtlLeaveCriticalSection(&CONSOLE_CritSect);
1518 }
1519 return ret;
1520 }
1521
1522 static WINE_EXCEPTION_FILTER(CONSOLE_CtrlEventHandler)
1523 {
1524 TRACE("(%lx)\n", GetExceptionCode());
1525 return EXCEPTION_EXECUTE_HANDLER;
1526 }
1527
1528 /******************************************************************
1529 * CONSOLE_SendEventThread
1530 *
1531 * Internal helper to pass an event to the list on installed handlers
1532 */
1533 static DWORD WINAPI CONSOLE_SendEventThread(void* pmt)
1534 {
1535 DWORD event = (DWORD)pmt;
1536 struct ConsoleHandler* ch;
1537
1538 if (event == CTRL_C_EVENT)
1539 {
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
1544 */
1545 __TRY
1546 {
1547 RaiseException( DBG_CONTROL_C, 0, 0, NULL );
1548 }
1549 __EXCEPT(CONSOLE_CtrlEventHandler)
1550 {
1551 caught_by_dbg = FALSE;
1552 }
1553 __ENDTRY;
1554 if (caught_by_dbg) return 0;
1555 /* the debugger didn't continue... so, pass to ctrl handlers */
1556 }
1557 RtlEnterCriticalSection(&CONSOLE_CritSect);
1558 for (ch = CONSOLE_Handlers; ch; ch = ch->next)
1559 {
1560 if (ch->handler(event)) break;
1561 }
1562 RtlLeaveCriticalSection(&CONSOLE_CritSect);
1563 return 1;
1564 }
1565
1566 /******************************************************************
1567 * CONSOLE_HandleCtrlC
1568 *
1569 * Check whether the shall manipulate CtrlC events
1570 */
1571 int CONSOLE_HandleCtrlC(unsigned sig)
1572 {
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;
1576
1577 /* check if we have to ignore ctrl-C events */
1578 if (!(NtCurrentTeb()->Peb->ProcessParameters->ConsoleFlags & 1))
1579 {
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
1588 */
1589 CreateThread(NULL, 0, CONSOLE_SendEventThread, (void*)CTRL_C_EVENT, 0, NULL);
1590 }
1591 return 1;
1592 }
1593
1594 /******************************************************************************
1595 * GenerateConsoleCtrlEvent [KERNEL32.@] Simulate a CTRL-C or CTRL-BREAK
1596 *
1597 * PARAMS
1598 * dwCtrlEvent [I] Type of event
1599 * dwProcessGroupID [I] Process group ID to send event to
1600 *
1601 * RETURNS
1602 * Success: True
1603 * Failure: False (and *should* [but doesn't] set LastError)
1604 */
1605 BOOL WINAPI GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
1606 DWORD dwProcessGroupID)
1607 {
1608 BOOL ret;
1609
1610 TRACE("(%ld, %ld)\n", dwCtrlEvent, dwProcessGroupID);
1611
1612 if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
1613 {
1614 ERR("Invalid event %ld for PGID %ld\n", dwCtrlEvent, dwProcessGroupID);
1615 return FALSE;
1616 }
1617
1618 SERVER_START_REQ( send_console_signal )
1619 {
1620 req->signal = dwCtrlEvent;
1621 req->group_id = dwProcessGroupID;
1622 ret = !wine_server_call_err( req );
1623 }
1624 SERVER_END_REQ;
1625
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...
1629 */
1630 return ret;
1631 }
1632
1633
1634 /******************************************************************************
1635 * CreateConsoleScreenBuffer [KERNEL32.@] Creates a console screen buffer
1636 *
1637 * PARAMS
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
1643 *
1644 * NOTES
1645 * Should call SetLastError
1646 *
1647 * RETURNS
1648 * Success: Handle to new console screen buffer
1649 * Failure: INVALID_HANDLE_VALUE
1650 */
1651 HANDLE WINAPI CreateConsoleScreenBuffer(DWORD dwDesiredAccess, DWORD dwShareMode,
1652 LPSECURITY_ATTRIBUTES sa, DWORD dwFlags,
1653 LPVOID lpScreenBufferData)
1654 {
1655 HANDLE ret = INVALID_HANDLE_VALUE;
1656
1657 TRACE("(%ld,%ld,%p,%ld,%p)\n",
1658 dwDesiredAccess, dwShareMode, sa, dwFlags, lpScreenBufferData);
1659
1660 if (dwFlags != CONSOLE_TEXTMODE_BUFFER || lpScreenBufferData != NULL)
1661 {
1662 SetLastError(ERROR_INVALID_PARAMETER);
1663 return INVALID_HANDLE_VALUE;
1664 }
1665
1666 SERVER_START_REQ(create_console_output)
1667 {
1668 req->handle_in = 0;
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;
1673 }
1674 SERVER_END_REQ;
1675
1676 return ret;
1677 }
1678
1679
1680 /***********************************************************************
1681 * GetConsoleScreenBufferInfo (KERNEL32.@)
1682 */
1683 BOOL WINAPI GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, LPCONSOLE_SCREEN_BUFFER_INFO csbi)
1684 {
1685 BOOL ret;
1686
1687 SERVER_START_REQ(get_console_output_info)
1688 {
1689 req->handle = console_handle_unmap(hConsoleOutput);
1690 if ((ret = !wine_server_call_err( req )))
1691 {
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;
1703 }
1704 }
1705 SERVER_END_REQ;
1706
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,
1710 csbi->wAttributes,
1711 csbi->srWindow.Left, csbi->srWindow.Top, csbi->srWindow.Right, csbi->srWindow.Bottom,
1712 csbi->dwMaximumWindowSize.X, csbi->dwMaximumWindowSize.Y);
1713
1714 return ret;
1715 }
1716
1717
1718 /******************************************************************************
1719 * SetConsoleActiveScreenBuffer [KERNEL32.@] Sets buffer to current console
1720 *
1721 * RETURNS
1722 * Success: TRUE
1723 * Failure: FALSE
1724 */
1725 BOOL WINAPI SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput)
1726 {
1727 BOOL ret;
1728
1729 TRACE("(%p)\n", hConsoleOutput);
1730
1731 SERVER_START_REQ( set_console_input_info )
1732 {
1733 req->handle = 0;
1734 req->mask = SET_CONSOLE_INPUT_INFO_ACTIVE_SB;
1735 req->active_sb = hConsoleOutput;
1736 ret = !wine_server_call_err( req );
1737 }
1738 SERVER_END_REQ;
1739 return ret;
1740 }
1741
1742
1743 /***********************************************************************
1744 * GetConsoleMode (KERNEL32.@)
1745 */
1746 BOOL WINAPI GetConsoleMode(HANDLE hcon, LPDWORD mode)
1747 {
1748 BOOL ret;
1749
1750 SERVER_START_REQ(get_console_mode)
1751 {
1752 req->handle = console_handle_unmap(hcon);
1753 ret = !wine_server_call_err( req );
1754 if (ret && mode) *mode = reply->mode;
1755 }
1756 SERVER_END_REQ;
1757 return ret;
1758 }
1759
1760
1761 /******************************************************************************
1762 * SetConsoleMode [KERNEL32.@] Sets input mode of console's input buffer
1763 *
1764 * PARAMS
1765 * hcon [I] Handle to console input or screen buffer
1766 * mode [I] Input or output mode to set
1767 *
1768 * RETURNS
1769 * Success: TRUE
1770 * Failure: FALSE
1771 *
1772 * mode:
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
1778 */
1779 BOOL WINAPI SetConsoleMode(HANDLE hcon, DWORD mode)
1780 {
1781 BOOL ret;
1782
1783 SERVER_START_REQ(set_console_mode)
1784 {
1785 req->handle = console_handle_unmap(hcon);
1786 req->mode = mode;
1787 ret = !wine_server_call_err( req );
1788 }
1789 SERVER_END_REQ;
1790 /* FIXME: when resetting a console input to editline mode, I think we should
1791 * empty the S_EditString buffer
1792 */
1793
1794 TRACE("(%p,%lx) retval == %d\n", hcon, mode, ret);
1795
1796 return ret;
1797 }
1798
1799
1800 /******************************************************************
1801 * CONSOLE_WriteChars
1802 *
1803 * WriteConsoleOutput helper: hides server call semantics
1804 * writes a string at a given pos with standard attribute
1805 */
1806 int CONSOLE_WriteChars(HANDLE hCon, LPCWSTR lpBuffer, int nc, COORD* pos)
1807 {
1808 int written = -1;
1809
1810 if (!nc) return 0;
1811
1812 SERVER_START_REQ( write_console_output )
1813 {
1814 req->handle = console_handle_unmap(hCon);
1815 req->x = pos->X;
1816 req->y = pos->Y;
1817 req->mode = CHAR_INFO_MODE_TEXTSTDATTR;
1818 req->wrap = FALSE;
1819 wine_server_add_data( req, lpBuffer, nc * sizeof(WCHAR) );
1820 if (!wine_server_call_err( req )) written = reply->written;
1821 }
1822 SERVER_END_REQ;
1823
1824 if (written > 0) pos->X += written;
1825 return written;
1826 }
1827
1828 /******************************************************************
1829 * next_line
1830 *
1831 * WriteConsoleOutput helper: handles passing to next line (+scrolling if necessary)
1832 *
1833 */
1834 static int next_line(HANDLE hCon, CONSOLE_SCREEN_BUFFER_INFO* csbi)
1835 {
1836 SMALL_RECT src;
1837 CHAR_INFO ci;
1838 COORD dst;
1839
1840 csbi->dwCursorPosition.X = 0;
1841 csbi->dwCursorPosition.Y++;
1842
1843 if (csbi->dwCursorPosition.Y < csbi->dwSize.Y) return 1;
1844
1845 src.Top = 1;
1846 src.Bottom = csbi->dwSize.Y - 1;
1847 src.Left = 0;
1848 src.Right = csbi->dwSize.X - 1;
1849
1850 dst.X = 0;
1851 dst.Y = 0;
1852
1853 ci.Attributes = csbi->wAttributes;
1854 ci.Char.UnicodeChar = ' ';
1855
1856 csbi->dwCursorPosition.Y--;
1857 if (!ScrollConsoleScreenBufferW(hCon, &src, NULL, dst, &ci))
1858 return 0;
1859 return 1;
1860 }
1861
1862 /******************************************************************
1863 * write_block
1864 *
1865 * WriteConsoleOutput helper: writes a block of non special characters
1866 * Block can spread on several lines, and wrapping, if needed, is
1867 * handled
1868 *
1869 */
1870 static int write_block(HANDLE hCon, CONSOLE_SCREEN_BUFFER_INFO* csbi,
1871 DWORD mode, LPCWSTR ptr, int len)
1872 {
1873 int blk; /* number of chars to write on current line */
1874 int done; /* number of chars already written */
1875
1876 if (len <= 0) return 1;
1877
1878 if (mode & ENABLE_WRAP_AT_EOL_OUTPUT) /* writes remaining on next line */
1879 {
1880 for (done = 0; done < len; done += blk)
1881 {
1882 blk = min(len - done, csbi->dwSize.X - csbi->dwCursorPosition.X);
1883
1884 if (CONSOLE_WriteChars(hCon, ptr + done, blk, &csbi->dwCursorPosition) != blk)
1885 return 0;
1886 if (csbi->dwCursorPosition.X == csbi->dwSize.X && !next_line(hCon, csbi))
1887 return 0;
1888 }
1889 }
1890 else
1891 {
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,
1896 * which is unlikely
1897 */
1898 for (blk = done = 0; done < len; done += blk)
1899 {
1900 blk = min(len - done, csbi->dwSize.X - csbi->dwCursorPosition.X);
1901
1902 csbi->dwCursorPosition.X = pos;
1903 if (CONSOLE_WriteChars(hCon, ptr + done, blk, &csbi->dwCursorPosition) != blk)
1904 return 0;
1905 }
1906 }
1907
1908 return 1;
1909 }
1910
1911 /***********************************************************************
1912 * WriteConsoleW (KERNEL32.@)
1913 */
1914 BOOL WINAPI WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite,
1915 LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved)
1916 {
1917 DWORD mode;
1918 DWORD nw = 0;
1919 const WCHAR* psz = lpBuffer;
1920 CONSOLE_SCREEN_BUFFER_INFO csbi;
1921 int k, first = 0;
1922
1923 TRACE("%p %s %ld %p %p\n",
1924 hConsoleOutput, debugstr_wn(lpBuffer, nNumberOfCharsToWrite),
1925 nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved);
1926
1927 if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = 0;
1928
1929 if (!GetConsoleMode(hConsoleOutput, &mode) ||
1930 !GetConsoleScreenBufferInfo(hConsoleOutput, &csbi))
1931 return FALSE;
1932
1933 if (mode & ENABLE_PROCESSED_OUTPUT)
1934 {
1935 unsigned int i;
1936
1937 for (i = 0; i < nNumberOfCharsToWrite; i++)
1938 {
1939 switch (psz[i])
1940 {
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)
1944 {
1945 if (!write_block(hConsoleOutput, &csbi, mode, &psz[first], k))
1946 goto the_end;
1947 nw += k;
1948 }
1949 first = i + 1;
1950 nw++;
1951 }
1952 switch (psz[i])
1953 {
1954 case '\b':
1955 if (csbi.dwCursorPosition.X > 0) csbi.dwCursorPosition.X--;
1956 break;
1957 case '\t':
1958 {
1959 WCHAR tmp[8] = {' ',' ',' ',' ',' ',' ',' ',' '};
1960
1961 if (!write_block(hConsoleOutput, &csbi, mode, tmp,
1962 ((csbi.dwCursorPosition.X + 8) & ~7) - csbi.dwCursorPosition.X))
1963 goto the_end;
1964 }
1965 break;
1966 case '\n':
1967 next_line(hConsoleOutput, &csbi);
1968 break;
1969 case '\a':
1970 Beep(400, 300);
1971 break;
1972 case '\r':
1973 csbi.dwCursorPosition.X = 0;
1974 break;
1975 default:
1976 break;
1977 }
1978 }
1979 }
1980
1981 /* write the remaining block (if any) if processed output is enabled, or the
1982 * entire buffer otherwise
1983 */
1984 if ((k = nNumberOfCharsToWrite - first) > 0)
1985 {
1986 if (!write_block(hConsoleOutput, &csbi, mode, &psz[first], k))
1987 goto the_end;
1988 nw += k;
1989 }
1990
1991 the_end:
1992 SetConsoleCursorPosition(hConsoleOutput, csbi.dwCursorPosition);
1993 if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = nw;
1994 return nw != 0;
1995 }
1996
1997
1998 /***********************************************************************
1999 * WriteConsoleA (KERNEL32.@)
2000 */
2001 BOOL WINAPI WriteConsoleA(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite,
2002 LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved)
2003 {
2004 BOOL ret;
2005 LPWSTR xstring;
2006 DWORD n;
2007
2008 n = MultiByteToWideChar(CP_ACP, 0, lpBuffer, nNumberOfCharsToWrite, NULL, 0);
2009
2010 if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = 0;
2011 xstring = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
2012 if (!xstring) return 0;
2013
2014 MultiByteToWideChar(CP_ACP, 0, lpBuffer, nNumberOfCharsToWrite, xstring, n);
2015
2016 ret = WriteConsoleW(hConsoleOutput, xstring, n, lpNumberOfCharsWritten, 0);
2017
2018 HeapFree(GetProcessHeap(), 0, xstring);
2019
2020 return ret;
2021 }
2022
2023 /******************************************************************************
2024 * SetConsoleCursorPosition [KERNEL32.@]
2025 * Sets the cursor position in console
2026 *
2027 * PARAMS
2028 * hConsoleOutput [I] Handle of console screen buffer
2029 * dwCursorPosition [I] New cursor position coordinates
2030 *
2031 * RETURNS STD
2032 */
2033 BOOL WINAPI SetConsoleCursorPosition(HANDLE hcon, COORD pos)
2034 {
2035 BOOL ret;
2036 CONSOLE_SCREEN_BUFFER_INFO csbi;
2037 int do_move = 0;
2038 int w, h;
2039
2040 TRACE("%p %d %d\n", hcon, pos.X, pos.Y);
2041
2042 SERVER_START_REQ(set_console_output_info)
2043 {
2044 req->handle = console_handle_unmap(hcon);
2045 req->cursor_x = pos.X;
2046 req->cursor_y = pos.Y;
2047 req->mask = SET_CONSOLE_OUTPUT_INFO_CURSOR_POS;
2048 ret = !wine_server_call_err( req );
2049 }
2050 SERVER_END_REQ;
2051
2052 if (!ret || !GetConsoleScreenBufferInfo(hcon, &csbi))
2053 return FALSE;
2054
2055 /* if cursor is no longer visible, scroll the visible window... */
2056 w = csbi.srWindow.Right - csbi.srWindow.Left + 1;
2057 h = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
2058 if (pos.X < csbi.srWindow.Left)
2059 {
2060 csbi.srWindow.Left = min(pos.X, csbi.dwSize.X - w);
2061 do_move++;
2062 }
2063 else if (pos.X > csbi.srWindow.Right)
2064 {
2065 csbi.srWindow.Left = max(pos.X, w) - w + 1;
2066 do_move++;
2067 }
2068 csbi.srWindow.Right = csbi.srWindow.Left + w - 1;
2069
2070 if (pos.Y < csbi.srWindow.Top)
2071 {
2072 csbi.srWindow.Top = min(pos.Y, csbi.dwSize.Y - h);
2073 do_move++;
2074 }
2075 else if (pos.Y > csbi.srWindow.Bottom)
2076 {
2077 csbi.srWindow.Top = max(pos.Y, h) - h + 1;
2078 do_move++;
2079 }
2080 csbi.srWindow.Bottom = csbi.srWindow.Top + h - 1;
2081
2082 ret = (do_move) ? SetConsoleWindowInfo(hcon, TRUE, &csbi.srWindow) : TRUE;
2083
2084 return ret;
2085 }
2086
2087 /******************************************************************************
2088 * GetConsoleCursorInfo [KERNEL32.@] Gets size and visibility of console
2089 *
2090 * PARAMS
2091 * hcon [I] Handle to console screen buffer
2092 * cinfo [O] Address of cursor information
2093 *
2094 * RETURNS
2095 * Success: TRUE
2096 * Failure: FALSE
2097 */
2098 BOOL WINAPI GetConsoleCursorInfo(HANDLE hCon, LPCONSOLE_CURSOR_INFO cinfo)
2099 {
2100 BOOL ret;
2101
2102 SERVER_START_REQ(get_console_output_info)
2103 {
2104 req->handle = console_handle_unmap(hCon);
2105 ret = !wine_server_call_err( req );
2106 if (ret && cinfo)
2107 {
2108 cinfo->dwSize = reply->cursor_size;
2109 cinfo->bVisible = reply->cursor_visible;
2110 }
2111 }
2112 SERVER_END_REQ;
2113
2114 TRACE("(%p) returning (%ld,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
2115 return ret;
2116 }
2117
2118
2119 /******************************************************************************
2120 * SetConsoleCursorInfo [KERNEL32.@] Sets size and visibility of cursor
2121 *
2122 * PARAMS
2123 * hcon [I] Handle to console screen buffer
2124 * cinfo [I] Address of cursor information
2125 * RETURNS
2126 * Success: TRUE
2127 * Failure: FALSE
2128 */
2129 BOOL WINAPI SetConsoleCursorInfo(HANDLE hCon, LPCONSOLE_CURSOR_INFO cinfo)
2130 {
2131 BOOL ret;
2132
2133 TRACE("(%p,%ld,%d)\n", hCon, cinfo->dwSize, cinfo->bVisible);
2134 SERVER_START_REQ(set_console_output_info)
2135 {
2136 req->handle = console_handle_unmap(hCon);
2137 req->cursor_size = cinfo->dwSize;
2138 req->cursor_visible = cinfo->bVisible;
2139 req->mask = SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM;
2140 ret = !wine_server_call_err( req );
2141 }
2142 SERVER_END_REQ;
2143 return ret;
2144 }
2145
2146
2147 /******************************************************************************
2148 * SetConsoleWindowInfo [KERNEL32.@] Sets size and position of console
2149 *
2150 * PARAMS
2151 * hcon [I] Handle to console screen buffer
2152 * bAbsolute [I] Coordinate type flag
2153 * window [I] Address of new window rectangle
2154 * RETURNS
2155 * Success: TRUE
2156 * Failure: FALSE
2157 */
2158 BOOL WINAPI SetConsoleWindowInfo(HANDLE hCon, BOOL bAbsolute, LPSMALL_RECT window)
2159 {
2160 SMALL_RECT p = *window;
2161 BOOL ret;
2162
2163 TRACE("(%p,%d,(%d,%d-%d,%d))\n", hCon, bAbsolute, p.Left, p.Top, p.Right, p.Bottom);
2164
2165 if (!bAbsolute)
2166 {
2167 CONSOLE_SCREEN_BUFFER_INFO csbi;
2168
2169 if (!GetConsoleScreenBufferInfo(hCon, &csbi))
2170 return FALSE;
2171 p.Left += csbi.srWindow.Left;
2172 p.Top += csbi.srWindow.Top;
2173 p.Right += csbi.srWindow.Right;
2174 p.Bottom += csbi.srWindow.Bottom;
2175 }
2176 SERVER_START_REQ(set_console_output_info)
2177 {
2178 req->handle = console_handle_unmap(hCon);
2179 req->win_left = p.Left;
2180 req->win_top = p.Top;
2181 req->win_right = p.Right;
2182 req->win_bottom = p.Bottom;
2183 req->mask = SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW;
2184 ret = !wine_server_call_err( req );
2185 }
2186 SERVER_END_REQ;
2187
2188 return ret;
2189 }
2190
2191
2192 /******************************************************************************
2193 * SetConsoleTextAttribute [KERNEL32.@] Sets colors for text
2194 *
2195 * Sets the foreground and background color attributes of characters
2196 * written to the screen buffer.
2197 *
2198 * RETURNS
2199 * Success: TRUE
2200 * Failure: FALSE
2201 */
2202 BOOL WINAPI SetConsoleTextAttribute(HANDLE hConsoleOutput, WORD wAttr)
2203 {
2204 BOOL ret;
2205
2206 TRACE("(%p,%d)\n", hConsoleOutput, wAttr);
2207 SERVER_START_REQ(set_console_output_info)
2208 {
2209 req->handle = console_handle_unmap(hConsoleOutput);
2210 req->attr = wAttr;
2211 req->mask = SET_CONSOLE_OUTPUT_INFO_ATTR;
2212 ret = !wine_server_call_err( req );
2213 }
2214 SERVER_END_REQ;
2215 return ret;
2216 }
2217
2218
2219 /******************************************************************************
2220 * SetConsoleScreenBufferSize [KERNEL32.@] Changes size of console
2221 *
2222 * PARAMS
2223 * hConsoleOutput [I] Handle to console screen buffer
2224 * dwSize [I] New size in character rows and cols
2225 *
2226 * RETURNS
2227 * Success: TRUE
2228 * Failure: FALSE
2229 */
2230 BOOL WINAPI SetConsoleScreenBufferSize(HANDLE hConsoleOutput, COORD dwSize)
2231 {
2232 BOOL ret;
2233
2234 TRACE("(%p,(%d,%d))\n", hConsoleOutput, dwSize.X, dwSize.Y);
2235 SERVER_START_REQ(set_console_output_info)
2236 {
2237 req->handle = console_handle_unmap(hConsoleOutput);
2238 req->width = dwSize.X;
2239 req->height = dwSize.Y;
2240 req->mask = SET_CONSOLE_OUTPUT_INFO_SIZE;
2241 ret = !wine_server_call_err( req );
2242 }
2243 SERVER_END_REQ;
2244 return ret;
2245 }
2246
2247
2248 /******************************************************************************
2249 * ScrollConsoleScreenBufferA [KERNEL32.@]
2250 *
2251 */
2252 BOOL WINAPI ScrollConsoleScreenBufferA(HANDLE hConsoleOutput, LPSMALL_RECT lpScrollRect,
2253 LPSMALL_RECT lpClipRect, COORD dwDestOrigin,
2254 LPCHAR_INFO lpFill)
2255 {
2256 CHAR_INFO ciw;
2257
2258 ciw.Attributes = lpFill->Attributes;
2259 MultiByteToWideChar(CP_ACP, 0, &lpFill->Char.AsciiChar, 1, &ciw.Char.UnicodeChar, 1);
2260
2261 return ScrollConsoleScreenBufferW(hConsoleOutput, lpScrollRect, lpClipRect,
2262 dwDestOrigin, &ciw);
2263 }
2264
2265 /******************************************************************
2266 * CONSOLE_FillLineUniform
2267 *
2268 * Helper function for ScrollConsoleScreenBufferW
2269 * Fills a part of a line with a constant character info
2270 */
2271 void CONSOLE_FillLineUniform(HANDLE hConsoleOutput, int i, int j, int len, LPCHAR_INFO lpFill)
2272 {
2273 SERVER_START_REQ( fill_console_output )
2274 {
2275 req->handle = console_handle_unmap(hConsoleOutput);
2276 req->mode = CHAR_INFO_MODE_TEXTATTR;
2277 req->x = i;
2278 req->y = j;
2279 req->count = len;
2280 req->wrap = FALSE;
2281 req->data.ch = lpFill->Char.UnicodeChar;
2282 req->data.attr = lpFill->Attributes;
2283 wine_server_call_err( req );
2284 }
2285 SERVER_END_REQ;
2286 }
2287
2288 /******************************************************************************
2289 * ScrollConsoleScreenBufferW [KERNEL32.@]
2290 *
2291 */
2292
2293 BOOL WINAPI ScrollConsoleScreenBufferW(HANDLE hConsoleOutput, LPSMALL_RECT lpScrollRect,
2294 LPSMALL_RECT lpClipRect, COORD dwDestOrigin,
2295 LPCHAR_INFO lpFill)
2296 {
2297 SMALL_RECT dst;
2298 DWORD ret;
2299 int i, j;
2300 int start = -1;
2301 SMALL_RECT clip;
2302 CONSOLE_SCREEN_BUFFER_INFO csbi;
2303 BOOL inside;
2304 COORD src;
2305
2306 if (lpClipRect)
2307 TRACE("(%p,(%d,%d-%d,%d),(%d,%d-%d,%d),%d-%d,%p)\n", hConsoleOutput,
2308 lpScrollRect->Left, lpScrollRect->Top,
2309 lpScrollRect->Right, lpScrollRect->Bottom,
2310 lpClipRect->Left, lpClipRect->Top,
2311 lpClipRect->Right, lpClipRect->Bottom,
2312 dwDestOrigin.X, dwDestOrigin.Y, lpFill);
2313 else
2314 TRACE("(%p,(%d,%d-%d,%d),(nil),%d-%d,%p)\n", hConsoleOutput,
2315 lpScrollRect->Left, lpScrollRect->Top,
2316 lpScrollRect->Right, lpScrollRect->Bottom,
2317 dwDestOrigin.X, dwDestOrigin.Y, lpFill);
2318
2319 if (!GetConsoleScreenBufferInfo(hConsoleOutput, &csbi))
2320 return FALSE;
2321
2322 src.X = lpScrollRect->Left;
2323 src.Y = lpScrollRect->Top;
2324
2325 /* step 1: get dst rect */
2326 dst.Left = dwDestOrigin.X;
2327 dst.Top = dwDestOrigin.Y;
2328 dst.Right = dst.Left + (lpScrollRect->Right - lpScrollRect->Left);
2329 dst.Bottom = dst.Top + (lpScrollRect->Bottom - lpScrollRect->Top);
2330
2331 /* step 2a: compute the final clip rect (optional passed clip and screen buffer limits */
2332 if (lpClipRect)
2333 {
2334 clip.Left = max(0, lpClipRect->Left);
2335 clip.Right = min(csbi.dwSize.X - 1, lpClipRect->Right);
2336 clip.Top = max(0, lpClipRect->Top);
2337 clip.Bottom = min(csbi.dwSize.Y - 1, lpClipRect->Bottom);
2338 }
2339 else
2340 {
2341 clip.Left = 0;
2342 clip.Right = csbi.dwSize.X - 1;
2343 clip.Top = 0;
2344 clip.Bottom = csbi.dwSize.Y - 1;
2345 }
2346 if (clip.Left > clip.Right || clip.Top > clip.Bottom) return FALSE;
2347
2348 /* step 2b: clip dst rect */
2349 if (dst.Left < clip.Left ) {src.X += clip.Left - dst.Left; dst.Left = clip.Left;}
2350 if (dst.Top < clip.Top ) {src.Y += clip.Top - dst.Top; dst.Top = clip.Top;}
2351 if (dst.Right > clip.Right ) dst.Right = clip.Right;
2352 if (dst.Bottom > clip.Bottom) dst.Bottom = clip.Bottom;
2353
2354 /* step 3: transfer the bits */
2355 SERVER_START_REQ(move_console_output)
2356 {
2357 req->handle = console_handle_unmap(hConsoleOutput);
2358 req->x_src = src.X;
2359 req->y_src = src.Y;
2360 req->x_dst = dst.Left;
2361 req->y_dst = dst.Top;
2362 req->w = dst.Right - dst.Left + 1;
2363 req->h = dst.Bottom - dst.Top + 1;
2364 ret = !wine_server_call_err( req );
2365 }
2366 SERVER_END_REQ;
2367
2368 if (!ret) return FALSE;
2369
2370 /* step 4: clean out the exposed part */
2371
2372 /* have to write cell [i,j] if it is not in dst rect (because it has already
2373 * been written to by the scroll) and is in clip (we shall not write
2374 * outside of clip)
2375 */
2376 for (j = max(lpScrollRect->Top, clip.Top); j <= min(lpScrollRect->Bottom, clip.Bottom); j++)
2377 {
2378 inside = dst.Top <= j && j <= dst.Bottom;
2379 start = -1;
2380 for (i = max(lpScrollRect->Left, clip.Left); i <= min(lpScrollRect->Right, clip.Right); i++)
2381 {
2382 if (inside && dst.Left <= i && i <= dst.Right)
2383 {
2384 if (start != -1)
2385 {
2386 CONSOLE_FillLineUniform(hConsoleOutput, start, j, i - start, lpFill);
2387 start = -1;
2388 }
2389 }
2390 else
2391 {
2392 if (start == -1) start = i;
2393 }
2394 }
2395 if (start != -1)
2396 CONSOLE_FillLineUniform(hConsoleOutput, start, j, i - start, lpFill);
2397 }
2398
2399 return TRUE;
2400 }
2401
2402
2403 /* ====================================================================
2404 *
2405 * Console manipulation functions
2406 *
2407 * ====================================================================*/
2408
2409 /* some missing functions...
2410 * FIXME: those are likely to be defined as undocumented function in kernel32 (or part of them)
2411 * should get the right API and implement them
2412 * GetConsoleCommandHistory[AW] (dword dword dword)
2413 * GetConsoleCommandHistoryLength[AW]
2414 * SetConsoleCommandHistoryMode
2415 * SetConsoleNumberOfCommands[AW]
2416 */
2417 int CONSOLE_GetHistory(int idx, WCHAR* buf, int buf_len)
2418 {
2419 int len = 0;
2420
2421 SERVER_START_REQ( get_console_input_history )
2422 {
2423 req->handle = 0;
2424 req->index = idx;
2425 if (buf && buf_len > 1)
2426 {
2427 wine_server_set_reply( req, buf, (buf_len - 1) * sizeof(WCHAR) );
2428 }
2429 if (!wine_server_call_err( req ))
2430 {
2431 if (buf) buf[wine_server_reply_size(reply) / sizeof(WCHAR)] = 0;
2432 len = reply->total / sizeof(WCHAR) + 1;
2433 }
2434 }
2435 SERVER_END_REQ;
2436 return len;
2437 }
2438
2439 /******************************************************************
2440 * CONSOLE_AppendHistory
2441 *
2442 *
2443 */
2444 BOOL CONSOLE_AppendHistory(const WCHAR* ptr)
2445 {
2446 size_t len = strlenW(ptr);
2447 BOOL ret;
2448
2449 while (len && (ptr[len - 1] == '\n' || ptr[len - 1] == '\r')) len--;
2450
2451 SERVER_START_REQ( append_console_input_history )
2452 {
2453 req->handle = 0;
2454 wine_server_add_data( req, ptr, len * sizeof(WCHAR) );
2455 ret = !wine_server_call_err( req );
2456 }
2457 SERVER_END_REQ;
2458 return ret;
2459 }
2460
2461 /******************************************************************
2462 * CONSOLE_GetNumHistoryEntries
2463 *
2464 *
2465 */
2466 unsigned CONSOLE_GetNumHistoryEntries(void)
2467 {
2468 unsigned ret = -1;
2469 SERVER_START_REQ(get_console_input_info)
2470 {
2471 req->handle = 0;
2472 if (!wine_server_call_err( req )) ret = reply->history_index;
2473 }
2474 SERVER_END_REQ;
2475 return ret;
2476 }
2477
2478 /******************************************************************
2479 * CONSOLE_GetEditionMode
2480 *
2481 *
2482 */
2483 BOOL CONSOLE_GetEditionMode(HANDLE hConIn, int* mode)
2484 {
2485 unsigned ret = FALSE;
2486 SERVER_START_REQ(get_console_input_info)
2487 {
2488 req->handle = console_handle_unmap(hConIn);
2489 if ((ret = !wine_server_call_err( req )))
2490 *mode = reply->edition_mode;
2491 }
2492 SERVER_END_REQ;
2493 return ret;
2494 }
GSOC 2012 project to enhance the control panel