![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to console.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / console|
Return to console.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / console |
1.1 ! root 1: #include <windows.h> ! 2: #include <stdio.h> ! 3: #include <string.h> ! 4: #include <stdlib.h> ! 5: #include "console.h" ! 6: ! 7: /* used to set our initial console screen buffer size */ ! 8: #define CONX 80 ! 9: #define CONY 43 ! 10: ! 11: /* prototypes of externally defined demo functions */ ! 12: extern void demoAllocFree(HANDLE hConOld, HANDLE *hConsole); ! 13: extern void demoCreate(HANDLE hConOld); ! 14: extern void demoFillAtt(HANDLE hConOut); ! 15: extern void demoFillChar(HANDLE hConOut); ! 16: extern void demoFlush(HANDLE hConOut); ! 17: extern void demoCursor(HANDLE hConOut); ! 18: extern void demoConMode(HANDLE hConOut); ! 19: extern void demoConInfo(HANDLE hConOut); ! 20: extern void demoGetTitle(HANDLE hConOut); ! 21: extern void demoGetLargest(HANDLE hConOut); ! 22: extern void demoGetNumEvents(HANDLE hConOut); ! 23: extern void demoGetNumBut(HANDLE hConOut); ! 24: extern void demoReadConOut(HANDLE hConOut); ! 25: extern void demoReadConChar(HANDLE hConOut); ! 26: extern void demoScrollCon(HANDLE hConOut); ! 27: extern void demoSizeInfo(HANDLE hConOut); ! 28: extern void demoSetCtrlHandler(HANDLE hConOut); ! 29: extern void demoWriteIn(HANDLE hConOut); ! 30: ! 31: /* information to display on the screen for user to click on */ ! 32: PCHAR conAPIs[] = { ! 33: "AllocConsole Creates a console for the current process", ! 34: "CreateConsoleScreenBuffer Returns a handle to a new screen buffer", ! 35: "FillConsoleOutputAttribute Writes attributes to the screen buffer", ! 36: "FillConsoleOutputCharacter Writes characters to the screen buffer", ! 37: "FlushConsoleInputBuffer Clears the console input buffer", ! 38: "FreeConsole Frees the current console", ! 39: "GetConsoleCursorInfo Returns console size and visibility", ! 40: "GetConsoleMode Returns console input or output mode", ! 41: "GetConsoleScreenBufferInfo Returns screen-buffer information", ! 42: "GetConsoleTitle Returns console-window title", ! 43: "GetLargestConsoleWindowSize Returns largest possible window size", ! 44: "GetNumberOfConsoleInputEvents Retrieves number of console-queue events", ! 45: "GetNumberOfConsoleMouseButtons Retrieves number of mouse buttons", ! 46: "PeekConsoleInput Previews console input data", ! 47: "ReadConsoleInput Reads console input data", ! 48: "ReadConsoleOutput Reads screen-buffer data", ! 49: "ReadConsoleOutputAttribute Reads a console attribute string", ! 50: "ReadConsoleOutputCharacter Reads a screen-buffer string", ! 51: "ScrollConsoleScreenBuffer Scrolls data in the screen buffer", ! 52: "SetConsoleActiveScreenBuffer Changes displayed screen buffer", ! 53: "SetConsoleCursorInfo Sets cursor size and visibility", ! 54: "SetConsoleCursorPosition Sets cursor position", ! 55: "SetConsoleMode Sets console input or output mode", ! 56: "SetConsoleScreenBufferSize Changes screen-buffer size", ! 57: "SetConsoleTextAttribute Sets attributes for screen text", ! 58: "SetConsoleTitle Sets console-window title string", ! 59: "SetConsoleWindowInfo Sets console window size", ! 60: "SetConsoleCtrlHandler Sets console ctrl-c handler", ! 61: "WriteConsoleInput Writes to console input buffer", ! 62: "WriteConsoleOutput Writes to screen buffer", ! 63: "WriteConsoleOutputAttribute Writes an attribute string to console", ! 64: "WriteConsoleOutputCharacter Writes a character string to console" ! 65: }; ! 66: ! 67: /* this variable holds the number next to the API on the screen that */ ! 68: /* the user clicks on */ ! 69: enum cAPIs { ALLOC = 1, CREATE, FILLATT, FILLCHAR, FLUSH, FREE, GETCUR, ! 70: GETMODE, GETCONINFO, GETTITLE, GETLARGEST, GETNUMEV, GETNUMBUT, PEEK, ! 71: READCONIN, READCONOUT, READCONATT, READCONCHAR, SCROLL, SETACTIVE, ! 72: SETCURINF, SETCURPOS, SETMODE, SETSIZE, SETATT, SETTITLE, SETINFO, ! 73: SETHAND, WRITEIN, WRITEOUT, WRITEATT, WRITECHAR }; ! 74: ! 75: ! 76: /***************************************************************** ! 77: * FUNCTION: myGetchar(void) * ! 78: * * ! 79: * PURPOSE: get a single character from the standard input handle * ! 80: * * ! 81: * INPUT: none * ! 82: * * ! 83: * RETURNS: the char received from the console * ! 84: *****************************************************************/ ! 85: ! 86: CHAR myGetchar(void) ! 87: { ! 88: HANDLE hStdIn; /* standard input */ ! 89: DWORD dwInputMode; /* to save the input mode */ ! 90: BOOL bSuccess; ! 91: CHAR chBuf; /* buffer to read into */ ! 92: DWORD dwRead; ! 93: ! 94: /* get the standard input handle to read from. There is only one */ ! 95: /* instance of standard input per process at any given time */ ! 96: hStdIn = GetStdHandle(STD_INPUT_HANDLE); ! 97: PERR((int) hStdIn != -1, "GetStdHandle"); ! 98: /* save the console mode */ ! 99: bSuccess = GetConsoleMode(hStdIn, &dwInputMode); ! 100: PERR(bSuccess, "GetconsoleMode"); ! 101: /* disable line input. Echo input must be disabled when disabling */ ! 102: /* line input */ ! 103: bSuccess = SetConsoleMode(hStdIn, dwInputMode & ~ENABLE_LINE_INPUT & ! 104: ~ENABLE_ECHO_INPUT); ! 105: PERR(bSuccess, "SetConsoleMode"); ! 106: /* read a character from the console input */ ! 107: bSuccess = ReadFile(hStdIn, &chBuf, sizeof(chBuf), &dwRead, NULL); ! 108: PERR(bSuccess, "ReadFile"); ! 109: /* restore the original console input mode */ ! 110: bSuccess = SetConsoleMode(hStdIn, dwInputMode); ! 111: PERR(bSuccess, "SetConsoleMode"); ! 112: return(chBuf); ! 113: } ! 114: ! 115: ! 116: /******************************************************************** ! 117: * FUNCTION: perrError(void) * ! 118: * * ! 119: * PURPOSE: beep twice and abort program * ! 120: * * ! 121: * INPUT: none * ! 122: * * ! 123: * RETURNS: none * ! 124: * * ! 125: * COMMENTS: only called from perr() when a fatal error has occurred * ! 126: ********************************************************************/ ! 127: ! 128: void perrError(void) ! 129: { ! 130: DWORD dwLastError; /* for debugger purposes */ ! 131: ! 132: dwLastError = GetLastError(); ! 133: /* we can't output an error message - beep instead */ ! 134: Beep(600, 500); ! 135: Beep(700, 500); ! 136: exit(1); ! 137: } ! 138: ! 139: ! 140: /********************************************************************* ! 141: * FUNCTION: perr(PCHAR szFileName, int line, PCHAR szApiName, * ! 142: * DWORD dwError) * ! 143: * * ! 144: * PURPOSE: report API errors. Allocate a new console buffer, display * ! 145: * error number and error text, restore previous console * ! 146: * buffer * ! 147: * * ! 148: * INPUT: current source file name, current line number, name of the * ! 149: * API that failed, and the error number * ! 150: * * ! 151: * RETURNS: none * ! 152: *********************************************************************/ ! 153: ! 154: /* this is the size of the buffer for the error message text */ ! 155: #define MSG_BUF_SIZE 512 ! 156: ! 157: void perr(PCHAR szFileName, int line, PCHAR szApiName, DWORD dwError) ! 158: { ! 159: BOOL bSuccess; ! 160: HANDLE hConTemp; /* temp console buffer to put error message on */ ! 161: HANDLE hCurrentCon; /* to save the current console so we can restore it */ ! 162: CHAR szTemp[256]; ! 163: DWORD cCharsWritten; ! 164: DWORD dwLastError; /* for debugging purposes */ ! 165: CHAR msgBuf[MSG_BUF_SIZE]; /* buffer for message text from system */ ! 166: ! 167: /* create a handle to the current console buffer */ ! 168: hCurrentCon = CreateFile("CONOUT$", GENERIC_WRITE, FILE_SHARE_READ | ! 169: FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); ! 170: if ((int) hCurrentCon == -1) ! 171: { ! 172: dwLastError = GetLastError(); ! 173: /* just in case this works */ ! 174: printf("Fatal error in perr() on line %d: %d\n", __LINE__, dwLastError); ! 175: Beep(600, 500); ! 176: exit(1); ! 177: } ! 178: /* create a temporary console buffer that we can write on */ ! 179: hConTemp = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, ! 180: FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, ! 181: NULL); ! 182: if ((int) hConTemp == -1) ! 183: { ! 184: dwLastError = GetLastError(); ! 185: printf("Fatal error in perr() on line %d: %d\n", __LINE__, dwLastError); ! 186: Beep(600, 500); ! 187: exit(1); ! 188: } ! 189: /* make the temp buffer to the current buffer */ ! 190: bSuccess = SetConsoleActiveScreenBuffer(hConTemp); ! 191: if (!bSuccess) ! 192: { ! 193: dwLastError = GetLastError(); ! 194: printf("Fatal error in perr() on line %d: %d\n", __LINE__, dwLastError); ! 195: Beep(600, 500); ! 196: exit(1); ! 197: } ! 198: /* set red on white text for future text output */ ! 199: SetConsoleTextAttribute(hConTemp, FOREGROUND_RED | BACKGROUND_WHITE); ! 200: /* format our error message */ ! 201: sprintf(szTemp, "%s: Error %d from %s on line %d\n", szFileName, ! 202: dwError, szApiName, line); ! 203: /* write the message to the console */ ! 204: bSuccess = WriteFile(hConTemp, szTemp, strlen(szTemp), &cCharsWritten, ! 205: NULL); ! 206: if (!bSuccess) ! 207: perrError(); ! 208: memset(msgBuf, 0, sizeof(msgBuf)); ! 209: /* get the text description for that error number from the system */ ! 210: cCharsWritten = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | ! 211: getConX(hConTemp), NULL, dwError, MAKELANGID(0, SUBLANG_ENGLISH_US), ! 212: msgBuf, sizeof(msgBuf), NULL); ! 213: if (!cCharsWritten) ! 214: perrError(); ! 215: else ! 216: { ! 217: /* write the text description to the console */ ! 218: bSuccess = WriteFile(hConTemp, msgBuf, strlen(msgBuf), &cCharsWritten, ! 219: NULL); ! 220: if (!bSuccess) ! 221: perrError(); ! 222: } ! 223: myGetchar(); ! 224: /* reset the current buffer to the original one */ ! 225: bSuccess = SetConsoleActiveScreenBuffer(hCurrentCon); ! 226: if (!bSuccess) ! 227: perrError(); ! 228: CloseHandle(hConTemp); ! 229: bSuccess = CloseHandle(hCurrentCon); ! 230: if (!bSuccess) ! 231: perrError(); ! 232: return; ! 233: } ! 234: ! 235: /************************************************************************* ! 236: * FUNCTION: myPuts(HANDLE hConsole, PCHAR s) * ! 237: * * ! 238: * PURPOSE: write a string to the given console buffer, appending a cr/lf * ! 239: * * ! 240: * INPUT: the console to write to, and the string to write * ! 241: * * ! 242: * RETURNS: TRUE if success, FALSE if an error occured * ! 243: *************************************************************************/ ! 244: ! 245: BOOL myPuts(HANDLE hConsole, PCHAR s) ! 246: { ! 247: BOOL bSuccess; ! 248: DWORD cCharsWritten; ! 249: const PCHAR crlf = "\n"; ! 250: BOOL retflag = TRUE; ! 251: ! 252: /* write the string to the console */ ! 253: bSuccess = WriteFile(hConsole, s, strlen(s), &cCharsWritten, NULL); ! 254: PERR(bSuccess, "WriteFile"); ! 255: retflag = bSuccess; ! 256: /* put a carriage return & line feed after the string */ ! 257: bSuccess = WriteFile(hConsole, crlf, strlen(crlf), &cCharsWritten, NULL); ! 258: PERR(bSuccess, "WriteFile"); ! 259: if (!bSuccess) ! 260: retflag = FALSE; ! 261: return(retflag); ! 262: } ! 263: ! 264: ! 265: /******************************************************************** ! 266: * FUNCTION: getConX(HANDLE hCon) * ! 267: * * ! 268: * PURPROSE: to get the current width of the console output buffer * ! 269: * * ! 270: * INPUT: the handle to get the information for * ! 271: * * ! 272: * RETURNS: the width of the current console output buffer, in chars * ! 273: ********************************************************************/ ! 274: ! 275: SHORT getConX(HANDLE hCon) ! 276: { ! 277: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 278: BOOL bSuccess; ! 279: ! 280: bSuccess = GetConsoleScreenBufferInfo(hCon, &csbi); ! 281: PERR(bSuccess, "GetConsoleScreenBufferInfo"); ! 282: return(csbi.dwSize.X); ! 283: } ! 284: ! 285: ! 286: /********************************************************************* ! 287: * FUNCTION: getConY(HANDLE hCon) * ! 288: * * ! 289: * PURPROSE: to get the current height of the console output buffer * ! 290: * * ! 291: * INPUT: the handle to get the information for * ! 292: * * ! 293: * RETURNS: the height of the current console output buffer, in chars * ! 294: *********************************************************************/ ! 295: ! 296: ! 297: SHORT getConY(HANDLE hCon) ! 298: { ! 299: CONSOLE_SCREEN_BUFFER_INFO csbi; ! 300: BOOL bSuccess; ! 301: ! 302: bSuccess = GetConsoleScreenBufferInfo(hCon, &csbi); ! 303: PERR(bSuccess, "GetConsoleScreenBufferInfo"); ! 304: return(csbi.dwSize.Y); ! 305: } ! 306: ! 307: ! 308: /************************************************************************* ! 309: * FUNCTION: showConAPIs(HANDLE hConsole) * ! 310: * * ! 311: * PURPOSE: to display a list of console APIs on the given console buffer * ! 312: * * ! 313: * INPUT: the console to display the APIs on * ! 314: * * ! 315: * RETURNS: none * ! 316: *************************************************************************/ ! 317: ! 318: void showConAPIs(HANDLE hConsole) ! 319: { ! 320: COORD coordScreen = {CONX, CONY}; /* used to set the console buffer size */ ! 321: /* used to set the console window size */ ! 322: SMALL_RECT srWindowRect = {0, 0, CONX - 1, CONY - 1}; ! 323: int i; ! 324: BOOL bSuccess; ! 325: DWORD cCharsWritten; ! 326: CHAR szTemps[128]; ! 327: WORD wConBufSize; /* used to hold current console buffer size */ ! 328: ! 329: /* get the current console buffer size, in chars */ ! 330: wConBufSize = getConX(hConsole) * getConY(hConsole); ! 331: /* force an CONX x CONY screen */ ! 332: /* if the current buffer is larger than what we want, resize the */ ! 333: /* console window first, then the buffer */ ! 334: if (wConBufSize > CONX * CONY) ! 335: { ! 336: bSuccess = SetConsoleWindowInfo(hConsole, TRUE, &srWindowRect); ! 337: PERR(bSuccess, "SetConsoleWindowInfo"); ! 338: bSuccess = SetConsoleScreenBufferSize(hConsole, coordScreen); ! 339: PERR(bSuccess, "SetConsoleScreenBufferSize"); ! 340: } ! 341: /* if the current buffer is smaller than what we want, resize the */ ! 342: /* buffer first, then the console window */ ! 343: if (wConBufSize < CONX * CONY) ! 344: { ! 345: bSuccess = SetConsoleScreenBufferSize(hConsole, coordScreen); ! 346: PERR(bSuccess, "SetConsoleScreenBufferSize"); ! 347: bSuccess = SetConsoleWindowInfo(hConsole, TRUE, &srWindowRect); ! 348: PERR(bSuccess, "SetConsoleWindowInfo"); ! 349: } ! 350: coordScreen.X = 0; ! 351: coordScreen.Y = 0; ! 352: /* set the screen */ ! 353: bSuccess = FillConsoleOutputAttribute(hConsole, BACKGROUND_BLUE, ! 354: CONX * CONY, coordScreen, &cCharsWritten); ! 355: PERR(bSuccess, "FillConsoleOutputAttribute"); ! 356: /* set attributes for new writes to the console */ ! 357: bSuccess = SetConsoleTextAttribute(hConsole, BACKGROUND_BLUE | ! 358: FOREGROUND_WHITE); ! 359: PERR(bSuccess, "SetConsoleTextAttribute"); ! 360: /* fill screen with API list */ ! 361: for (i = 0; i < sizeof(conAPIs) / sizeof(conAPIs[0]); i++) ! 362: { ! 363: coordScreen.X = 0; ! 364: coordScreen.Y = (SHORT) (i + 2); /* start on third line (zero based) */ ! 365: /* position the cursor to start the API list */ ! 366: bSuccess = SetConsoleCursorPosition(hConsole, coordScreen); ! 367: PERR(bSuccess, "SetConsoleCursorPosition"); ! 368: /* format a line and write it to the screen */ ! 369: sprintf(szTemps, "%-3d%s", i + 1, conAPIs[i]); ! 370: myPuts(hConsole, szTemps); ! 371: /* color the number yellow on blue */ ! 372: bSuccess = FillConsoleOutputAttribute(hConsole, FOREGROUND_YELLOW | ! 373: FOREGROUND_INTENSITY | BACKGROUND_BLUE, 3, coordScreen, ! 374: &cCharsWritten); ! 375: PERR(bSuccess, "FillConsoleOutputAttribute"); ! 376: coordScreen.X = 3; ! 377: /* color text light cyan on blue */ ! 378: bSuccess = FillConsoleOutputAttribute(hConsole, FOREGROUND_CYAN | ! 379: FOREGROUND_INTENSITY | BACKGROUND_BLUE, strlen(conAPIs[i]), ! 380: coordScreen, &cCharsWritten); ! 381: PERR(bSuccess, "FillConsoleOutputAttribute"); ! 382: } ! 383: myPuts(hConsole, "\nClick on an API to see a demonstration of that API.\n" ! 384: "Hit ESC to exit the program.\n"); ! 385: return; ! 386: } ! 387: ! 388: ! 389: /************************************************************************* ! 390: * FUNCTION: putStatusLine(HANDLE hOut, PCHAR buf) * ! 391: * * ! 392: * PURPOSE: display a string on the top line of the console output buffer * ! 393: * * ! 394: * INPUT: the output handle, the string to display * ! 395: * * ! 396: * RETURNS: none * ! 397: *************************************************************************/ ! 398: ! 399: void putStatusLine(HANDLE hOut, PCHAR buf) ! 400: { ! 401: BOOL bSuccess; ! 402: /* position the status line at (0, 0) */ ! 403: const COORD dwWriteCoord = {0, 0}; ! 404: DWORD cCharsWritten; ! 405: int len; /* the length of the input string parameter */ ! 406: CHAR szTemp[256]; ! 407: SHORT sWidth; /* console width */ ! 408: ! 409: sWidth = getConX(hOut); ! 410: strcpy(szTemp, buf); ! 411: len = strlen(szTemp); ! 412: memset(szTemp + len, ' ', sWidth - len); /* blank out rest of line */ ! 413: /* write the string to the console at the correct position */ ! 414: bSuccess = WriteConsoleOutputCharacter(hOut, szTemp, sWidth, ! 415: dwWriteCoord, &cCharsWritten); ! 416: PERR(bSuccess, "WriteConsoleOutput"); ! 417: /* color the status line so it stands out */ ! 418: bSuccess = FillConsoleOutputAttribute(hOut, FOREGROUND_RED | ! 419: BACKGROUND_WHITE, sWidth, dwWriteCoord, &cCharsWritten); ! 420: PERR(bSuccess, "FillConsoleOutputAttribute"); ! 421: return; ! 422: } ! 423: ! 424: ! 425: /******************************************************************** ! 426: * FUNCTION: demoAPI(HANDLE *hConsole, enum cAPIs apiNumber) * ! 427: * * ! 428: * PURPOSE: call the correct demo function based on the input index * ! 429: * * ! 430: * INPUT: current console output buffer, and screen index of the API * ! 431: * to demonstrate * ! 432: * * ! 433: * RETURNS: none * ! 434: ********************************************************************/ ! 435: ! 436: static void demoAPI(HANDLE *phConsole, enum cAPIs apiNumber) ! 437: { ! 438: const COORD coordScreen = {0, 0}; ! 439: DWORD cCharsWritten; ! 440: BOOL bSuccess; ! 441: HANDLE hConTemp; ! 442: CHAR szConsoleTitle[128]; /* to store the console title */ ! 443: DWORD dwCharsRead; ! 444: ! 445: /* create a temp screen buffer to write to */ ! 446: hConTemp = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, ! 447: FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, ! 448: NULL); ! 449: PERR((int) hConTemp != -1, "CreateConsoleScreenBuffer"); ! 450: /* make it the active buffer */ ! 451: bSuccess = SetConsoleActiveScreenBuffer(hConTemp); ! 452: PERR(bSuccess, "SetConsoleActiveScreenBuffer"); ! 453: /* clear screen & save the console title */ ! 454: cls(hConTemp); ! 455: bSuccess = FillConsoleOutputAttribute(hConTemp, BACKGROUND_CYAN, ! 456: getConX(hConTemp) * getConY(hConTemp), coordScreen, &cCharsWritten); ! 457: PERR(bSuccess, "FillConsoleOutputAttribute"); ! 458: bSuccess = SetConsoleTextAttribute(hConTemp, BACKGROUND_CYAN); ! 459: PERR(bSuccess, "SetConsoleTextAttribute"); ! 460: dwCharsRead = GetConsoleTitle(szConsoleTitle, sizeof(szConsoleTitle)); ! 461: PERR(dwCharsRead, "GetConsoleTitle"); ! 462: ! 463: /* flush the input buffer and call the correct demo function */ ! 464: bSuccess = FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); ! 465: PERR(bSuccess, "FlushConsoleInputBuffer"); ! 466: switch(apiNumber) ! 467: { ! 468: case ALLOC: ! 469: case FREE: ! 470: demoAllocFree(hConTemp, phConsole); ! 471: return; ! 472: break; ! 473: case CREATE: ! 474: case SETACTIVE: ! 475: case SETATT: ! 476: demoCreate(hConTemp); ! 477: break; ! 478: case FILLATT: ! 479: case WRITECHAR: ! 480: demoFillAtt(hConTemp); ! 481: break; ! 482: case FILLCHAR: ! 483: demoFillChar(hConTemp); ! 484: break; ! 485: case FLUSH: ! 486: demoFlush(hConTemp); ! 487: break; ! 488: case GETCUR: ! 489: case SETCURINF: ! 490: case SETCURPOS: ! 491: demoCursor(hConTemp); ! 492: break; ! 493: case GETMODE: ! 494: case SETMODE: ! 495: demoConMode(hConTemp); ! 496: break; ! 497: case GETCONINFO: ! 498: demoConInfo(hConTemp); ! 499: break; ! 500: case GETTITLE: ! 501: case SETTITLE: ! 502: demoGetTitle(hConTemp); ! 503: break; ! 504: case GETLARGEST: ! 505: demoGetLargest(hConTemp); ! 506: break; ! 507: case GETNUMEV: ! 508: case PEEK: ! 509: case READCONIN: ! 510: demoGetNumEvents(hConTemp); ! 511: break; ! 512: case GETNUMBUT: ! 513: demoGetNumBut(hConTemp); ! 514: break; ! 515: case READCONOUT: ! 516: case WRITEOUT: ! 517: case READCONATT: ! 518: case WRITEATT: ! 519: demoReadConOut(hConTemp); ! 520: break; ! 521: case READCONCHAR: ! 522: demoReadConChar(hConTemp); ! 523: break; ! 524: case SCROLL: ! 525: demoScrollCon(hConTemp); ! 526: break; ! 527: case SETSIZE: ! 528: case SETINFO: ! 529: demoSizeInfo(hConTemp); ! 530: break; ! 531: case SETHAND: ! 532: demoSetCtrlHandler(hConTemp); ! 533: break; ! 534: case WRITEIN: ! 535: demoWriteIn(hConTemp); ! 536: break; ! 537: default: ! 538: break; ! 539: } ! 540: CloseHandle(hConTemp); /* free temporary console buffer */ ! 541: /* reset active buffer to original buffer. If the temp buffer has been */ ! 542: /* resized, the console window will automatically be sized correctly */ ! 543: /* when the current console is set back to the old one */ ! 544: bSuccess = SetConsoleActiveScreenBuffer(*phConsole); ! 545: PERR(bSuccess, "SetConsoleActiveScreenBuffer"); ! 546: /* restore the original console title */ ! 547: bSuccess = SetConsoleTitle(szConsoleTitle); ! 548: PERR(bSuccess, "SetConsoleTitle"); ! 549: /* flush the input buffer to remove any 'leftover' clicks or key events */ ! 550: bSuccess = FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); ! 551: PERR(bSuccess, "FlushConsoleInputBuffer"); ! 552: return; ! 553: } ! 554: ! 555: ! 556: /************************************************************************ ! 557: * FUNCTION: cls(HANDLE hConsole) * ! 558: * * ! 559: * PURPOSE: clear the screen by filling it with blanks, then home cursor * ! 560: * * ! 561: * INPUT: the console buffer to clear * ! 562: * * ! 563: * RETURNS: none * ! 564: *************************************************************************/ ! 565: ! 566: void cls(HANDLE hConsole) ! 567: { ! 568: COORD coordScreen = { 0, 0 }; /* here's where we'll home the cursor */ ! 569: BOOL bSuccess; ! 570: DWORD cCharsWritten; ! 571: ! 572: /* fill the entire screen with blanks */ ! 573: bSuccess = FillConsoleOutputCharacter(hConsole, (TCHAR) ' ', ! 574: getConX(hConsole) * getConY(hConsole), coordScreen, &cCharsWritten); ! 575: PERR(bSuccess, "FillConsoleOutputCharacter"); ! 576: /* put the cursor at (0, 0) */ ! 577: bSuccess = SetConsoleCursorPosition(hConsole, coordScreen); ! 578: PERR(bSuccess, "SetConsoleCursorPosition"); ! 579: return; ! 580: } ! 581: ! 582: ! 583: /********************************************************************* ! 584: * FUNCTION: setConTitle * ! 585: * * ! 586: * PURPOSE: simply set the current console title. Called by each demo * ! 587: * function to specify the name of the source file that * ! 588: * contains the demo function. * ! 589: * * ! 590: * INPUT: null terminated string * ! 591: *********************************************************************/ ! 592: ! 593: void setConTitle(PCHAR szTitle) ! 594: { ! 595: BOOL bSuccess; ! 596: ! 597: /* set the console title to the input string parameter */ ! 598: bSuccess = SetConsoleTitle(szTitle); ! 599: PERR(bSuccess, "SetConsoleTitle"); ! 600: return; ! 601: } ! 602: ! 603: ! 604: /********************************************************************* ! 605: * FUNCTION: main * ! 606: * * ! 607: * PURPOSE: main input loop. Set up console input and output * ! 608: * attributes, then read the input queue and process input * ! 609: * events. If ESC is hit, end the process. If the mouse is * ! 610: * clicked, read the line from the output console where the * ! 611: * mouse was clicked. If an index number can be found at the * ! 612: * beginning of the line, call the appropriate demo function * ! 613: * to demonstrate that API. All input event information is * ! 614: * displayed on the status line on the top line. * ! 615: * * ! 616: * INPUT: none * ! 617: * * ! 618: * RETURNS: 1 if can't free console, 2 if can't allocate a console, 0 * ! 619: * for a normal exit * ! 620: *********************************************************************/ ! 621: ! 622: int main() ! 623: { ! 624: BOOL bSuccess; ! 625: HANDLE hStdIn, hStdOut; /* standard input and standard output */ ! 626: DWORD dwMode; ! 627: /* array of console input event records */ ! 628: INPUT_RECORD inputBuffer; ! 629: DWORD dwInputEvents; /* number of events actually read */ ! 630: CHAR bOutBuf[256]; /* buffer to format event information into */ ! 631: /* used to get the new console screen buffer size if it is changed */ ! 632: COORD coordScreen; /* used when reading the index number from the screen */ ! 633: CHAR *szLineBuf; /* buffer to read the index number into */ ! 634: DWORD cCharsRead; ! 635: enum cAPIs apiNumber; /* the index number of the API read from the screen */ ! 636: /* used when turning off the cursor */ ! 637: CONSOLE_CURSOR_INFO cci = {100, FALSE}; ! 638: ! 639: /* free the console and immediately allocate a new one. This is done so */ ! 640: /* that when debugging under ntsd, the application output will not be */ ! 641: /* intermingled with the debugger output. This section can be removed */ ! 642: /* without any change in the behavior of this program */ ! 643: bSuccess = FreeConsole(); ! 644: /* C run-time output will not work from now on! */ ! 645: if (!bSuccess) ! 646: { ! 647: Beep(600, 500); /* can't output an error message! */ ! 648: return(1); ! 649: } ! 650: bSuccess = AllocConsole(); ! 651: if (!bSuccess) ! 652: { ! 653: Beep(600, 500); /* can't output an error message! */ ! 654: return(2); ! 655: } ! 656: /* let's put up a meaningful console title */ ! 657: bSuccess = SetConsoleTitle("Win32 Console API Demo"); ! 658: PERR(bSuccess, "SetConsoleTitle"); ! 659: /* get the standard handles */ ! 660: hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); ! 661: PERR((int) hStdOut != -1, "GetStdHandle"); ! 662: hStdIn = GetStdHandle(STD_INPUT_HANDLE); ! 663: PERR((int) hStdIn != -1,"GetStdHandle"); ! 664: /* set up mouse and window input */ ! 665: bSuccess = GetConsoleMode(hStdIn, &dwMode); ! 666: PERR(bSuccess, "GetConsoleMode"); ! 667: /* when turning off ENABLE_LINE_INPUT, you MUST also turn off */ ! 668: /* ENABLE_ECHO_INPUT. */ ! 669: bSuccess = SetConsoleMode(hStdIn, (dwMode & ~(ENABLE_LINE_INPUT | ! 670: ENABLE_ECHO_INPUT)) | ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT); ! 671: PERR(bSuccess, "SetConsoleMode"); ! 672: /* hide the cursor */ ! 673: bSuccess = SetConsoleCursorInfo(hStdOut, &cci); ! 674: PERR(bSuccess, "SetConsoleCursorInfo"); ! 675: /* resize console to CONX * CONY and put list of console APIs up */ ! 676: showConAPIs(hStdOut); ! 677: /* This is the main input loop. Read from the input queue and process */ ! 678: /* the events read */ ! 679: szLineBuf = (char *) malloc(getConX(hStdOut)); ! 680: PERR(szLineBuf, "malloc"); ! 681: ! 682: for(;;) ! 683: { ! 684: /* read an input events from the input event queue */ ! 685: bSuccess = ReadConsoleInput(hStdIn, &inputBuffer, 1, &dwInputEvents); ! 686: PERR(bSuccess, "ReadConsoleInput"); ! 687: switch (inputBuffer.EventType) ! 688: { ! 689: case KEY_EVENT: ! 690: if (inputBuffer.Event.KeyEvent.bKeyDown) ! 691: { ! 692: /* display the key event info on the status line */ ! 693: sprintf(bOutBuf, "key: virtual=%d ascii=%c", ! 694: inputBuffer.Event.KeyEvent.wVirtualKeyCode, ! 695: inputBuffer.Event.KeyEvent.uChar.AsciiChar); ! 696: if (inputBuffer.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ! 697: { ! 698: free(szLineBuf); /* free allocated line buffer */ ! 699: return(0); ! 700: } ! 701: putStatusLine(hStdOut, bOutBuf); ! 702: } ! 703: break; ! 704: case MOUSE_EVENT: ! 705: sprintf(bOutBuf, "mouse: %s at %d, %d", ! 706: (inputBuffer.Event.MouseEvent.dwEventFlags == MOUSE_MOVED ? ! 707: "moved" : "clicked"), inputBuffer.Event.MouseEvent.dwMousePosition.X, ! 708: inputBuffer.Event.MouseEvent.dwMousePosition.Y); ! 709: putStatusLine(hStdOut, bOutBuf); ! 710: /* was this a mouse click? If so dwEventFlags contains 0 */ ! 711: /* are any mouse buttons down? If so dwButtonState is not 0 */ ! 712: if (inputBuffer.Event.MouseEvent.dwEventFlags == 0 && ! 713: inputBuffer.Event.MouseEvent.dwButtonState) ! 714: { ! 715: coordScreen.X = 0; ! 716: coordScreen.Y = inputBuffer.Event.MouseEvent.dwMousePosition.Y; ! 717: /* read the line where the mouse clicked */ ! 718: bSuccess = ReadConsoleOutputCharacter(hStdOut, szLineBuf, ! 719: sizeof(szLineBuf), coordScreen, &cCharsRead); ! 720: PERR(bSuccess, "ReadConsoleOutputCharacter"); ! 721: /* scan for an index number at the beginning of that line. */ ! 722: /* if there was one read, call the correct demo function */ ! 723: if (sscanf(szLineBuf, "%d", &apiNumber)) ! 724: demoAPI(&hStdOut, apiNumber); ! 725: } ! 726: break; ! 727: case WINDOW_BUFFER_SIZE_EVENT: ! 728: sprintf(bOutBuf, "window: %d, %d", ! 729: inputBuffer.Event.WindowBufferSizeEvent.dwSize.X, ! 730: inputBuffer.Event.WindowBufferSizeEvent.dwSize.Y); ! 731: putStatusLine(hStdOut, bOutBuf); ! 732: Sleep(1000); ! 733: break; ! 734: } /* switch */ ! 735: } /* while */ ! 736: free(szLineBuf); /* free allocated line buffer */ ! 737: return(0); ! 738: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.