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