git.oblomov.eu Git - wine/blob - dlls/kernel/console.c

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