home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / window / winclip / demo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-23  |  32.2 KB  |  1,057 lines
  1. /* Date 1-15-91 */
  2.  
  3. /*********************************************************************
  4.  * This is the demonstration program of some of the functions        *
  5.  * available with The C Window Library.                              *
  6.  *                                                                   *
  7.  * For Turbo C version 1.5 and above,  compile using the following:  *
  8.  *     tcc -mm -Ixxx demo.c tcwinm.lib                               *
  9.  * where xxx is the directory of The C Window Library header files.  *
  10.  *                                                                   *
  11.  * For Microsoft C users Version 5.1 and above:                      *
  12.  *     cl -AM -Ixxx -DMSC demo /link /SE:1000 mswinm.lib             *
  13.  * (use "qcl" instead of "cl" if using Quick C)                      *
  14.  * where  xxx is the directory of The C Window Library header files. *
  15.  *                                                                   *
  16.  * For Zortech C++ Version 2.0 and above:                            *
  17.  *     ztc -mm -Ixxx -p -b demo.c zcwinm.lib                         *
  18.  * where  xxx is the directory of The C Window Library header files. *
  19.  *                                                                   *
  20.  * For Power C Version 2.0 and above:                                *
  21.  *     pc -DPOWERC -mm -c -ixxx demo.c                               *
  22.  *     pcl [5k,45k,300k] demo,pcwinm                                 *
  23.  * where  xxx is the directory of The C Window Library header files. *
  24.  *********************************************************************/
  25.  
  26. #include <window.h>
  27. #include <stdio.h>
  28. #include <walloc.h>
  29. #include <dos.h>
  30.  
  31.  
  32. int approx_delay(int);
  33. void demo(void);
  34. int write_all(WPOINTER);
  35. void slide_window(WPOINTER);
  36. int slide_windows(void);
  37. int change_screen_size(void);
  38. int read_file(void);
  39. int pan_window(WPOINTER);
  40. void resize_demo(void);
  41. void slide_see_thru_window(WPOINTER);
  42. void initialize_error(void);
  43. void custom_error_func(int errcode, char *sourcefile, int sourceline,
  44.                char *funcname);
  45.  
  46. /* Define colors used */
  47.  
  48. #define YELLOWONRED    CREATE_VIDEO_ATTRIBUTE(red,yellow)
  49. #define WHITEONRED     CREATE_VIDEO_ATTRIBUTE(red,lightwhite)
  50. #define WHITEONBLUE    CREATE_VIDEO_ATTRIBUTE(blue,white)
  51. #define WHITEONBLACK   CREATE_VIDEO_ATTRIBUTE(black,gray)
  52. #define GREENONBLACK   CREATE_VIDEO_ATTRIBUTE(black,green)
  53. #define BLACKONWHITE   CREATE_VIDEO_ATTRIBUTE(white,black)
  54. #define WHITEONGREEN   CREATE_VIDEO_ATTRIBUTE(green,white)
  55. #define GRAYONBLACK    CREATE_VIDEO_ATTRIBUTE(black,gray)
  56. #define GREENONBLUE    CREATE_VIDEO_ATTRIBUTE(blue,green)
  57. #define NORM           CREATE_VIDEO_ATTRIBUTE(black,white)
  58.  
  59.  
  60. /* define filename characters */
  61.  
  62. #define FILENAMECHARS  "25[A-Za-z0-9!@#$%/^&()+=_/-{}/[/]`~/.\\:]"
  63.  
  64.  
  65. /* define titles used for each window */
  66.  
  67. char *title1 = " [ Main Window ] ";
  68. char *title2 = " [ Window 1 ] ";
  69. char *title3 = " [ Window 2 ] ";
  70. char *title4 = " [ Window 3 ] ";
  71.  
  72.  
  73. char filename[26];     /* filename buffer */
  74. FILE *infile;          /* input file handle */
  75.  
  76.  
  77. /* Text written to main window */
  78.  
  79. char *screen1[] = {
  80.   " Welcome to the demonstration of the C Window Library!!  The C Window Library",
  81.   " is a collection of C functions that manipulate text windows.  With these    ",
  82.   " text windows, you can ...",
  83. NULL};
  84.  
  85. char *effectstr[] = {"Normal...",
  86.                      "Normal Explode...",
  87.                      "Contract...",
  88.              "Bricks...",
  89.              "Explode From Center To Top And Bottom...",
  90.              "Explode To Center From Top And Bottom...",
  91.              "Explode From Top...",
  92.              "Explode From Bottom...",
  93.              "Explode From Center To Left And Right...",
  94.              "Explode From Left And Right To Center...",
  95.              "Explode From Left To Right...",
  96.              "Explode From Right To Left..."
  97.              };
  98.  
  99. char *delay_text[] = {
  100.   "*  Create Windows",
  101.   "*  Write Text to Windows",
  102.   "*  Hide Windows",
  103.   "*  Resize Windows",
  104.   "*  Get Input From Windows",
  105.   "*  Scroll Up or Down in Windows",
  106.   "*  Change Colors on the fly",
  107.   "*  Create Shadows",
  108.   "*  Create See-Thru Windows",
  109.   "*  Border and Unborder Windows",
  110.   "*  Use Windows Larger than the Physical Screen",
  111.   "*  Create Pop-up, Bar, and PullDown Menus",
  112.   "*  And Much More!",
  113. NULL};
  114.  
  115.  
  116. char *closing_message[] = {
  117. "These are just a sample of the many things you can do with",
  118. "The C Window Library!",
  119. "The C Window Library is guaranteed to cut development time down substantially",
  120. "without putting a lot of strain on your budget!",
  121. " ",
  122. "The full registered version of The C Window Library is only $45. ",
  123. "With the full registered version you will receive technical support, free ",
  124. "upgrades to the next major version, and the full source code.  To receive ",
  125. "the full registered version send check or money order for $45 to",
  126. "  ",
  127. "P. A. McKenzie",
  128. "CitySoft Software",
  129. "100-3 Alcott Place",
  130. "Bronx, NY 10475",
  131. "  ",
  132. "Thank you for running the demo of The C Window Library!!",
  133.   };
  134.  
  135.  
  136.  
  137.  
  138.  
  139. WPOINTER main_window,              /* Main Window */
  140.          help,                     /* Help Window */
  141.          esc_window,               /* Escape Window */
  142.          error_window;             /* Error Window */
  143.  
  144. WPOINTER w[3];                     /* Window Pointers to miscellaneous
  145.                                     * windows */
  146.  
  147. VWPOINTER vw;                      /* Virtual window pointer */
  148.  
  149. VBLOCKPTR v;                       /* Video Block Pointer */
  150.  
  151. int error_check_flag = 1;          /* Turn error checking on (not to be
  152.                                     * confused with the internal variable
  153.                                     * check_window_error) */
  154.  
  155. void main()
  156. {
  157.   int i,d;
  158.   int initrow,initcol;             /* Initial row and column of the cursor */
  159.  
  160.   printf("\nPlease enter: '0' for Direct Screen Writes\n"
  161.      "              '1' for Direct Screen Writes with snow checking\n"
  162.      "              '2' for BIOS Screen updates: ");
  163.   scanf("%d",&d);
  164.  
  165.   /* Get the cursor Position */
  166.   GetCursorPosition(&initrow,&initcol,0);
  167.  
  168.   /* Initialize The C Window Library */
  169.   WindowInitializeSystem();
  170.  
  171.   /* Initialize error function */
  172.   window_error_func = custom_error_func;
  173.   initialize_error();
  174.  
  175.   /* Initialize Direct memory writes, Snow check or BIOS screen updates
  176.    * depending on user's response */
  177.   CHECK_SNOW = d;
  178.   SCREEN_WRITE_METHOD = (d == 2)?BIOS:DMA;
  179.  
  180.   /* Save Initial Screen as a VBLOCK and Clear Screen */
  181.   v = VideoSave(1,1,num_screen_rows,num_screen_cols);
  182.   ClearScreen(NORM);
  183.  
  184.   /* Save What's on the screen now in a window - this gives us the base
  185.    * window to draw on */
  186.   WindowSaveInitial(active_video_page);
  187.  
  188.   /* Initialize and open help window */
  189.   help = WindowInitialize(NOBORDER,25,1,80,1,BLACKONWHITE,BLACKONWHITE,0);
  190.   WindowOpen(help);
  191.   WindowWriteCenterString(help,
  192.   "Up \030   Down \031   Left \033   Right \032   Quit <CR>",1);
  193.  
  194.   /* Initialize and open main window */
  195.   main_window = WindowInitialize(BORDER, 1, 1, 78, 23,BLACKONWHITE,BLACKONWHITE, DOUBLEBOX);
  196.   WindowOpen(main_window);
  197.  
  198.   /* Initialize and open escape window */
  199.   esc_window = WindowInitialize(BORDER,22,54,24,2,WHITEONBLUE,WHITEONBLUE,SINGLEBOX);
  200.   WindowOpen(esc_window);
  201.   WindowPrintf(esc_window,"Press ESC to Quit\nAny other key to advance");
  202.  
  203.   /* Hide Cursor in main window */
  204.   WindowChangeCursor(main_window,INVISIBLE);
  205.  
  206.   /* Write Some Strings to main window */
  207.   WindowWriteCenterString(main_window, "THE C WINDOW LIBRARY DEMO", 1);
  208.   WindowWriteCenterString(main_window, "─────────────────────────", 2);
  209.   WindowWriteCenterString(main_window, title1,0);
  210.   i = 0;
  211.  
  212.   /* Display main window and escape window - make sure escape window is
  213.    * on top by making main window's rank = 2 and the escape window's
  214.    * rank = 1 */
  215.   WindowDisplay(main_window,2,NOEFFECT);
  216.   WindowDisplay(esc_window,1,NOEFFECT);
  217.  
  218.   /* Write info to main window */
  219.   while (screen1[i] != NULL)
  220.   {
  221.     WindowWriteString(main_window, screen1[i], i+3, 1);
  222.     i++;
  223.   }
  224.   i = 0;
  225.   approx_delay(4000);
  226.  
  227.   /* Write Slowly to main window */
  228.   while (delay_text[i] != NULL)
  229.   {
  230.     WindowWriteString(main_window, delay_text[i], i+9, 20);
  231.     i++;
  232.     approx_delay(2000);
  233.   }
  234.   approx_delay(15000);
  235.  
  236.   /* Clear text from a region of the main window */
  237.   WindowClearRegion(main_window, 3, 1, 23, 78);
  238.  
  239.   /* Call main demo() function */
  240.   demo();
  241.  
  242.   /* Dispose of main window */
  243.   WindowFree(main_window,NOEFFECT);
  244.  
  245.   /* Put original screen back and move cursor to startup position*/
  246.   VideoRestore(v);
  247.   MoveCursor(initrow,initcol,0);
  248.  
  249.   /* Change cursor back to original shape */
  250.   ChangeCursor(initial_video_startup.cursor_startline,
  251.                initial_video_startup.cursor_endline);
  252. }
  253.  
  254.  
  255.  
  256. void demo()
  257. {
  258.   int i,j,k;
  259.   int dir;
  260.   char buf[50], buf2[50];
  261.   char *str = "You can also open multiple windows...";
  262.   buf[0] = 0;
  263.  
  264.   /* Initialize and open sub-window 1 */
  265.   w[0] = WindowInitialize(BORDER, 15, 20, 38, 5, CREATE_VIDEO_ATTRIBUTE(blue, lightwhite),
  266.                CREATE_VIDEO_ATTRIBUTE(blue, lightwhite), SINGLEBOX);
  267.   WindowOpen(w[0]);
  268.  
  269.  
  270.   WindowWriteString(main_window,
  271.         "You can choose different border styles ...", 6, 1);
  272.   approx_delay(2000);
  273.  
  274.  
  275.   /* Demonstrate drawing a new border for main window.  Also must rewrite
  276.    * title because title is destroyed when new border is written */
  277.  
  278.   WindowDrawBorder(main_window,DOUBLEBOX);
  279.   WindowWriteCenterString(main_window,title1,0);
  280.   approx_delay(2000);
  281.   WindowDrawBorder(main_window,MIXEDBOX1);
  282.   WindowWriteCenterString(main_window,title1,0);
  283.   approx_delay(2000);
  284.   WindowDrawBorder(main_window,BLANKBOX);
  285.   WindowWriteCenterString(main_window,title1,0);
  286.   approx_delay(2000);
  287.   WindowDrawBorder(main_window,SINGLEBOX);
  288.   WindowWriteCenterString(main_window,title1,0);
  289.   approx_delay(2000);
  290.  
  291.  
  292.   /* Change main window's border attribute */
  293.  
  294.   WindowWriteString(main_window,
  295.         "You can choose different border colors ...", 7, 1);
  296.   approx_delay(3000);
  297.   for (i=0;i<8;i++)
  298.   {
  299.     WindowChangeBorderAttribute(main_window,CREATE_VIDEO_ATTRIBUTE(i,lightwhite));
  300.     approx_delay(1000);
  301.   }
  302.   WindowChangeBorderAttribute(main_window,BLACKONWHITE);
  303.  
  304.  
  305.   /* Change main window's text attribute */
  306.  
  307.   WindowWriteString(main_window,
  308.         "You can also choose different window colors ...", 8, 1);
  309.   approx_delay(3000);
  310.   for (i=0;i<8;i++)
  311.   {
  312.     WindowChangeTextAttribute(main_window,CREATE_VIDEO_ATTRIBUTE(i,lightwhite));
  313.     approx_delay(1000);
  314.   }
  315.   WindowChangeTextAttribute(main_window,BLACKONWHITE);
  316.   approx_delay(1000);
  317.   WindowClearRegion(main_window,3,1,9,70);
  318.  
  319.  
  320.   /* Title sub window 1 and display it */
  321.  
  322.   WindowWriteCenterString(w[0],title2,0);
  323.   WindowDisplay(w[0],2,NOEFFECT);
  324.  
  325.   /* Write text to sub window */
  326.   WindowWriteString(main_window,"You can write text to a window...",3,1);
  327.   approx_delay(1000);
  328.   WindowWriteString(w[0],"Hello, world!",1,1);
  329.   approx_delay(2000);
  330.  
  331.   /* Demonstrate writing text with different colors */
  332.   WindowWriteString(main_window,
  333.      "You can write text with a different colors...",4,1);
  334.   approx_delay(2000);
  335.   WindowWriteStringAttr(w[0],"Hello, World!",2,1,BLACKONWHITE);
  336.   WindowWriteStringAttr(w[0],"Hello, World!",3,1,YELLOWONRED);
  337.   approx_delay(2000);
  338.  
  339.   /* Demonstrate WindowPrintf() */
  340.   WindowWriteString(main_window,"You can even use a printf() for windows!",5,1);
  341.   approx_delay(2000);
  342.   WindowWriteString(main_window,"To demonstrate, I will count to 20...",6,1);
  343.   approx_delay(2000);
  344.   WindowMoveCursor(w[0],4,1);
  345.   for (i=1;i<=20;i++)
  346.   {
  347.     WindowPrintf(w[0],"Count is now %d\n",i);
  348.     approx_delay(1000);
  349.   }
  350.   approx_delay(4000);
  351.   WindowClear(w[0]);
  352.  
  353.   /* Demonstrate right justification of strings in a window */
  354.   WindowWriteString(main_window,
  355.                   "You can write Right Justified strings...",7,1);
  356.   approx_delay(2000);
  357.   WindowWriteStringRJ(w[0],"These strings",1,19);
  358.   WindowWriteStringRJ(w[0],"are printed Right",2,19);
  359.   WindowWriteStringRJ(w[0],"justified!",3,19);
  360.   approx_delay(4000);
  361.  
  362.   /* Demonstrate centering strings around a column in a window */
  363.   WindowWriteString(main_window,
  364.       "You can write strings Centered on a certain column...",8,1);
  365.   approx_delay(2000);
  366.   WindowClear(w[0]);
  367.   WindowWriteStringCC(w[0],"These strings",1,10);
  368.   WindowWriteStringCC(w[0],"are centered on",2,10);
  369.   WindowWriteStringCC(w[0],"column 10",3,10);
  370.   approx_delay(3000);
  371.   WindowClear(w[0]);
  372.   WindowWriteStringCC(w[0],"These strings",1,19);
  373.   WindowWriteStringCC(w[0],"are centered on",2,19);
  374.   WindowWriteStringCC(w[0],"column 19",3,19);
  375.   approx_delay(3000);
  376.   WindowClear(w[0]);
  377.   WindowWriteStringCC(w[0],"These strings",1,29);
  378.   WindowWriteStringCC(w[0],"are centered on",2,29);
  379.   WindowWriteStringCC(w[0],"column 29",3,29);
  380.   approx_delay(3000);
  381.   WindowClearRegion(main_window,3,1,9,70);
  382.   WindowClear(w[0]);
  383.  
  384.   /* Move sub window around on the screen */
  385.   WindowWriteString(main_window,"You can move a window around...",3,1);
  386.   approx_delay(2000);
  387.   for (i=1;i<=10;i++)
  388.   {
  389.     WindowMove(w[0],rand()%15+1,rand()%60+1);
  390.     approx_delay(1000);
  391.   }
  392.   WindowMove(w[0],14,12);
  393.   approx_delay(2000);
  394.  
  395.   /* Slide sub window around on the screen */
  396.   WindowWriteString(main_window,"You can slide a window...",4,1);
  397.   WindowWriteString(main_window,"Press A key to Stop sliding...",5,1);
  398.   while (!ISKEYREADY())
  399.   {
  400.     dir = rand()%4+1;
  401.     if (dir == UP || dir == DOWN)
  402.       WindowSlide(w[0],dir,rand()%10+1);
  403.     else
  404.       WindowSlide(w[0],dir,rand()%30+1);
  405.   }
  406.   approx_delay(5000);
  407.   WindowMove(w[0],15,20);
  408.   WindowHide(w[0],NOEFFECT);
  409.   WindowClearRegion(main_window,3,1,9,70);
  410.  
  411.   /* Erase and display main window using special effects */
  412.   WindowWriteString(main_window,
  413.    "You can remove a window from the screen using special effects",3,1);
  414.   approx_delay(4000);
  415.   for (i=0;i<=11;i++)
  416.   {
  417.     WindowWriteString(main_window,effectstr[i],i+4,1);
  418.     approx_delay(2000);
  419.     WindowHide(main_window,i);
  420.     approx_delay(2000);
  421.       WindowDisplay(main_window,2,i);
  422.     approx_delay(2000);
  423.   }
  424.   WindowClearRegion(main_window,3,1,15,70);
  425.   WindowWriteString(main_window, str, 3, 1);
  426.   approx_delay(5000);
  427.  
  428.   /* Initialize, open, and display two more sub windows */
  429.   w[1] = WindowInitialize(BORDER, 12, 32, 38, 5, CREATE_VIDEO_ATTRIBUTE(green, lightwhite),
  430.   CREATE_VIDEO_ATTRIBUTE(green, lightwhite), SINGLEBOX);
  431.   WindowOpen(w[1]);
  432.   WindowWriteCenterString(w[1],title3,0);
  433.   w[2] = WindowInitialize(BORDER, 9, 38, 38, 5, BLACKONWHITE, BLACKONWHITE,
  434.                           SINGLEBOX);
  435.   WindowOpen(w[2]);
  436.   WindowWriteCenterString(w[2],title4,0);
  437.   WindowDisplay(w[2],2,NOEFFECT);
  438.   WindowDisplay(w[1],2,NOEFFECT);
  439.   WindowDisplay(w[0],2,NOEFFECT);
  440.   WindowWriteString(w[1],"This is window 2",1,1);
  441.   WindowWriteString(w[2],"This is window 3",1,1);
  442.   WindowWriteString(w[0],"This is window 1",1,1);
  443.   approx_delay(2000);
  444.  
  445.   /* Demonstrate writing text to any window at any time */
  446.   WindowWriteString(main_window,"You can write text to any window, at any time",4,1);
  447.   WindowWriteString(main_window,"regardless of which window is on top...",5,1);
  448.   approx_delay(3000);
  449.   write_all(w[0]);
  450.   approx_delay(2000);
  451.   write_all(w[1]);
  452.   approx_delay(2000);
  453.   write_all(w[2]);
  454.   approx_delay(2000);
  455.  
  456.  
  457.   /* Scroll text in sub windows to demonstrate independent scrolling */
  458.   WindowWriteString(main_window,"Press A key to stop scrolling...",7,1);
  459.   approx_delay(2000);
  460.   i = 1;
  461.   while (!ISKEYREADY())
  462.   {
  463.     WindowPrintf(w[0]," Scrolling line %d in window 1\n",i);
  464.     WindowPrintf(w[1]," Scrolling line %d in window 2\n",i);
  465.     WindowPrintf(w[2]," Scrolling line %d in window 3\n",i);
  466.     i++;
  467.   }
  468.   approx_delay(2000);
  469.   WindowWriteString(main_window,"You can change the order around...",8,1);
  470.   approx_delay(2000);
  471.   WindowHide(w[0],0);
  472.   WindowDisplay(w[0],2,0);
  473.   approx_delay(2000);
  474.   WindowDisplay(w[2],2,0);
  475.   approx_delay(2000);
  476.   WindowDisplay(w[1],2,0);
  477.   approx_delay(4000);
  478.  
  479.   /* Slide all of the sub windows */
  480.   slide_windows();
  481.   approx_delay(4000);
  482.  
  483.   /* Change the number of rows displayed on the screen */
  484.   change_screen_size();
  485.   WindowClearRegion(main_window,3,1,15,70);
  486.  
  487.   /* Take off top two sub-windows windows */
  488.   WindowWriteString(main_window,"Let's remove the top two windows..",3,1);
  489.   approx_delay(2000);
  490.   WindowHide(w[1],NOEFFECT);
  491.   approx_delay(1000);
  492.   WindowHide(w[2],NOEFFECT);
  493.   approx_delay(1000);
  494.   WindowClear(w[0]);
  495.  
  496.   /* Demonstrate see-thru window */
  497.   WindowWriteString(main_window,"You can create see-thru windows...",4,1);
  498.   approx_delay(2000);
  499.   WindowMakeSeeThru(w[0]);
  500.   approx_delay(2000);
  501.   WindowWriteString(main_window,
  502.     "Use Cursor Keys to move see-thru window around, RETURN to stop...",5,1);
  503.  
  504.  /* Slide this see-thru window around */
  505.   slide_see_thru_window(w[0]);
  506.  
  507.  /* Make see-thru windoqw a normal window again */
  508.   WindowMakeNormal(w[0]);
  509.   WindowClearRegion(main_window,3,1,15,70);
  510.   WindowWriteString(main_window,
  511.            "You can shadow window in 4 different positions...",3,1);
  512.   approx_delay(2000);
  513.  
  514.   /* Draw Shadow on all 4 possible positions of the window */
  515.   WindowDrawShadow(w[0],SHADOWUPLEFT,2,1,'█',BLACKONWHITE,0);
  516.   approx_delay(2000);
  517.   WindowDrawShadow(w[0],SHADOWUPRIGHT,2,1,'█',BLACKONWHITE,0);
  518.   approx_delay(2000);
  519.   WindowDrawShadow(w[0],SHADOWLOWLEFT,2,1,'█',BLACKONWHITE,0);
  520.   approx_delay(2000);
  521.   WindowDrawShadow(w[0],SHADOWLOWRIGHT,2,1,'█',BLACKONWHITE,0);
  522.   approx_delay(4000);
  523.   WindowClearRegion(main_window,3,1,15,70);
  524.   WindowClearRegion(main_window,20,14,21,70);
  525.   WindowRemoveShadow(w[0]);
  526.  
  527.   /* Demonstrate resizing sub-window */
  528.   WindowWriteString(main_window,"You can resize this window...",3,1);
  529.   approx_delay(4000);
  530.   resize_demo();
  531.  
  532.  
  533.   WindowWriteString(main_window,
  534.   "You can create windows larger than the physical screen ",3,1);
  535.   WindowWriteString(main_window,
  536.      "And scroll this window to see different sections",4,1);
  537.   approx_delay(5000);
  538.  
  539.   /* Initialize a virtual window */
  540.   vw = VirtualInitialize(NOATTRIBUTE,80,80,0);
  541.  
  542.   /* Read a file into the virtual window */
  543.   read_file();
  544.  
  545.   /* Assign viewport to virtual window */
  546.   WindowAssignToVirtual(w[0],vw,1,1);
  547.  
  548.   /* Make viewport larger */
  549.   WindowHide(w[0],NOEFFECT);
  550.   WindowMove(w[0],1,1);
  551.   WindowResizeWidth(w[0],78,ANCHORLEFT);
  552.   WindowResizeHeight(w[0],22,ANCHORTOP);
  553.   WindowDisplay(w[0],2,EXPLODE);
  554.   WindowDisplay(help,3,NOEFFECT);
  555.  
  556.   WindowHide(esc_window,NOEFFECT);
  557.   /* Turn off error checking temporarily */
  558.   error_check_flag = 0;
  559.   pan_window(w[0]);
  560.   /* Turn error checking back on */
  561.   error_check_flag = 1;
  562.   WindowDisplay(esc_window,1,NOEFFECT);
  563.  
  564.   /* Make viewport small again */
  565.   WindowHide(w[0],CONTRACT);
  566.   WindowHide(help,NOEFFECT);
  567.   WindowResizeWidth(w[0],38,ANCHORLEFT);
  568.   WindowResizeHeight(w[0],6,ANCHORTOP);
  569.   WindowMove(w[0],14,12);
  570.  
  571.   /* Make viewport into a normal window again */
  572.   WindowCloseViewport(w[0],0,NOEFFECT);
  573.   VirtualFree(vw,0,NOEFFECT);
  574.   WindowClearRegion(main_window,3,1,15,70);
  575.   WindowMoveCursor(main_window,15,1);
  576.   WindowMove(w[0],14,1);
  577.   WindowResizeWidth(w[0],78,ANCHORLEFT);
  578.   WindowDisplay(w[0],2,0);
  579.  
  580.   /* Demonstrate input routines */
  581.   WindowWriteString(main_window,"You can also get input from windows...",3,1);
  582.   approx_delay(4000);
  583.   buf[0] = 0;
  584.   WindowWriteString(w[0],"Enter Your First Name :",1,1);
  585.  
  586.   /* Get a string */
  587.   WindowGetString(w[0],2,5,buf,'_',1,15,0,"30.");
  588.   WindowMoveCursor(w[0],3,1);
  589.   WindowPrintf(w[0],"You entered %s",buf);
  590.   approx_delay(10000);
  591.   WindowWriteString(main_window,
  592.                "You can get input with a different attribute...",4,1);
  593.   approx_delay(10000);
  594.  
  595.   /* Make sure input buffer's first character is null */
  596.   buf[0] = '\0';
  597.  
  598.   WindowClear(w[0]);
  599.   WindowWriteString(w[0],"Enter Your Last Name :",1,1);
  600.  
  601.   /* Get a string, but the attribute is reversed */
  602.   WindowGetStringAttr(w[0],2,1,buf,'_',1,15,0,BLACKONWHITE,"30.");
  603.   WindowMoveCursor(w[0],3,1);
  604.   WindowPrintf(w[0],"You entered %s",buf);
  605.   approx_delay(10000);
  606.   WindowWriteString(main_window,
  607.                "You can get input with an input mask ..",5,1);
  608.   buf[0] = 0;
  609.   WindowClear(w[0]);
  610.  
  611.   /* Get a string using a character mask */
  612.   WindowWriteString(w[0],"Enter Your Social Security Number :",1,1);
  613.   WindowGetMaskString(w[0],2,1,buf,"___-__-____",'_',1,15,0,"9[0-9]");
  614.   WindowMoveCursor(w[0],3,1);
  615.  
  616.   /* Use mask pattern to format output string */
  617.   TranslateStringToMaskString(buf,"___-__-____",buf2,'_',1);
  618.   WindowPrintf(w[0],"You entered %s",buf2);
  619.   approx_delay(10000);
  620.   buf[0] = 0;
  621.   WindowWriteString(main_window,
  622.     "You can get input with an input mask and have a different attribute..",6,1);
  623.   approx_delay(10000);
  624.   WindowClear(w[0]);
  625.  
  626.  
  627.   /* Get a string using a character mask, but use different attribute */
  628.   WindowWriteString(w[0],"Enter Your Social Security Number :",1,1);
  629.   WindowGetMaskStringAttr(w[0],2,1,buf,"___-__-____",'_',1,15,0,BLACKONWHITE,"9[0-9]");
  630.   WindowMoveCursor(w[0],3,1);
  631.  
  632.   /* Use mask pattern to format output string */
  633.   TranslateStringToMaskString(buf,"___-__-____",buf2,'_',1);
  634.   WindowPrintf(w[0],"You entered %s",buf2);
  635.   approx_delay(10000);
  636.   buf[0] = 0;
  637.   WindowWriteString(main_window,"You can get password input...",7,1);
  638.   approx_delay(10000);
  639.   WindowClear(w[0]);
  640.   WindowWriteString(w[0],"Enter Your Name :",1,1);
  641.  
  642.   /* Get password input */
  643.   WindowGetPassword(w[0],2,1,buf,'_','*',1,15,0,"30.");
  644.   WindowMoveCursor(w[0],3,1);
  645.   WindowPrintf(w[0],"You entered %s",buf);
  646.   approx_delay(10000);
  647.   buf[0] = 0;
  648.   WindowWriteString(main_window,
  649.      "You can get password input with a different attribute..",8,1);
  650.   approx_delay(10000);
  651.   WindowClear(w[0]);
  652.   WindowWriteString(w[0],"Enter Your Name :",1,1);
  653.  
  654.   /* Get password but use different video attribute */
  655.   WindowGetPasswordAttr(w[0],2,1,buf,'_','*',1,15,0,BLACKONWHITE,"30.");
  656.   WindowMoveCursor(w[0],3,1);
  657.   WindowPrintf(w[0],"You entered %s",buf);
  658.   approx_delay(10000);
  659.  
  660.   /* Hide all of the windows */
  661.   WindowHide(w[0],NOEFFECT);
  662.   WindowHide(main_window,NOEFFECT);
  663.   WindowHide(esc_window,NOEFFECT);
  664.  
  665.   /* Clear the screen */
  666.   ClearScreen(NORM);
  667.  
  668.   /* Demonstrate writing to the screen without using window functions */
  669.   VideoWriteString(
  670.       "You also have non-window related, fast video functions.",1,1);
  671.   VideoWriteString(
  672. "To demonstrate, the normal printf() function will be used to fill the screen",2,1);
  673.   VideoWriteString("Press a key to start demonstration...",4,1);
  674.   GET_KEY();
  675.  
  676.   /* Move Cursor to (1,1) */
  677.   MoveCursor(1,1,0);
  678.  
  679.   /* Loop until all rows are filled with our message using normal printf() */
  680.   for (i=0; i<num_screen_rows; i++)
  681.     printf("Using the normal printf() function call\n");
  682.   printf("Press a key to demonstrate the C Window Libraries fast video ...");
  683.   GET_KEY();
  684.  
  685.   /* Clear the screen */
  686.   ClearScreen(NORM);
  687.  
  688.   /* Move Cursor to (1,1) */
  689.   MoveCursor(1,1,0);
  690.  
  691.   /* Do same thing as before, butr use VideoPrintf() */
  692.   for (i=0;i<num_screen_rows;i++)
  693.     VideoPrintf(
  694.           "Using the C Window Libraries VideoPrintf() function call\n");
  695.   approx_delay(20000);
  696.   WindowClearRegion(main_window,3,1,23,70);
  697.  
  698.   /* Write closing message */
  699.   WindowWriteCenterString(main_window,closing_message[0],5);
  700.   for (i=2;i<=9;i++)
  701.     WindowWriteString(main_window,closing_message[i],i+6,1);
  702.   for (i=10;i<=13;i++)
  703.     WindowWriteCenterString(main_window,closing_message[i],i+6);
  704.   WindowDisplay(main_window,2,NOEFFECT);
  705.   i = 1;
  706.  
  707.   /* Change video attribute until a key is pressed for the desired effect */
  708.   while(!ISKEYREADY())
  709.   {
  710.     j = i % 16;
  711.     if (j == 0)
  712.       j = 1;
  713.     k =
  714.   CREATE_VIDEO_ATTRIBUTE(GET_BGROUND_COLOR(WINDOW_TEXT_COLOR(main_window)),j);
  715.     WindowWriteCenterStringAttr(main_window,closing_message[1],6,k);
  716.     WindowWriteCenterStringAttr(main_window,closing_message[15],21,k);
  717.     i++;
  718.     delay(10);
  719.   }
  720. }
  721.  
  722.  
  723. void resize_demo(void)
  724. /************************************************************************
  725.  * This demo demonstrates the resizing features of the C Window Library *
  726.  ***********************************************************************/
  727. {
  728.   int i;
  729.  
  730.   /* Get original width and height */
  731.   int h = WINDOW_HEIGHT(w[0]);
  732.   int wid = WINDOW_WIDTH(w[0]);
  733.  
  734.  
  735.   /* Resize Height of window.  Also rewrite title because border text is
  736.    * destroyed when window is resized */
  737.   for (i=h+2;i<=17;i+=2)
  738.   {
  739.     WindowResizeHeight(w[0],i,ANCHORBOTTOM);
  740.     WindowWriteCenterString(w[0],title2,0);
  741.     approx_delay(200);
  742.   }
  743.   for (i=17;i>=h;i-=2)
  744.   {
  745.     WindowResizeHeight(w[0],i,ANCHORTOP);
  746.     WindowWriteCenterString(w[0],title2,0);
  747.     approx_delay(200);
  748.   }
  749.   for (i=h+2;i<=17;i+=2)
  750.   {
  751.     WindowResizeHeight(w[0],i,ANCHORTOP);
  752.     WindowWriteCenterString(w[0],title2,0);
  753.     approx_delay(200);
  754.   }
  755.   for (i=17;i>=h;i-=2)
  756.   {
  757.     WindowResizeHeight(w[0],i,ANCHORBOTTOM);
  758.     WindowWriteCenterString(w[0],title2,0);
  759.     approx_delay(200);
  760.   }
  761.  
  762.  
  763.   /* Resize width of window.  Also rewrite title because border text is
  764.    * destroyed when window is resized */
  765.  
  766.   for (i=wid+2;i<=60;i+=3)
  767.   {
  768.     WindowResizeWidth(w[0],i,ANCHORLEFT);
  769.     WindowWriteCenterString(w[0],title2,0);
  770.     approx_delay(200);
  771.   }
  772.   for (i=60;i>=wid;i-=3)
  773.   {
  774.     WindowResizeWidth(w[0],i,ANCHORRIGHT);
  775.     WindowWriteCenterString(w[0],title2,0);
  776.     approx_delay(200);
  777.   }
  778.   for (i=wid+2;i<=60;i+=3)
  779.   {
  780.     WindowResizeWidth(w[0],i,ANCHORRIGHT);
  781.     WindowWriteCenterString(w[0],title2,0);
  782.     approx_delay(200);
  783.   }
  784.   for (i=60;i>=wid+2;i-=3)
  785.   {
  786.     WindowResizeWidth(w[0],i,ANCHORLEFT);
  787.     WindowWriteCenterString(w[0],title2,0);
  788.     approx_delay(200);
  789.   }
  790. }
  791. /**********************************************************
  792.  * Gets a filename and displays it in the virtual window  *
  793.  *********************************************************/
  794. read_file()
  795. {
  796.     int ch;
  797.     unsigned r = 1, c = 1;
  798.     infile = fopen("demo.c","r");  /* read file name into window */
  799.     while(1)
  800.     {
  801.       ch = fgetc(infile);          /* get a character */
  802.       if (feof(infile))
  803.         break;
  804.       if (ch != '\n' && c <= 80)   /* check if safe to write to virtual
  805.                                     * window  */
  806.         VirtualWriteRepeatCharacter(vw,ch,r,c++,1); /* write character to vw */
  807.       else
  808.       {
  809.         if (c > 80)
  810.        /* read until '\n' is reached */
  811.           while((ch = fgetc(infile)) != '\n')
  812.          ;
  813.         r++;                    /* increment row */
  814.         if (r > 80) break;
  815.           c=1;
  816.       }
  817.     }
  818.     fclose(infile);             /* close input file */
  819.     return 0;
  820. }
  821.  
  822.  
  823. /* Write alphabet to window */
  824. write_all(WPOINTER win)
  825. {
  826.   int i;
  827.   for (i = 1; i <= WINDOW_HEIGHT(win); i++)
  828.     WindowWriteString(win,"ABCDEFGHIJKLMNOPQRSTUVWXYZ",i,1);
  829.   return 0;
  830. }
  831.  
  832.  
  833.  
  834. /******************************
  835.  * Slide window demonstration *
  836.  *****************************/
  837. void slide_see_thru_window(WPOINTER win)
  838. {
  839.   int ch = 0;
  840.   /* Keep going until RETURN key is pressed */
  841.   while(ch != RETURN)
  842.   {
  843.     /* Get a key and slide 1 character in the desired direction */
  844.     switch(ch = GET_KEY())
  845.     {
  846.       case UARROW:
  847.         WindowSlide(win,UP,1);
  848.       break;
  849.       case DARROW:
  850.         WindowSlide(win,DOWN,1);
  851.       break;
  852.       case LARROW:
  853.         WindowSlide(win,LEFT,1);
  854.       break;
  855.       case RARROW:
  856.         WindowSlide(win,RIGHT,1);
  857.       break;
  858.       case 13:
  859.         WindowMove(win,14,12);
  860.       break;
  861.     }
  862.   }
  863. }
  864.  
  865.  
  866. /*********************************
  867.  * Scroll viewport demonstration *
  868.  ********************************/
  869. pan_window(WPOINTER win)
  870. {
  871.   int ch = 0;
  872.  
  873.   /* keep going until Escape or Return key is pressed */
  874.   /* Error checking is temporarily disabled because you may attempt to scroll
  875.    * beyond the bounds of the window */
  876.  
  877.   while(ch != ESC && ch != RETURN)
  878.   {
  879.     switch(ch = GET_KEY())
  880.     {
  881.       case UARROW:
  882.         WindowScrollViewport(win,1,UP);
  883.       break;
  884.       case DARROW:
  885.         WindowScrollViewport(win,1,DOWN);
  886.       break;
  887.       case LARROW:
  888.         WindowScrollViewport(win,1,LEFT);
  889.       break;
  890.       case RARROW:
  891.         WindowScrollViewport(win,1,RIGHT);
  892.       break;
  893. /*      case ESC:
  894.         VideoRestore(v);
  895.       break;            */
  896.       case RETURN:
  897.       break;
  898.     }
  899.   }
  900. }
  901.  
  902.  
  903. /* Delay function that either exits when you press a key, or when time
  904.  * runs out.  Demo is terminated if ESC key is pressed  */
  905.  
  906. approx_delay(int mil)
  907. {
  908.   unsigned start = 5;
  909.   int ch;
  910.  
  911.   /* quit if key is in keyboard buffer */
  912.   while(!ISKEYREADY())
  913.   {
  914.     delay(10);
  915.     start+=10;
  916.   /* return because time ran out */
  917.     if (start > mil)
  918.       return 0;
  919.   }
  920.   /* read the key */
  921.   ch = GET_KEY();
  922.  
  923.   /* quit demo if the Escape key was pressed */
  924.   if (ch == ESC)
  925.   {
  926.     /* Restore original screen */
  927.     VideoRestore(v);
  928.     exit(0);
  929.   }
  930.   return 0;
  931. }
  932.  
  933.  
  934.  
  935. /**********************************************************************
  936.  * Changes screen rows.  This routine exits if the hardware dowes not *
  937.  * support screen rows > 25 lines.                                    *
  938.  *********************************************************************/
  939. int change_screen_size()
  940. {
  941.   int rows,oldrows = num_screen_rows;
  942.   WindowClearRegion(main_window,3,1,15,70);
  943.   WindowWriteString(main_window,"You can change screen size...",5,1);
  944.   approx_delay(5000);
  945.  
  946.   /* Check for VGA mode */
  947.   if (VGA_MODE_ON)
  948.     SetVideoRows(rows=50,0);
  949.  
  950.   else
  951.  
  952.   /* Check for EGA or MCGA mode */
  953.   if (EGA_MODE_ON || MCGA_MODE_ON)
  954.     SetVideoRows(rows=43,0);
  955.  
  956.   /* Video cannot change rows, so exit */
  957.   else
  958.   {
  959.     WindowWriteString(main_window,
  960.   "Sorry, your video adapter does not support more than 25 rows...",6,1);
  961.     approx_delay(8000);
  962.     return 0;
  963.   }
  964.  
  965.   /* Adjust all global data in The C Window Library to reflect the new
  966.    * number of rows */
  967.   AdjustScreenInfo(0);
  968.  
  969.   /* Resize the height of the main window */
  970.   WindowResizeHeight(main_window,rows-2,ANCHORTOP);
  971.   WindowWriteCenterString(main_window,title1,0);
  972.  
  973.   /* Slide all sub-windows */
  974.   slide_windows();
  975.   WindowWriteString(main_window,"Press a key to change back to 25 rows",6,1);
  976.   GET_KEY();
  977.  
  978.   /* Resize window.  This must be done so that the window will fit in a
  979.    * 25 row screen (or whatever the old number of video rows were) */
  980.   WindowResizeHeight(main_window,oldrows-2,ANCHORTOP);
  981.   WindowWriteCenterString(main_window,title1,0);
  982.   SetVideoRows(oldrows,0);
  983.  
  984.   /* Readjust global data */
  985.   AdjustScreenInfo(0);
  986.   return 0;
  987. }
  988.  
  989.  
  990. /* Slide all 3 sub-windows randomly */
  991. slide_windows()
  992. {
  993.   int i,j,k;
  994.   WindowWriteString(main_window,"Press a key to stop sliding...",9,1);
  995.   approx_delay(2000);
  996.   while (!ISKEYREADY())
  997.   {
  998.     i = rand()%3;
  999.     j = rand()%4+1;
  1000.     if (j == UP || j == DOWN)
  1001.       k = rand()%15+1;
  1002.     else
  1003.       k = rand()%50+1;
  1004.     WindowSlide(w[i],j,k);
  1005.   }
  1006.   WindowMove(w[0],15,20);
  1007.   WindowMove(w[1],14,14);
  1008.   WindowMove(w[2],16,24);
  1009.   return 0;
  1010. }
  1011.  
  1012.  
  1013. void initialize_error()    /* Initialize error window and error handler */
  1014. {
  1015.   error_window =
  1016.     WindowInitialize(BORDER,1,1,60,5,WHITEONRED,WHITEONRED,SINGLEBOX);
  1017.   WindowOpen(error_window);
  1018.   window_error_func = custom_error_func;  /* Assign error function */
  1019. }
  1020.  
  1021.  
  1022. void custom_error_func(int errcode, char *sourcefile, int sourceline,
  1023.                char *funcname)
  1024. {
  1025.   int ch;
  1026.   if (error_check_flag)
  1027.   {
  1028.     MakeSound(100,500);           /* Beep */
  1029.     if (errcode == NO_HEAP_MEM)   /* Always check for the heap memory error
  1030.                    separately */
  1031.     {
  1032.       VideoWriteString("You have ran out of Heap Memory",1,1);
  1033.       VideoWriteString(
  1034.          "Press 'Q' to quit program, Any other key to Continue...",2,1);
  1035.     }
  1036.     else                         /* Display error window */
  1037.     {
  1038.       WindowClear(error_window);
  1039.       WindowDisplay(error_window,1,EXPLODE);
  1040.       WindowPrintf(error_window,
  1041.        "Error Code: %d\nSource File: %s\nSource Line %d\nError Occurred in %s",
  1042.        errcode,sourcefile,sourceline,funcname);
  1043.       WindowWriteString(error_window,
  1044.     "Press 'Q' to quit program, Any other key to Continue...",5,1);
  1045.     }
  1046.     ch = GET_KEY();
  1047.     if (ch == 'Q' || ch == 'q')
  1048.     {
  1049.       VideoRestore(v);
  1050.       exit(0);
  1051.     }
  1052.     else
  1053.     if (errcode != NO_HEAP_MEM)
  1054.       WindowHide(error_window,CONTRACT);
  1055.   }
  1056. }
  1057.