reactos/lib/kernel32/misc/console.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/kernel32/misc/console.c
   5  * PURPOSE:         Win32 server console functions
   6  * PROGRAMMER:      ???
   7  * UPDATE HISTORY:
   8  *      199901?? ??     Created
   9  *      19990204 EA     SetConsoleTitleA
  10  *      19990306 EA     Stubs
  11  */
  12
  13 /* INCLUDES ******************************************************************/
  14
  15 #include <ddk/ntddk.h>
  16 #include <ddk/ntddblue.h>
  17 #include <windows.h>
  18 #include <assert.h>
  19 #include <wchar.h>
  20
  21 #include <csrss/csrss.h>
  22 #include <ntdll/csr.h>
  23
  24 #define NDEBUG
  25 #include <kernel32/kernel32.h>
  26
  27 /* FUNCTIONS *****************************************************************/
  28
  29 WINBOOL STDCALL CloseConsoleHandle(HANDLE Handle)
  30 {
  31 }
  32
  33 BOOLEAN IsConsoleHandle(HANDLE Handle)
  34 {
  35    if ((((ULONG)Handle) & 0x10000003) == 0x3)
  36      {
  37         return(TRUE);
  38      }
  39    return(FALSE);
  40 }
  41
  42
  43 /*--------------------------------------------------------------
  44  *      GetStdHandle
  45  */
  46 HANDLE STDCALL GetStdHandle(DWORD nStdHandle)
  47 {
  48    PRTL_USER_PROCESS_PARAMETERS Ppb;
  49
  50 //   DbgPrint("GetStdHandle(nStdHandle %d)\n",nStdHandle);
  51
  52    SetLastError(ERROR_SUCCESS); /* OK */
  53 //   DbgPrint("NtCurrentPeb() %x\n", NtCurrentPeb());
  54    Ppb = NtCurrentPeb()->ProcessParameters;
  55 //   DbgPrint("Ppb %x\n", Ppb);
  56 //   DbgPrint("Ppb->OutputHandle %x\n", Ppb->OutputHandle);
  57    switch (nStdHandle)
  58      {
  59       case STD_INPUT_HANDLE:    return Ppb->InputHandle;
  60       case STD_OUTPUT_HANDLE:   return Ppb->OutputHandle;
  61       case STD_ERROR_HANDLE:    return Ppb->ErrorHandle;
  62      }
  63    SetLastError( ERROR_INVALID_PARAMETER );
  64    return INVALID_HANDLE_VALUE;
  65 }
  66
  67
  68 /*--------------------------------------------------------------
  69  *      SetStdHandle
  70  */
  71 WINBASEAPI BOOL WINAPI SetStdHandle(DWORD nStdHandle,
  72                                     HANDLE hHandle)
  73 {
  74    PRTL_USER_PROCESS_PARAMETERS Ppb;
  75
  76    Ppb = NtCurrentPeb()->ProcessParameters;
  77
  78    /* More checking needed? */
  79    if (hHandle == INVALID_HANDLE_VALUE)
  80      {
  81         SetLastError( ERROR_INVALID_HANDLE );
  82         return FALSE;
  83      }
  84
  85    SetLastError(ERROR_SUCCESS); /* OK */
  86    switch (nStdHandle)
  87      {
  88       case STD_INPUT_HANDLE:
  89         Ppb->InputHandle = hHandle;
  90         return TRUE;
  91       case STD_OUTPUT_HANDLE:
  92         Ppb->OutputHandle = hHandle;
  93         return TRUE;
  94       case STD_ERROR_HANDLE:
  95         Ppb->ErrorHandle = hHandle;
  96         return TRUE;
  97      }
  98    SetLastError( ERROR_INVALID_PARAMETER );
  99    return FALSE;
 100 }
 101
 102
 103 /*--------------------------------------------------------------
 104  *      WriteConsoleA
 105  */
 106 WINBOOL STDCALL WriteConsoleA(HANDLE hConsoleOutput,
 107                               CONST VOID *lpBuffer,
 108                               DWORD nNumberOfCharsToWrite,
 109                               LPDWORD lpNumberOfCharsWritten,
 110                               LPVOID lpReserved)
 111 {
 112    PCSRSS_API_REQUEST Request;
 113    CSRSS_API_REPLY Reply;
 114    NTSTATUS Status;
 115
 116    Request = HeapAlloc(GetProcessHeap(),
 117                        HEAP_ZERO_MEMORY,
 118                        sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite);
 119    if (Request == NULL)
 120      {
 121         return(FALSE);
 122      }
 123
 124    Request->Type = CSRSS_WRITE_CONSOLE;
 125    Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
 126    Request->Data.WriteConsoleRequest.NrCharactersToWrite =
 127      nNumberOfCharsToWrite;
 128
 129 //   DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
 130 //   DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
 131
 132    memcpy(Request->Data.WriteConsoleRequest.Buffer,
 133           lpBuffer,
 134           nNumberOfCharsToWrite);
 135
 136    Status = CsrClientCallServer(Request,
 137                                 &Reply,
 138                                 sizeof(CSRSS_API_REQUEST) +
 139                                 nNumberOfCharsToWrite,
 140                                 sizeof(CSRSS_API_REPLY));
 141
 142    HeapFree(GetProcessHeap(),
 143             0,
 144             Request);
 145
 146    if (!NT_SUCCESS(Status))
 147      {
 148         return(FALSE);
 149      }
 150
 151    if (lpNumberOfCharsWritten != NULL)
 152      {
 153         *lpNumberOfCharsWritten =
 154           Reply.Data.WriteConsoleReply.NrCharactersWritten;
 155      }
 156
 157    return(TRUE);
 158 }
 159
 160
 161 /*--------------------------------------------------------------
 162  *      ReadConsoleA
 163  */
 164 WINBOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
 165                              LPVOID lpBuffer,
 166                              DWORD nNumberOfCharsToRead,
 167                              LPDWORD lpNumberOfCharsRead,
 168                              LPVOID lpReserved)
 169 {
 170    CSRSS_API_REQUEST Request;
 171    PCSRSS_API_REPLY Reply;
 172    NTSTATUS Status;
 173
 174    Reply = HeapAlloc(GetProcessHeap(),
 175                      HEAP_ZERO_MEMORY,
 176                      sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
 177    if (Reply == NULL)
 178      {
 179         return(FALSE);
 180      }
 181
 182    Request.Type = CSRSS_READ_CONSOLE;
 183    Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
 184    Request.Data.ReadConsoleRequest.NrCharactersToRead =
 185      nNumberOfCharsToRead;
 186
 187    Status = CsrClientCallServer(&Request,
 188                                 Reply,
 189                                 sizeof(CSRSS_API_REQUEST),
 190                                 sizeof(CSRSS_API_REPLY) +
 191                                 nNumberOfCharsToRead);
 192    //   DbgPrint( "Csrss Returned\n" );
 193    if (!NT_SUCCESS(Status) || !NT_SUCCESS(Reply->Status))
 194      {
 195         DbgPrint( "CSR returned error in ReadConsole\n" );
 196         HeapFree( GetProcessHeap(), 0, Reply );
 197         return(FALSE);
 198      }
 199    if( Reply->Status == STATUS_PENDING )
 200      {
 201        //DbgPrint( "Read pending, waiting on object %x\n", Reply->Data.ReadConsoleReply.EventHandle );
 202        Status = NtWaitForSingleObject( Reply->Data.ReadConsoleReply.EventHandle, FALSE, 0 );
 203        if( !NT_SUCCESS( Status ) )
 204          {
 205            DbgPrint( "Wait for console input failed!\n" );
 206            HeapFree( GetProcessHeap(), 0, Reply );
 207            return FALSE;
 208          }
 209        Status = CsrClientCallServer( &Request, Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) + nNumberOfCharsToRead );
 210        if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Reply->Status ) )
 211          {
 212            SetLastError( RtlNtStatusToDosError( Reply->Status ) );
 213            HeapFree( GetProcessHeap(), 0, Reply );
 214            return FALSE;
 215          }
 216      }
 217    if (lpNumberOfCharsRead != NULL)
 218      {
 219         *lpNumberOfCharsRead =
 220           Reply->Data.ReadConsoleReply.NrCharactersRead;
 221      }
 222    memcpy(lpBuffer,
 223           Reply->Data.ReadConsoleReply.Buffer,
 224           Reply->Data.ReadConsoleReply.NrCharactersRead);
 225    HeapFree(GetProcessHeap(),
 226             0,
 227             Reply);
 228
 229    return(TRUE);
 230 }
 231
 232
 233 /*--------------------------------------------------------------
 234  *      AllocConsole
 235  */
 236 WINBOOL STDCALL AllocConsole(VOID)
 237 {
 238    CSRSS_API_REQUEST Request;
 239    CSRSS_API_REPLY Reply;
 240    NTSTATUS Status;
 241
 242    Request.Type = CSRSS_ALLOC_CONSOLE;
 243    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
 244    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Reply.Status ) )
 245      return FALSE;
 246    SetStdHandle( STD_INPUT_HANDLE, Reply.Data.AllocConsoleReply.ConsoleHandle );
 247    SetStdHandle( STD_OUTPUT_HANDLE, Reply.Data.AllocConsoleReply.ConsoleHandle );
 248    SetStdHandle( STD_ERROR_HANDLE, Reply.Data.AllocConsoleReply.ConsoleHandle );
 249    return TRUE;
 250 }
 251
 252
 253 /*--------------------------------------------------------------
 254  *      FreeConsole
 255  */
 256 WINBOOL STDCALL FreeConsole(VOID)
 257 {
 258    DbgPrint("FreeConsole() is unimplemented");
 259 }
 260
 261
 262 /*--------------------------------------------------------------
 263  *      GetConsoleScreenBufferInfo
 264  */
 265 WINBOOL
 266 STDCALL
 267 GetConsoleScreenBufferInfo(
 268     HANDLE hConsoleOutput,
 269     PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
 270     )
 271 {
 272         DWORD   dwBytesReturned;
 273
 274         if ( !DeviceIoControl(
 275                 hConsoleOutput,
 276                 IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO,
 277                 NULL,
 278                 0,
 279                 lpConsoleScreenBufferInfo,
 280                 sizeof(CONSOLE_SCREEN_BUFFER_INFO),
 281                 & dwBytesReturned,
 282                 NULL
 283                 )
 284         )
 285         {
 286                 SetLastError(0); /* FIXME: What error code? */
 287                 return FALSE;
 288         }
 289         SetLastError(ERROR_SUCCESS); /* OK */
 290         return TRUE;
 291 }
 292
 293
 294 /*--------------------------------------------------------------
 295  *      SetConsoleCursorPosition
 296  */
 297 WINBOOL
 298 STDCALL
 299 SetConsoleCursorPosition(
 300     HANDLE hConsoleOutput,
 301     COORD dwCursorPosition
 302     )
 303 {
 304         DWORD dwBytesReturned;
 305         CONSOLE_SCREEN_BUFFER_INFO ConsoleScreenBufferInfo;
 306
 307         if( !GetConsoleScreenBufferInfo(hConsoleOutput,&ConsoleScreenBufferInfo) )
 308         {
 309                 SetLastError(0); /* FIXME: What error code? */
 310                 return FALSE;
 311         }
 312         ConsoleScreenBufferInfo.dwCursorPosition.X = dwCursorPosition.X;
 313         ConsoleScreenBufferInfo.dwCursorPosition.Y = dwCursorPosition.Y;
 314
 315         if( !DeviceIoControl(
 316                         hConsoleOutput,
 317                         IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO,
 318                         &ConsoleScreenBufferInfo,
 319                         sizeof(CONSOLE_SCREEN_BUFFER_INFO),
 320                         NULL,
 321                         0,
 322                         &dwBytesReturned,
 323                         NULL ))
 324                 return FALSE;
 325
 326         return TRUE;
 327 }
 328
 329
 330 /*--------------------------------------------------------------
 331  *      FillConsoleOutputCharacterA
 332  */
 333 WINBOOL
 334 STDCALL
 335 FillConsoleOutputCharacterA(
 336         HANDLE          hConsoleOutput,
 337         CHAR            cCharacter,
 338         DWORD           nLength,
 339         COORD           dwWriteCoord,
 340         LPDWORD         lpNumberOfCharsWritten
 341         )
 342 {
 343     DWORD dwBytesReturned;
 344     OUTPUT_CHARACTER Buffer;
 345
 346     Buffer.cCharacter = cCharacter;
 347     Buffer.nLength    = nLength;
 348     Buffer.dwCoord    = dwWriteCoord;
 349
 350     if (DeviceIoControl (hConsoleOutput,
 351                          IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER,
 352                          &Buffer,
 353                          sizeof(OUTPUT_CHARACTER),
 354                          &Buffer,
 355                          sizeof(OUTPUT_CHARACTER),
 356                          &dwBytesReturned,
 357                          NULL))
 358     {
 359         *lpNumberOfCharsWritten = Buffer.dwTransfered;
 360         return TRUE;
 361     }
 362
 363     *lpNumberOfCharsWritten = 0;
 364     return FALSE;
 365 }
 366
 367
 368 /*--------------------------------------------------------------
 369  *      FillConsoleOutputCharacterW
 370  */
 371 WINBOOL
 372 STDCALL
 373 FillConsoleOutputCharacterW(
 374         HANDLE          hConsoleOutput,
 375         WCHAR           cCharacter,
 376         DWORD           nLength,
 377         COORD           dwWriteCoord,
 378         LPDWORD         lpNumberOfCharsWritten
 379         )
 380 {
 381 /* TO DO */
 382         return FALSE;
 383 }
 384
 385
 386 /*--------------------------------------------------------------
 387  *      PeekConsoleInputA
 388  */
 389 WINBASEAPI
 390 BOOL
 391 WINAPI
 392 PeekConsoleInputA(
 393         HANDLE                  hConsoleInput,
 394         PINPUT_RECORD           lpBuffer,
 395         DWORD                   nLength,
 396         LPDWORD                 lpNumberOfEventsRead
 397         )
 398 {
 399 /* TO DO */
 400         return FALSE;
 401 }
 402
 403
 404 /*--------------------------------------------------------------
 405  *      PeekConsoleInputW
 406  */
 407 WINBASEAPI
 408 BOOL
 409 WINAPI
 410 PeekConsoleInputW(
 411         HANDLE                  hConsoleInput,
 412         PINPUT_RECORD           lpBuffer,
 413         DWORD                   nLength,
 414         LPDWORD                 lpNumberOfEventsRead
 415         )
 416 {
 417 /* TO DO */
 418         return FALSE;
 419 }
 420
 421
 422 /*--------------------------------------------------------------
 423  *      ReadConsoleInputA
 424  */
 425 WINBASEAPI
 426 BOOL
 427 WINAPI
 428 ReadConsoleInputA(
 429         HANDLE                  hConsoleInput,
 430         PINPUT_RECORD           lpBuffer,
 431         DWORD                   nLength,
 432         LPDWORD                 lpNumberOfEventsRead
 433         )
 434 {
 435    BOOL  stat = TRUE;
 436    DWORD Result;
 437    int i;
 438
 439    for (i=0; (stat && i < nLength);)
 440      {
 441         stat = ReadFile(hConsoleInput,
 442                         &lpBuffer[i].Event.KeyEvent,
 443                         sizeof(KEY_EVENT_RECORD),
 444                         &Result,
 445                         NULL);
 446         if (stat)
 447           {
 448              lpBuffer[i].EventType = KEY_EVENT;
 449              i++;
 450           }
 451      }
 452    if (lpNumberOfEventsRead != NULL)
 453      {
 454         *lpNumberOfEventsRead = i;
 455      }
 456    return(stat);
 457 }
 458
 459
 460 /*--------------------------------------------------------------
 461  *      ReadConsoleInputW
 462  */
 463 WINBASEAPI
 464 BOOL
 465 WINAPI
 466 ReadConsoleInputW(
 467         HANDLE                  hConsoleInput,
 468         PINPUT_RECORD           lpBuffer,
 469         DWORD                   nLength,
 470         LPDWORD                 lpNumberOfEventsRead
 471         )
 472 {
 473 /* TO DO */
 474         return FALSE;
 475 }
 476
 477
 478 /*--------------------------------------------------------------
 479  *      WriteConsoleInputA
 480  */
 481 WINBASEAPI
 482 BOOL
 483 WINAPI
 484 WriteConsoleInputA(
 485         HANDLE                   hConsoleInput,
 486         CONST INPUT_RECORD      *lpBuffer,
 487         DWORD                    nLength,
 488         LPDWORD                  lpNumberOfEventsWritten
 489         )
 490 {
 491 /* TO DO */
 492         return FALSE;
 493 }
 494
 495
 496 /*--------------------------------------------------------------
 497  *      WriteConsoleInputW
 498  */
 499 WINBASEAPI
 500 BOOL
 501 WINAPI
 502 WriteConsoleInputW(
 503         HANDLE                   hConsoleInput,
 504         CONST INPUT_RECORD      *lpBuffer,
 505         DWORD                    nLength,
 506         LPDWORD                  lpNumberOfEventsWritten
 507         )
 508 {
 509 /* TO DO */
 510         return FALSE;
 511 }
 512
 513
 514 /*--------------------------------------------------------------
 515  *      ReadConsoleOutputA
 516  */
 517 WINBASEAPI
 518 BOOL
 519 WINAPI
 520 ReadConsoleOutputA(
 521         HANDLE          hConsoleOutput,
 522         PCHAR_INFO      lpBuffer,
 523         COORD           dwBufferSize,
 524         COORD           dwBufferCoord,
 525         PSMALL_RECT     lpReadRegion
 526         )
 527 {
 528 /* TO DO */
 529         return FALSE;
 530 }
 531
 532
 533 /*--------------------------------------------------------------
 534  *      ReadConsoleOutputW
 535  */
 536 WINBASEAPI
 537 BOOL
 538 WINAPI
 539 ReadConsoleOutputW(
 540         HANDLE          hConsoleOutput,
 541         PCHAR_INFO      lpBuffer,
 542         COORD           dwBufferSize,
 543         COORD           dwBufferCoord,
 544         PSMALL_RECT     lpReadRegion
 545         )
 546 {
 547 /* TO DO */
 548         return FALSE;
 549 }
 550
 551 /*--------------------------------------------------------------
 552  *      WriteConsoleOutputA
 553  */
 554 WINBASEAPI
 555 BOOL
 556 WINAPI
 557 WriteConsoleOutputA(
 558         HANDLE           hConsoleOutput,
 559         CONST CHAR_INFO *lpBuffer,
 560         COORD            dwBufferSize,
 561         COORD            dwBufferCoord,
 562         PSMALL_RECT      lpWriteRegion
 563         )
 564 {
 565 /* TO DO */
 566         return FALSE;
 567 }
 568
 569
 570 /*--------------------------------------------------------------
 571  *      WriteConsoleOutputW
 572  */
 573 WINBASEAPI
 574 BOOL
 575 WINAPI
 576 WriteConsoleOutputW(
 577         HANDLE           hConsoleOutput,
 578         CONST CHAR_INFO *lpBuffer,
 579         COORD            dwBufferSize,
 580         COORD            dwBufferCoord,
 581         PSMALL_RECT      lpWriteRegion
 582         )
 583 {
 584 /* TO DO */
 585         return FALSE;
 586 }
 587
 588
 589 /*--------------------------------------------------------------
 590  *      ReadConsoleOutputCharacterA
 591  */
 592 WINBASEAPI
 593 BOOL
 594 WINAPI
 595 ReadConsoleOutputCharacterA(
 596         HANDLE          hConsoleOutput,
 597         LPSTR           lpCharacter,
 598         DWORD           nLength,
 599         COORD           dwReadCoord,
 600         LPDWORD         lpNumberOfCharsRead
 601         )
 602 {
 603     DWORD dwBytesReturned;
 604     OUTPUT_CHARACTER Buffer;
 605
 606     Buffer.dwCoord    = dwReadCoord;
 607
 608     if (DeviceIoControl (hConsoleOutput,
 609                          IOCTL_CONSOLE_READ_OUTPUT_CHARACTER,
 610                          &Buffer,
 611                          sizeof(OUTPUT_CHARACTER),
 612                          lpCharacter,
 613                          nLength,
 614                          &dwBytesReturned,
 615                          NULL))
 616     {
 617         *lpNumberOfCharsRead = Buffer.dwTransfered;
 618         return TRUE;
 619     }
 620
 621     *lpNumberOfCharsRead = 0;
 622     return FALSE;
 623 }
 624
 625
 626 /*--------------------------------------------------------------
 627  *      ReadConsoleOutputCharacterW
 628  */
 629 WINBASEAPI
 630 BOOL
 631 WINAPI
 632 ReadConsoleOutputCharacterW(
 633         HANDLE          hConsoleOutput,
 634         LPWSTR          lpCharacter,
 635         DWORD           nLength,
 636         COORD           dwReadCoord,
 637         LPDWORD         lpNumberOfCharsRead
 638         )
 639 {
 640 /* TO DO */
 641         return FALSE;
 642 }
 643
 644
 645 /*--------------------------------------------------------------
 646  *      ReadConsoleOutputAttribute
 647  */
 648 WINBASEAPI
 649 BOOL
 650 WINAPI
 651 ReadConsoleOutputAttribute(
 652         HANDLE          hConsoleOutput,
 653         LPWORD          lpAttribute,
 654         DWORD           nLength,
 655         COORD           dwReadCoord,
 656         LPDWORD         lpNumberOfAttrsRead
 657         )
 658 {
 659     DWORD dwBytesReturned;
 660     OUTPUT_ATTRIBUTE Buffer;
 661
 662     Buffer.dwCoord = dwReadCoord;
 663
 664     if (DeviceIoControl (hConsoleOutput,
 665                          IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE,
 666                          &Buffer,
 667                          sizeof(OUTPUT_ATTRIBUTE),
 668                          (PVOID)lpAttribute,
 669                          nLength,
 670                          &dwBytesReturned,
 671                          NULL))
 672     {
 673         *lpNumberOfAttrsRead = Buffer.dwTransfered;
 674         return TRUE;
 675     }
 676
 677     *lpNumberOfAttrsRead = 0;
 678
 679     return FALSE;
 680 }
 681
 682
 683 /*--------------------------------------------------------------
 684  *      WriteConsoleOutputCharacterA
 685  */
 686 WINBASEAPI
 687 BOOL
 688 WINAPI
 689 WriteConsoleOutputCharacterA(
 690         HANDLE          hConsoleOutput,
 691         LPCSTR          lpCharacter,
 692         DWORD           nLength,
 693         COORD           dwWriteCoord,
 694         LPDWORD         lpNumberOfCharsWritten
 695         )
 696 {
 697     DWORD dwBytesReturned;
 698     OUTPUT_CHARACTER Buffer;
 699
 700     Buffer.dwCoord    = dwWriteCoord;
 701
 702     if (DeviceIoControl (hConsoleOutput,
 703                          IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER,
 704                          &Buffer,
 705                          sizeof(OUTPUT_CHARACTER),
 706                          (LPSTR)lpCharacter,
 707                          nLength,
 708                          &dwBytesReturned,
 709                          NULL))
 710     {
 711         *lpNumberOfCharsWritten = Buffer.dwTransfered;
 712         return TRUE;
 713     }
 714
 715     *lpNumberOfCharsWritten = 0;
 716     return FALSE;
 717 }
 718
 719
 720 /*--------------------------------------------------------------
 721  *      WriteConsoleOutputCharacterW
 722  */
 723 WINBASEAPI
 724 BOOL
 725 WINAPI
 726 WriteConsoleOutputCharacterW(
 727         HANDLE          hConsoleOutput,
 728         LPCWSTR         lpCharacter,
 729         DWORD           nLength,
 730         COORD           dwWriteCoord,
 731         LPDWORD         lpNumberOfCharsWritten
 732         )
 733 {
 734 /* TO DO */
 735         return FALSE;
 736 }
 737
 738
 739
 740 /*--------------------------------------------------------------
 741  *      WriteConsoleOutputAttribute
 742  */
 743 WINBASEAPI
 744 BOOL
 745 WINAPI
 746 WriteConsoleOutputAttribute(
 747         HANDLE           hConsoleOutput,
 748         CONST WORD      *lpAttribute,
 749         DWORD            nLength,
 750         COORD            dwWriteCoord,
 751         LPDWORD          lpNumberOfAttrsWritten
 752         )
 753 {
 754     DWORD dwBytesReturned;
 755     OUTPUT_ATTRIBUTE Buffer;
 756
 757     Buffer.dwCoord = dwWriteCoord;
 758
 759     if (DeviceIoControl (hConsoleOutput,
 760                          IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE,
 761                          &Buffer,
 762                          sizeof(OUTPUT_ATTRIBUTE),
 763                          (PVOID)lpAttribute,
 764                          nLength,
 765                          &dwBytesReturned,
 766                          NULL))
 767     {
 768         *lpNumberOfAttrsWritten = Buffer.dwTransfered;
 769         return TRUE;
 770     }
 771
 772     *lpNumberOfAttrsWritten = 0;
 773
 774     return FALSE;
 775 }
 776
 777
 778 /*--------------------------------------------------------------
 779  *      FillConsoleOutputAttribute
 780  */
 781 WINBASEAPI
 782 BOOL
 783 WINAPI
 784 FillConsoleOutputAttribute(
 785         HANDLE          hConsoleOutput,
 786         WORD            wAttribute,
 787         DWORD           nLength,
 788         COORD           dwWriteCoord,
 789         LPDWORD         lpNumberOfAttrsWritten
 790         )
 791 {
 792     DWORD dwBytesReturned;
 793     OUTPUT_ATTRIBUTE Buffer;
 794
 795     Buffer.wAttribute = wAttribute;
 796     Buffer.nLength    = nLength;
 797     Buffer.dwCoord    = dwWriteCoord;
 798
 799     if (DeviceIoControl (hConsoleOutput,
 800                          IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE,
 801                          &Buffer,
 802                          sizeof(OUTPUT_ATTRIBUTE),
 803                          &Buffer,
 804                          sizeof(OUTPUT_ATTRIBUTE),
 805                          &dwBytesReturned,
 806                          NULL))
 807     {
 808         *lpNumberOfAttrsWritten = Buffer.dwTransfered;
 809         return TRUE;
 810     }
 811
 812     *lpNumberOfAttrsWritten = 0;
 813
 814     return FALSE;
 815 }
 816
 817
 818 /*--------------------------------------------------------------
 819  *      GetConsoleMode
 820  */
 821 WINBASEAPI
 822 BOOL
 823 WINAPI
 824 GetConsoleMode(
 825         HANDLE          hConsoleHandle,
 826         LPDWORD         lpMode
 827         )
 828 {
 829     CONSOLE_MODE Buffer;
 830     DWORD   dwBytesReturned;
 831
 832     if (DeviceIoControl (hConsoleHandle,
 833                          IOCTL_CONSOLE_GET_MODE,
 834                          NULL,
 835                          0,
 836                          &Buffer,
 837                          sizeof(CONSOLE_MODE),
 838                          &dwBytesReturned,
 839                          NULL))
 840     {
 841         *lpMode = Buffer.dwMode;
 842         SetLastError (ERROR_SUCCESS);
 843         return TRUE;
 844     }
 845
 846     SetLastError(0); /* FIXME: What error code? */
 847     return FALSE;
 848 }
 849
 850
 851 /*--------------------------------------------------------------
 852  *      GetNumberOfConsoleInputEvents
 853  */
 854 WINBASEAPI
 855 BOOL
 856 WINAPI
 857 GetNumberOfConsoleInputEvents(
 858         HANDLE          hConsoleInput,
 859         LPDWORD         lpNumberOfEvents
 860         )
 861 {
 862 /* TO DO */
 863         return FALSE;
 864 }
 865
 866
 867 /*--------------------------------------------------------------
 868  *      GetLargestConsoleWindowSize
 869  */
 870 WINBASEAPI
 871 COORD
 872 WINAPI
 873 GetLargestConsoleWindowSize(
 874         HANDLE          hConsoleOutput
 875         )
 876 {
 877 #if 1   /* FIXME: */
 878         COORD Coord = {80,25};
 879
 880 /* TO DO */
 881         return Coord;
 882 #endif
 883 }
 884
 885
 886 /*--------------------------------------------------------------
 887  *      GetConsoleCursorInfo
 888  */
 889 WINBASEAPI
 890 BOOL
 891 WINAPI
 892 GetConsoleCursorInfo(
 893         HANDLE                  hConsoleOutput,
 894         PCONSOLE_CURSOR_INFO    lpConsoleCursorInfo
 895         )
 896 {
 897     DWORD   dwBytesReturned;
 898
 899     if (DeviceIoControl (hConsoleOutput,
 900                          IOCTL_CONSOLE_GET_CURSOR_INFO,
 901                          NULL,
 902                          0,
 903                          lpConsoleCursorInfo,
 904                          sizeof(CONSOLE_CURSOR_INFO),
 905                          &dwBytesReturned,
 906                          NULL))
 907         return TRUE;
 908
 909     return FALSE;
 910 }
 911
 912
 913 /*--------------------------------------------------------------
 914  *      GetNumberOfConsoleMouseButtons
 915  */
 916 WINBASEAPI
 917 BOOL
 918 WINAPI
 919 GetNumberOfConsoleMouseButtons(
 920         LPDWORD         lpNumberOfMouseButtons
 921         )
 922 {
 923 /* TO DO */
 924         return FALSE;
 925 }
 926
 927
 928 /*--------------------------------------------------------------
 929  *      SetConsoleMode
 930  */
 931 WINBASEAPI
 932 BOOL
 933 WINAPI
 934 SetConsoleMode(
 935         HANDLE          hConsoleHandle,
 936         DWORD           dwMode
 937         )
 938 {
 939     CONSOLE_MODE Buffer;
 940     DWORD   dwBytesReturned;
 941
 942     Buffer.dwMode = dwMode;
 943
 944     if (DeviceIoControl (hConsoleHandle,
 945                          IOCTL_CONSOLE_SET_MODE,
 946                          &Buffer,
 947                          sizeof(CONSOLE_MODE),
 948                          NULL,
 949                          0,
 950                          &dwBytesReturned,
 951                          NULL))
 952     {
 953         SetLastError (ERROR_SUCCESS);
 954         return TRUE;
 955     }
 956
 957     SetLastError(0); /* FIXME: What error code? */
 958     return FALSE;
 959 }
 960
 961
 962 /*--------------------------------------------------------------
 963  *      SetConsoleActiveScreenBuffer
 964  */
 965 WINBASEAPI
 966 BOOL
 967 WINAPI
 968 SetConsoleActiveScreenBuffer(
 969         HANDLE          hConsoleOutput
 970         )
 971 {
 972 /* TO DO */
 973         return FALSE;
 974 }
 975
 976
 977 /*--------------------------------------------------------------
 978  *      FlushConsoleInputBuffer
 979  */
 980 WINBASEAPI
 981 BOOL
 982 WINAPI
 983 FlushConsoleInputBuffer(
 984         HANDLE          hConsoleInput
 985         )
 986 {
 987 /* TO DO */
 988         return FALSE;
 989 }
 990
 991
 992 /*--------------------------------------------------------------
 993  *      SetConsoleScreenBufferSize
 994  */
 995 WINBASEAPI
 996 BOOL
 997 WINAPI
 998 SetConsoleScreenBufferSize(
 999         HANDLE          hConsoleOutput,
1000         COORD           dwSize
1001         )
1002 {
1003 /* TO DO */
1004         return FALSE;
1005 }
1006
1007 /*--------------------------------------------------------------
1008  *      SetConsoleCursorInfo
1009  */
1010 WINBASEAPI
1011 BOOL
1012 WINAPI
1013 SetConsoleCursorInfo(
1014         HANDLE                           hConsoleOutput,
1015         CONST CONSOLE_CURSOR_INFO       *lpConsoleCursorInfo
1016         )
1017 {
1018     DWORD   dwBytesReturned;
1019
1020     if (DeviceIoControl (hConsoleOutput,
1021                          IOCTL_CONSOLE_SET_CURSOR_INFO,
1022                          (PCONSOLE_CURSOR_INFO)lpConsoleCursorInfo,
1023                          sizeof(CONSOLE_CURSOR_INFO),
1024                          NULL,
1025                          0,
1026                          &dwBytesReturned,
1027                          NULL))
1028         return TRUE;
1029
1030     return FALSE;
1031 }
1032
1033
1034 /*--------------------------------------------------------------
1035  *      ScrollConsoleScreenBufferA
1036  */
1037 WINBASEAPI
1038 BOOL
1039 WINAPI
1040 ScrollConsoleScreenBufferA(
1041         HANDLE                   hConsoleOutput,
1042         CONST SMALL_RECT        *lpScrollRectangle,
1043         CONST SMALL_RECT        *lpClipRectangle,
1044         COORD                    dwDestinationOrigin,
1045         CONST CHAR_INFO         *lpFill
1046         )
1047 {
1048 /* TO DO */
1049         return FALSE;
1050 }
1051
1052
1053 /*--------------------------------------------------------------
1054  *      ScrollConsoleScreenBufferW
1055  */
1056 WINBASEAPI
1057 BOOL
1058 WINAPI
1059 ScrollConsoleScreenBufferW(
1060         HANDLE                   hConsoleOutput,
1061         CONST SMALL_RECT        *lpScrollRectangle,
1062         CONST SMALL_RECT        *lpClipRectangle,
1063         COORD                    dwDestinationOrigin,
1064         CONST CHAR_INFO         *lpFill
1065         )
1066 {
1067 /* TO DO */
1068         return FALSE;
1069 }
1070
1071
1072 /*--------------------------------------------------------------
1073  *      SetConsoleWindowInfo
1074  */
1075 WINBASEAPI
1076 BOOL
1077 WINAPI
1078 SetConsoleWindowInfo(
1079         HANDLE                   hConsoleOutput,
1080         BOOL                     bAbsolute,
1081         CONST SMALL_RECT        *lpConsoleWindow
1082         )
1083 {
1084 /* TO DO */
1085         return FALSE;
1086 }
1087
1088
1089 /*--------------------------------------------------------------
1090  *      SetConsoleTextAttribute
1091  */
1092 WINBASEAPI
1093 BOOL
1094 WINAPI
1095 SetConsoleTextAttribute(
1096         HANDLE          hConsoleOutput,
1097         WORD            wAttributes
1098         )
1099 {
1100     DWORD dwBytesReturned;
1101
1102     if (!DeviceIoControl (hConsoleOutput,
1103                           IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE,
1104                           &wAttributes,
1105                           sizeof(WORD),
1106                           NULL,
1107                           0,
1108                           &dwBytesReturned,
1109                           NULL))
1110         return FALSE;
1111     return TRUE;
1112 }
1113
1114
1115 /*--------------------------------------------------------------
1116  *      SetConsoleCtrlHandler
1117  */
1118 WINBASEAPI
1119 BOOL
1120 WINAPI
1121 SetConsoleCtrlHandler(
1122         PHANDLER_ROUTINE        HandlerRoutine,
1123         BOOL                    Add
1124         )
1125 {
1126 /* TO DO */
1127         return FALSE;
1128 }
1129
1130
1131 /*--------------------------------------------------------------
1132  *      GenerateConsoleCtrlEvent
1133  */
1134 WINBASEAPI
1135 BOOL
1136 WINAPI
1137 GenerateConsoleCtrlEvent(
1138         DWORD           dwCtrlEvent,
1139         DWORD           dwProcessGroupId
1140         )
1141 {
1142 /* TO DO */
1143         return FALSE;
1144 }
1145
1146
1147 /*--------------------------------------------------------------
1148  *      GetConsoleTitleW
1149  */
1150 #define MAX_CONSOLE_TITLE_LENGTH 80
1151
1152 WINBASEAPI
1153 DWORD
1154 WINAPI
1155 GetConsoleTitleW(
1156         LPWSTR          lpConsoleTitle,
1157         DWORD           nSize
1158         )
1159 {
1160 /* TO DO */
1161         return 0;
1162 }
1163
1164
1165 /*--------------------------------------------------------------
1166  *      GetConsoleTitleA
1167  *
1168  *      19990306 EA
1169  */
1170 WINBASEAPI
1171 DWORD
1172 WINAPI
1173 GetConsoleTitleA(
1174         LPSTR           lpConsoleTitle,
1175         DWORD           nSize
1176         )
1177 {
1178         wchar_t WideTitle [MAX_CONSOLE_TITLE_LENGTH];
1179         DWORD   nWideTitle = sizeof WideTitle;
1180 //      DWORD   nWritten;
1181
1182         if (!lpConsoleTitle || !nSize) return 0;
1183         nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
1184         if (!nWideTitle) return 0;
1185 #if 0
1186         if ( (nWritten = WideCharToMultiByte(
1187                 CP_ACP,                 // ANSI code page
1188                 0,                      // performance and mapping flags
1189                 (LPWSTR) WideTitle,     // address of wide-character string
1190                 nWideTitle,             // number of characters in string
1191                 lpConsoleTitle,         // address of buffer for new string
1192                 nSize,                  // size of buffer
1193                 NULL,                   // FAST
1194                 NULL                    // FAST
1195                 )))
1196         {
1197                 lpConsoleTitle[nWritten] = '\0';
1198                 return nWritten;
1199         }
1200 #endif
1201         return 0;
1202 }
1203
1204
1205 /*--------------------------------------------------------------
1206  *      SetConsoleTitleW
1207  */
1208 WINBASEAPI
1209 BOOL
1210 WINAPI
1211 SetConsoleTitleW(
1212         LPCWSTR         lpConsoleTitle
1213         )
1214 {
1215 /* --- TO DO --- */
1216         return FALSE;
1217 }
1218
1219
1220 /*--------------------------------------------------------------
1221  *      SetConsoleTitleA
1222  *
1223  *      19990204 EA     Added
1224  */
1225 WINBASEAPI
1226 BOOL
1227 WINAPI
1228 SetConsoleTitleA(
1229         LPCSTR          lpConsoleTitle
1230         )
1231 {
1232         wchar_t WideTitle [MAX_CONSOLE_TITLE_LENGTH];
1233         char    AnsiTitle [MAX_CONSOLE_TITLE_LENGTH];
1234         INT     nWideTitle;
1235
1236         if (!lpConsoleTitle) return FALSE;
1237         ZeroMemory( WideTitle, sizeof WideTitle );
1238         nWideTitle = lstrlenA(lpConsoleTitle);
1239         if (!lstrcpynA(
1240                 AnsiTitle,
1241                 lpConsoleTitle,
1242                 nWideTitle
1243                 ))
1244         {
1245                 return FALSE;
1246         }
1247         AnsiTitle[nWideTitle] = '\0';
1248 #if 0
1249         if ( MultiByteToWideChar(
1250                 CP_ACP,                 // ANSI code page
1251                 MB_PRECOMPOSED,         // character-type options
1252                 AnsiTitle,              // address of string to map
1253                 nWideTitle,             // number of characters in string
1254                 (LPWSTR) WideTitle,     // address of wide-character buffer
1255                 (-1)                    // size of buffer: -1=...\0
1256                 ))
1257         {
1258                 return SetConsoleTitleW( (LPWSTR) WideTitle );
1259         }
1260 #endif
1261         return FALSE;
1262 }
1263
1264
1265 /*--------------------------------------------------------------
1266  *      ReadConsoleW
1267  */
1268 WINBASEAPI
1269 BOOL
1270 WINAPI
1271 ReadConsoleW(
1272         HANDLE          hConsoleInput,
1273         LPVOID          lpBuffer,
1274         DWORD           nNumberOfCharsToRead,
1275         LPDWORD         lpNumberOfCharsRead,
1276         LPVOID          lpReserved
1277         )
1278 {
1279 /* --- TO DO --- */
1280         return FALSE;
1281 }
1282
1283
1284 /*--------------------------------------------------------------
1285  *      WriteConsoleW
1286  */
1287 WINBASEAPI
1288 BOOL
1289 WINAPI
1290 WriteConsoleW(
1291         HANDLE           hConsoleOutput,
1292         CONST VOID      *lpBuffer,
1293         DWORD            nNumberOfCharsToWrite,
1294         LPDWORD          lpNumberOfCharsWritten,
1295         LPVOID           lpReserved
1296         )
1297 {
1298 #if 0
1299    PCSRSS_API_REQUEST Request;
1300    CSRSS_API_REPLY Reply;
1301    NTSTATUS Status;
1302
1303    Request = HeapAlloc(GetProcessHeap(),
1304                        HEAP_ZERO_MEMORY,
1305                        sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite * sizeof(WCHAR));
1306    if (Request == NULL)
1307      {
1308         return(FALSE);
1309      }
1310
1311    Request->Type = CSRSS_WRITE_CONSOLE;
1312    Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
1313    Request->Data.WriteConsoleRequest.NrCharactersToWrite =
1314      nNumberOfCharsToWrite;
1315 //   DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
1316 //   DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
1317    memcpy(Request->Data.WriteConsoleRequest.Buffer,
1318           lpBuffer,
1319           nNumberOfCharsToWrite * sizeof(WCHAR));
1320
1321    Status = CsrClientCallServer(Request,
1322                                 &Reply,
1323                                 sizeof(CSRSS_API_REQUEST) +
1324                                 nNumberOfCharsToWrite,
1325                                 sizeof(CSRSS_API_REPLY));
1326
1327    HeapFree(GetProcessHeap(),
1328             0,
1329             Request);
1330
1331    if (!NT_SUCCESS(Status))
1332      {
1333         return(FALSE);
1334      }
1335
1336    if (lpNumberOfCharsWritten != NULL)
1337      {
1338         *lpNumberOfCharsWritten =
1339           Reply.Data.WriteConsoleReply.NrCharactersWritten;
1340      }
1341
1342    return(TRUE);
1343 #endif
1344    return FALSE;
1345 }
1346
1347
1348 /*--------------------------------------------------------------
1349  *      CreateConsoleScreenBuffer
1350  */
1351 WINBASEAPI
1352 HANDLE
1353 WINAPI
1354 CreateConsoleScreenBuffer(
1355         DWORD                            dwDesiredAccess,
1356         DWORD                            dwShareMode,
1357         CONST SECURITY_ATTRIBUTES       *lpSecurityAttributes,
1358         DWORD                            dwFlags,
1359         LPVOID                           lpScreenBufferData
1360         )
1361 {
1362 /* --- TO DO --- */
1363         return FALSE;
1364 }
1365
1366
1367 /*--------------------------------------------------------------
1368  *      GetConsoleCP
1369  */
1370 WINBASEAPI
1371 UINT
1372 WINAPI
1373 GetConsoleCP( VOID )
1374 {
1375 /* --- TO DO --- */
1376         return CP_OEMCP; /* FIXME */
1377 }
1378
1379
1380 /*--------------------------------------------------------------
1381  *      SetConsoleCP
1382  */
1383 WINBASEAPI
1384 BOOL
1385 WINAPI
1386 SetConsoleCP(
1387         UINT            wCodePageID
1388         )
1389 {
1390 /* --- TO DO --- */
1391         return FALSE;
1392 }
1393
1394
1395 /*--------------------------------------------------------------
1396  *      GetConsoleOutputCP
1397  */
1398 WINBASEAPI
1399 UINT
1400 WINAPI
1401 GetConsoleOutputCP( VOID )
1402 {
1403 /* --- TO DO --- */
1404         return 0; /* FIXME */
1405 }
1406
1407
1408 /*--------------------------------------------------------------
1409  *      SetConsoleOutputCP
1410  */
1411 WINBASEAPI
1412 BOOL
1413 WINAPI
1414 SetConsoleOutputCP(
1415         UINT            wCodePageID
1416         )
1417 {
1418 /* --- TO DO --- */
1419         return FALSE;
1420 }
1421
1422
1423 /* EOF */
1424