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