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