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