home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / cprog / cursesp.zip / DEMO.C < prev    next >
C/C++ Source or Header  |  1991-12-03  |  8KB  |  322 lines
  1. /*  Demo.c  -  A demo program using pc curses. The program illustrate
  2.     the use of colours for text output.   */
  3.  
  4. #include <stdio.h>
  5. #include <signal.h>
  6. #include <time.h>
  7. #include "curses.h"
  8.  
  9. //
  10. //  The Australian map
  11. //
  12. char    *AusMap[16] =
  13. {   
  14.     "           A           A ",
  15.     "    N.T. AAAAA       AAAA ",
  16.     "     AAAAAAAAAAA  AAAAAAAA ",
  17.     "   AAAAAAAAAAAAAAAAAAAAAAAAA Qld.",
  18.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  19.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  20.     " AAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  21.     "   AAAAAAAAAAAAAAAAAAAAAAAAA N.S.W.",
  22.     "W.A. AAAAAAAAA      AAAAAA Vic.",
  23.     "       AAA   S.A.     AA",
  24.     "                           A  Tas.",
  25.     ""
  26. };
  27.  
  28. //
  29. //  Funny messages
  30. //
  31. #define NMESSAGES   6
  32.  
  33. char    *messages[] =
  34. {   
  35.     "Hello from the Land Down Under",
  36.     "The Land of crocs. and a big Red Rock",
  37.     "Where the sunflower runs along the highways",
  38.     "the dusty red roads lead one to loneliness",
  39.     "Blue sky in the morning and",
  40.     "freezing nights and twinkling stars",
  41.     ""
  42. };
  43.  
  44. //
  45. //  Main driver
  46. //
  47. main()
  48. {
  49. WINDOW  *win;
  50. int     w, x, y, i, j, c, len;
  51. time_t  t;
  52. char    buffer[80], *message;
  53. int     width, height;
  54. int     save[80];
  55. void    trap();
  56.  
  57.     initscr();
  58.     signal(SIGINT, trap);
  59.     width  = 48;
  60.     height = 13;                // Create a drawing window
  61.     win = newwin(height, width, (_LINES-height)/2, (_COLS-width)/2);
  62.     if(win == NULL)
  63.     {   endwin();
  64.         return 1;
  65.     }
  66.  
  67.     while(1)
  68.     {   wattrset(win, F_GRAY | B_BLUE);
  69.         werase(win);
  70.  
  71.         wattrset(win, F_RED | B_RED);
  72.         box(win, '-', '+');
  73.         wrefresh(win);
  74.                                 // Do ramdom output of a character
  75.         wattrset(win, F_GRAY | B_BLUE);
  76.         c = 'a';
  77.         for(i=0; i < 5000; ++i)
  78.         {   x = rand() % (width-2)  + 1;
  79.             y = rand() % (height-2) + 1;
  80.             mvwaddch(win, y, x, c);
  81.             wrefresh(win);
  82.             if(kbhit())
  83.                 break;
  84.             if(i == 2000)
  85.             {   c = 'b';
  86.                 wattron(win, F_CYAN | B_BROWN);
  87.             }
  88.         }
  89.  
  90.         SubWinTest(win);
  91.                                 // Erase and draw green window
  92.         wattrset(win, B_GREEN | F_BROWN | A_HIGH);
  93.         werase(win);
  94.         wrefresh(win);
  95.                                 // Draw RED bounding box
  96.         wattrset(win, F_RED | B_RED);
  97.         box(win, ' ', ' ');
  98.         wrefresh(win);
  99.                                 // Display Australia map
  100.         wattrset(win, B_GREEN | F_BROWN | A_HIGH);
  101.         i = 0;
  102.         while(*AusMap[i])
  103.         {   mvwaddstr(win, i+1, 8, AusMap[i]);
  104.             wrefresh(win);
  105.             delay(100);
  106.             ++i;
  107.         }
  108.  
  109.         wattrset(win, A_BLINK| F_BLUE | B_GRAY);
  110.         mvwaddstr(win, height-2, 12, " PC curses for Ansi-C ");
  111.         wrefresh(win);
  112.  
  113.                                 // Draw running messages
  114.         wattrset(win, F_BROWN | B_GRAY);
  115.         message = messages[0];
  116.         len = strlen(message);
  117.         j = 0;
  118.         i = 2;
  119.         w = width-2;
  120.         while(j < NMESSAGES)
  121.         {   strncpy(buffer, message, w - i);
  122.             buffer[w-i] = 0;
  123.             mvwaddstr(win, height/2, i, buffer);
  124.             if(w - i < len)
  125.             {   memset(buffer, ' ', i);
  126.                 strcpy(buffer, message + (w - i));
  127.                 buffer[strlen(buffer)]   = ' ';
  128.                 buffer[i-2] = '\0';
  129.                 mvwaddstr(win, height/2, 2, buffer);
  130.             }                
  131.             wrefresh(win);
  132.             if(kbhit()) 
  133.             {   bioskey(0);
  134.                 break;
  135.             }
  136.             mvwaddch(win, height/2, i, ' ');
  137.             i = ++i % w;
  138.             if(i < 2)
  139.             {   message = messages[++j%NMESSAGES];
  140.                 memset(buffer, ' ', w-2);
  141.                 buffer[w-2] = 0;
  142.                 mvwaddstr(win, height/2, 2, buffer);
  143.                 i = 2;
  144.             }
  145.             delay(300);
  146.         }
  147.  
  148.         j = 0;
  149.                                 //  Draw running As across in RED
  150.         wattron(win, B_GREEN|F_RED);
  151.         for(i=2; i < width - 4; ++i)
  152.         {   c = wgetatpos(win, 4, i);
  153.             save[j++] = c;
  154.             c = c & 0x7f;
  155.             mvwaddch(win, 4, i, c);
  156.         }
  157.         wrefresh(win);
  158.  
  159.                                 // Put a message up wait for a key
  160.         i = height-2;
  161.         wattrset(win, F_BLUE | B_GRAY);
  162.         mvwaddstr(win, i, 12, " Type a key to continue ");
  163.         wrefresh(win);
  164.  
  165.         if(WaitForUser() == 0x1b)
  166.             break;
  167.  
  168.         j = 0;                  // Restore the old line 
  169.         for(i=2; i < width - 4; ++i)
  170.             wputatpos(win, 4, i, save[j++]);
  171.         wrefresh(win);
  172.  
  173.         BouncingBalls(win);
  174.                                 // Put a message up wait for a key
  175.         i = height-2;
  176.         wattrset(win, F_BLUE | B_GRAY);
  177.         mvwaddstr(win, i, 12, " Hit ESC key to exit ...");
  178.         wrefresh(win);
  179.         if(WaitForUser() == 0x1b)
  180.             break;
  181.     }
  182. exit:
  183.     endwin();
  184.     return 0;
  185. }
  186.  
  187. //
  188. // Test sub windows
  189. //
  190. SubWinTest(WINDOW *win)
  191. {
  192. int     w, h, sw, sh, bx, by;
  193. WINDOW  *swin1, *swin2, *swin3;
  194.  
  195.     w  = win->_maxx;
  196.     h  = win->_maxy;
  197.     bx = win->_begx;
  198.     by = win->_begy;
  199.     sw = w / 3;
  200.     sh = h / 3;
  201.     if((swin1 = subwin(win, sh, sw, by+3, bx+5)) == NULL)
  202.         return  1;
  203.     if((swin2 = subwin(win, sh, sw, by+4, bx+8)) == NULL)
  204.         return  1;
  205.     if((swin3 = subwin(win, sh, sw, by+5, bx+11)) == NULL)
  206.         return  1;
  207.     wattron(swin1, B_BLUE    | F_RED);
  208.     werase(swin1);
  209.     mvwaddstr(swin1, 0, 3, "Sub-window 1");
  210.     wrefresh(swin1);
  211.  
  212.     wattron(swin2, B_MAGENTA | F_CYAN);
  213.     werase(swin2);
  214.     mvwaddstr(swin2, 0, 3, "Sub-window 2");
  215.     wrefresh(swin2);
  216.  
  217.     wattron(swin3, B_GREEN   | F_BROWN);
  218.     werase(swin3);
  219.     mvwaddstr(swin3, 0, 3, "Sub-window 3");
  220.     wrefresh(swin3);
  221.  
  222.     delwin(swin1);
  223.     delwin(swin2);
  224.     delwin(swin3);
  225.     WaitForUser();
  226.     return  0;
  227. }
  228.  
  229. //
  230. //  Bouncing balls
  231. //
  232. BouncingBalls(WINDOW *win)
  233. {
  234. int     c1, c2, c3, w, h;
  235. int     x1, y1, xd1, yd1;
  236. int     x2, y2, xd2, yd2;
  237. int     x3, y3, xd3, yd3;
  238.  
  239.     w    = win->_maxx;
  240.     h    = win->_maxy;
  241.     x1   = 2 + rand() % (w - 4);
  242.     y1   = 2 + rand() % (h - 4);
  243.     x2   = 2 + rand() % (w - 4);
  244.     y2   = 2 + rand() % (h - 4);
  245.     x3   = 2 + rand() % (w - 4);
  246.     y3   = 2 + rand() % (h - 4);
  247.     xd1  = 1; yd1 = 1;
  248.     xd2  = 1; yd2 = 0;
  249.     xd3  = 0; yd3 = 1;
  250.     while(bioskey(1) == 0)
  251.     {   x1 = xd1 > 0 ? ++x1 : --x1;
  252.         if(x1 <= 1 || x1 >= w - 2)
  253.             xd1 = xd1 ? 0 : 1;
  254.         y1 = yd1 > 0 ? ++y1 : --y1;
  255.         if(y1 <= 1 || y1 >= h - 2)
  256.             yd1 = yd1 ? 0 : 1;
  257.  
  258.         x2 = xd2 > 0 ? ++x2 : --x2;
  259.         if(x2 <= 1 || x2 >= w - 2)
  260.             xd2 = xd2 ? 0 : 1;
  261.         y2 = yd2 > 0 ? ++y2 : --y2;
  262.         if(y2 <= 1 || y2 >= h - 2)
  263.             yd2 = yd2 ? 0 : 1;
  264.  
  265.         x3 = xd3 > 0 ? ++x3 : --x3;
  266.         if(x3 <= 1 || x3 >= w - 2)
  267.             xd3 = xd3 ? 0 : 1;
  268.         y3 = yd3 > 0 ? ++y3 : --y3;
  269.         if(y3 <= 1 || y3 >= h - 2)
  270.             yd3 = yd3 ? 0 : 1;
  271.  
  272.         c1 = wgetatpos(win, y1, x1);  
  273.         c2 = wgetatpos(win, y2, x2);
  274.         c3 = wgetatpos(win, y3, x3);
  275.  
  276.         wattrset(win, B_BLUE  | F_RED);
  277.         mvwaddch(win, y1, x1, 'O');
  278.         wattrset(win,  B_RED   | F_BLUE);
  279.         mvwaddch(win, y2, x2, '*');
  280.         wattrset(win,  B_GRAY  | F_BROWN);
  281.         mvwaddch(win, y3, x3, '@');
  282.         wmove(win, 0, 0);
  283.         wrefresh(win);
  284.         wputatpos(win, y1, x1, c1);
  285.         wputatpos(win, y2, x2, c2);
  286.         wputatpos(win, y3, x3, c3);
  287.         delay(150);
  288.     }
  289.     return 0;
  290. }
  291.  
  292. //
  293. //  Wait for user
  294. //
  295. WaitForUser()
  296. {
  297. time_t  t;
  298.  
  299.     t = time((time_t *)0);
  300.     while(1)                         
  301.     {   if(bioskey(1))
  302.         {   if((bioskey(0) & 0x7f) == 0x1b)
  303.                 return  0x1b;
  304.             else
  305.                 return  0;
  306.         }
  307.         if(time((time_t *)0) - t > 5)
  308.             return  0;
  309.     }
  310. }
  311.  
  312. //
  313. //  Trap interrupt
  314. //
  315. void trap()
  316. {
  317.     endwin();
  318.     exit(0);
  319. }
  320.  
  321. //  End of demo.c
  322.