home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / window / popups / popups.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-01-19  |  20.7 KB  |  897 lines
  1. /*
  2.     popups.c
  3.     a multi level pop up window module
  4.  
  5. */
  6.  
  7.  
  8. #include <stdio.h>
  9. #include <conio.h>
  10.  
  11.  
  12. #define VERSION 101
  13.  
  14. #define FALSE 0
  15. #define TRUE 1
  16.  
  17. #define SPACE 0x20
  18. #define POPERR -1
  19.  
  20. #define DEFAULT_WAIT 0x0019
  21. #define DEFAULT_TONE 0x0100
  22. #define DEFAULT_STEP 0x0100
  23.  
  24. #define NO_SHADOW 0
  25. #define TOP_LEFT_SHADOW 1
  26. #define TOP_RIGHT_SHADOW 2
  27. #define BOTTOM_LEFT_SHADOW 3
  28. #define BOTTOM_RIGHT_SHADOW 4
  29. #define TOP_LEFT_WIDE 6
  30. #define TOP_RIGHT_WIDE 7
  31. #define BOTTOM_LEFT_WIDE 8
  32. #define BOTTOM_RIGHT_WIDE 9
  33.  
  34.  
  35.  
  36. #define NO_BORDER 0
  37. #define SINGLE_BORDER 1
  38. #define DOUBLE_BORDER 2
  39. #define THIN_BORDER 3
  40. #define THICK_BORDER 4
  41.  
  42. #define OLD_SCREEN 4000    /* 4000 for 80 column    2000 for 40 column */
  43. #define FULL_SCREEN 4000   /* 4000 for 80 column    2000 for 40 column */
  44. #define MAX_WINDOW 25      /* max windows even if buffer not full */
  45. #define MAX_SCREENS 5      /* max number of FULL_SCREENS to buffer (1 - 8) */
  46. #define BUF_SIZE FULL_SCREEN * MAX_SCREENS
  47. #define PARAMS 9
  48.  
  49. static char scrbuf[BUF_SIZE];  /* storage buffer for previous window */
  50. static char *scrbufptr;         /* pointer to last window in buffer */
  51. static char oldscr[OLD_SCREEN];
  52. static char explode_w,shrink_w,shadow_w,noise_w,shadow_edge;
  53. static unsigned char init[1] = { 0 };
  54. static unsigned char bord[8] = { NO_BORDER,' ',' ',' ',' ',' ',' ',' ' };
  55. static int param[PARAMS*(MAX_WINDOW+1)];
  56. static unsigned int explode_wait,shrink_wait;
  57. static int popup_mode,pop_id,shadow_attr;
  58. static int rn,rw;
  59. static unsigned int tone,tone_step;
  60. static struct text_info initial_info;
  61.  
  62. /*************************************************************************/
  63.  
  64. init_popup(mode,left,top,right,bottom,foreground,background,border,bordertype)
  65. int mode,left,top,right,bottom,foreground,background,border,bordertype;
  66. {
  67.     int pptr;
  68.  
  69.         if (init[0] != 0)
  70.             return POPERR;
  71.  
  72.         init[0] = 1;
  73.  
  74.         shadow_w = NO_SHADOW;
  75.         shadow_attr = BLACK;
  76.         noise_w = explode_w = shrink_w = FALSE;
  77.         explode_wait = shrink_wait = DEFAULT_WAIT;
  78.         tone = DEFAULT_TONE;
  79.         tone_step = DEFAULT_STEP;
  80.  
  81.         gettextinfo(&initial_info);
  82.  
  83.         if (initial_info.currmode < 2)
  84.             gettext(1,1,40,25,oldscr);
  85.         else
  86.             gettext(1,1,80,25,oldscr);
  87.  
  88.         if (mode < 2) {
  89.             rn = 40;
  90.             rw = 38;
  91.         }
  92.         else {
  93.             rn = 80;
  94.             rw = 78;
  95.         }
  96.         popup_mode = mode;
  97.         textmode(mode);
  98.          scrbufptr = &scrbuf[0];
  99.         pop_id = 0;
  100.  
  101.         param[0] = left;
  102.         param[1] = top;
  103.         param[2] = right;
  104.         param[3] = bottom;
  105.         param[4] = foreground;
  106.         param[5] = background;
  107.         param[6] = border;
  108.         param[7] = bordertype;
  109.         param[8] = NO_SHADOW;
  110.  
  111.         delay(explode_wait);
  112.  
  113.         build_window();
  114.         return pop_id;
  115.  
  116. }
  117.  
  118. /*************************************************************************/
  119.  
  120. uninit_popup()
  121. {
  122.  
  123.     if (pop_id)
  124.         return POPERR;
  125.     abandon_popup();
  126.  
  127. }
  128.  
  129. /*************************************************************************/
  130.  
  131. abandon_popup()
  132. {
  133.  
  134.     if (!init[0])
  135.         return POPERR;
  136.  
  137.  
  138.     textmode(initial_info.currmode);
  139.  
  140.     if (initial_info.currmode < 2)
  141.         puttext(1,1,40,25,oldscr);
  142.     else
  143.         puttext(1,1,80,25,oldscr);
  144.  
  145.     window(initial_info.winleft,initial_info.wintop,initial_info.winright,initial_info.winbottom);
  146.     textattr(initial_info.attribute);
  147.     gotoxy(initial_info.curx,initial_info.cury);
  148.  
  149. }
  150.  
  151. /****************************************************************************/
  152.  
  153. version_pop()
  154. {
  155.     return VERSION;
  156. }
  157.  
  158. /****************************************************************************/
  159.  
  160. shrink(tog)
  161. char tog;
  162. {
  163.     shrink_w = tog;
  164. }
  165.  
  166. /****************************************************************************/
  167.  
  168. explode(tog)
  169. char tog;
  170. {
  171.     explode_w = tog;
  172. }
  173.  
  174. /****************************************************************************/
  175.  
  176. shadow(shade)
  177. char shade;
  178. {
  179.     shadow_w = shade;
  180. }
  181.  
  182. /****************************************************************************/
  183.  
  184. shadow_color(sattr)
  185. int sattr;
  186. {
  187.     shadow_attr = sattr;
  188. }
  189.  
  190.  
  191.  
  192. /****************************************************************************/
  193.  
  194. explode_delay(del)
  195. unsigned int del;
  196. {
  197.     if (!del)
  198.         return explode_wait;
  199.     else
  200.         explode_wait = del;
  201. }
  202.  
  203. /****************************************************************************/
  204.  
  205. shrink_delay(del)
  206. unsigned int del;
  207. {
  208.     if (!del)
  209.         return shrink_wait;
  210.     else
  211.         shrink_wait = del;
  212. }
  213.  
  214. /****************************************************************************/
  215.  
  216. noise(tog)
  217. char tog;
  218. {
  219.     noise_w = tog;
  220. }
  221.  
  222. /****************************************************************************/
  223.  
  224. noise_tone(stone)
  225. unsigned int stone;
  226. {
  227.     if (!stone)
  228.         return tone;
  229.     else
  230.         tone = stone;
  231. }
  232.  
  233. /****************************************************************************/
  234.  
  235. noise_step(stone)
  236. unsigned int stone;
  237. {
  238.     if (!stone)
  239.         return tone_step;
  240.     else
  241.         tone_step = stone;
  242. }
  243.  
  244. /*************************************************************************/
  245.  
  246. id_popup()
  247. {
  248.     return pop_id;
  249. }
  250.  
  251. /*************************************************************************/
  252.  
  253. pop_max()
  254. {
  255.     return MAX_WINDOW;
  256. }
  257.  
  258. /*************************************************************************/
  259.  
  260. pop_left()
  261. {
  262.     return (MAX_WINDOW - pop_id);
  263. }
  264.  
  265. /*************************************************************************/
  266.  
  267. buf_max()
  268. {
  269.     return BUF_SIZE;
  270. }
  271.  
  272. /*************************************************************************/
  273.  
  274. buf_left()
  275. {
  276.     return (BUF_SIZE-(scrbufptr - &scrbuf[0]));
  277. }
  278.  
  279. /*************************************************************************/
  280.  
  281. high_popup()
  282. {
  283.     int pptr,high;
  284.  
  285.     pptr = (pop_id*PARAMS);
  286.     high = ((param[pptr+3] - param[pptr+1]) +1);
  287.     if (param[pptr+7] != NO_BORDER)
  288.         high -= 2;
  289.     return high;
  290. }
  291.  
  292. /*************************************************************************/
  293.  
  294. wide_popup()
  295. {
  296.     int pptr,wide;
  297.  
  298.     pptr = (pop_id*PARAMS);
  299.     wide = ((param[pptr+2] - param[pptr]) +1);
  300.     if (param[pptr+7] == THICK_BORDER)
  301.         wide -= 4;
  302.     else if (param[pptr+7] != NO_BORDER)
  303.         wide -= 2;
  304.  
  305.     return wide;
  306. }
  307.  
  308. /*************************************************************************/
  309.  
  310. next_popup(left,top,right,bottom,foreground,background,border,bordertype)
  311. int left,top,right,bottom,foreground,background,border,bordertype;
  312. {
  313.     int pptr,offx,offy,ox,oy;
  314.  
  315.     if (shadow_w) {
  316.         shadow_edge = FALSE;
  317.  
  318.         if (shadow_w > BOTTOM_RIGHT_SHADOW) {
  319.             if ((left < 3) || (right > rw))
  320.                 shadow_edge = TRUE;
  321.         }
  322.  
  323.         else {
  324.             if ((left == 1) || (right == rn))
  325.                 shadow_edge = TRUE;
  326.         }
  327.  
  328.         if ((top == 1) || (bottom == 25))
  329.             shadow_edge = TRUE;
  330.  
  331.        }
  332.  
  333.     if (shadow_w && !shadow_edge) {
  334.         if (shadow_w > BOTTOM_RIGHT_SHADOW) {
  335.             offx = 5;
  336.             offy = 3;
  337.             ox = 2;
  338.             oy = 1;
  339.         }
  340.         else {
  341.               offx = offy = 3;
  342.             ox = oy = 1;
  343.         }
  344.     }
  345.     else {
  346.         offx = offy = 1;
  347.         ox = oy = 0;
  348.     }
  349.  
  350.     if ((scrbufptr+(2*(((right-left)+offx)*((bottom-top)+offy)))) >= &scrbuf[BUF_SIZE])
  351.         return POPERR;
  352.  
  353.     if (pop_id == MAX_WINDOW)
  354.         return POPERR;
  355.  
  356.     ++pop_id;
  357.  
  358.     pptr = (pop_id*PARAMS);
  359.     param[pptr] = left;
  360.     param[pptr+1] = top;
  361.     param[pptr+2] = right;
  362.     param[pptr+3] = bottom;
  363.     param[pptr+4] = foreground;
  364.     param[pptr+5] = background;
  365.     param[pptr+6] = border;
  366.     param[pptr+7] = bordertype;
  367.     if (shadow_edge)
  368.           param[pptr+8] = NO_SHADOW;
  369.     else
  370.         param[pptr+8] = shadow_w;
  371.  
  372.     gettext((left-ox),(top-oy),(right+ox),(bottom+oy),scrbufptr);
  373.     scrbufptr = (scrbufptr+(2*(((right-left)+offx)*((bottom-top)+offy))));
  374.     build_window();
  375.     return pop_id;
  376.  
  377. }
  378.  
  379. /*************************************************************************/
  380.  
  381. previous_popup()
  382. {
  383.     int s_top,s_bottom,s_left,s_right,s_wide,s_high,xadd,x,y,sx,sy,offs;
  384.     char buf[FULL_SCREEN];
  385.     int pptr;
  386.     int wattribute;
  387.     int    bufptr,lastptr;
  388.     unsigned int beep;
  389.     char v_shrunk,h_shrunk;
  390.  
  391.     if (!pop_id)
  392.         return POPERR;
  393.  
  394.     window(1,1,rn,25);
  395.  
  396.     pptr = (pop_id*PARAMS);
  397.     if (param[pptr+8])  {
  398.         if (param[pptr+8] > BOTTOM_RIGHT_SHADOW) {
  399.             sx = 2;
  400.             sy = 1;
  401.         }
  402.         else
  403.             sx = sy = 1;
  404.  
  405.     }
  406.     else
  407.         sx = sy = 0;
  408.  
  409.     offs = (2*(((param[pptr+2]-param[pptr])+((sx*2)+1))*((param[pptr+3]-param[pptr+1])+((sy*2)+1))));
  410.     scrbufptr = (scrbufptr-offs);
  411.  
  412.     if (shrink_w) {
  413.         wattribute = (param[pptr+6] + (param[pptr+5] * 0x10));
  414.         bufptr = 1;
  415.         while (bufptr < offs) {
  416.             buf[bufptr] = wattribute;
  417.             bufptr += 2;
  418.         }
  419.  
  420.         x = (param[pptr+3] - param[pptr+1]);
  421.         y = (param[pptr+2] - param[pptr]);
  422.         if ((y < 12) || (x < 8))
  423.             goto tosm;
  424.  
  425.         xadd = 0;
  426.         if (y <= x)
  427.             y = (x+1);
  428.         while (y > x) {
  429.             y = (y-x);
  430.             ++xadd;
  431.         }
  432.         if (y >= (x/2))
  433.             ++xadd;
  434.  
  435.         s_top = (param[pptr+1] +1);
  436.         s_bottom = (param[pptr+3] -1);
  437.  
  438.         s_left = (param[pptr] + xadd);
  439.         s_right = (param[pptr+2] - xadd);
  440.  
  441.         s_wide = ((s_right - s_left) * 2);
  442.         s_high = ((s_wide + 2) * (s_bottom - s_top));
  443.  
  444.         h_shrunk = v_shrunk = FALSE;
  445.  
  446.         if (noise_w) {
  447.             beep = tone;
  448.             sound(beep);
  449.         }
  450.  
  451.         if (bord[0] != param[pptr+7]) {
  452.             check_border(pptr);
  453.         }
  454.  
  455.         while (TRUE) {
  456.             buf[0] = bord[4];
  457.             bufptr = 2;
  458.             while (bufptr < s_wide) {
  459.                 buf[bufptr] = bord[1];
  460.                 bufptr += 2;
  461.             }
  462.             buf[bufptr] = bord[5];
  463.             bufptr += 2;
  464.  
  465.             if (param[pptr+7] == THICK_BORDER) {
  466.                 while (bufptr < s_high) {
  467.                     buf[bufptr] = buf[bufptr+2] = bord[3];
  468.                     bufptr += 4;
  469.                     lastptr = (bufptr-6);
  470.                     while (bufptr < (lastptr+s_wide)) {
  471.                         buf[bufptr] = SPACE;
  472.                         bufptr += 2;
  473.                     }
  474.                     buf[bufptr] = buf[bufptr+2] = bord[3];
  475.                     bufptr += 4;
  476.                 }
  477.             }
  478.             else {
  479.                 while (bufptr < s_high) {
  480.                     buf[bufptr] = bord[3];
  481.                     bufptr += 2;
  482.                     lastptr = (bufptr-2);
  483.                     while (bufptr < (lastptr+s_wide)) {
  484.                         buf[bufptr] = SPACE;
  485.                         bufptr += 2;
  486.                     }
  487.                     buf[bufptr] = bord[3];
  488.                     bufptr += 2;
  489.                 }
  490.             }
  491.  
  492.  
  493.             buf[bufptr] = bord[6];
  494.             bufptr += 2;
  495.             while (bufptr < (s_wide+s_high)) {
  496.                 buf[bufptr] = bord[2];
  497.                 bufptr += 2;
  498.             }
  499.             buf[bufptr] = bord[7];
  500.  
  501.             puttext((param[pptr]-sx),(param[pptr+1]-sy),(param[pptr+2]+sx),(param[pptr+3]+sy),scrbufptr);
  502.  
  503.             puttext(s_left,s_top,s_right,s_bottom,buf);
  504.  
  505.             if ((v_shrunk) && (h_shrunk))
  506.                 break;
  507.  
  508.             if (!v_shrunk) {
  509.                 ++s_top;
  510.                 --s_bottom;
  511.                 if ((s_top + 5) >= s_bottom)
  512.                     v_shrunk = TRUE;
  513.             }
  514.             if (!h_shrunk) {
  515.                 s_left += xadd;
  516.                 s_right -= xadd;
  517.                 if ((s_left + 9) >= s_right)
  518.                     h_shrunk = TRUE;
  519.             }
  520.  
  521.             s_wide = ((s_right - s_left) * 2);
  522.             s_high = ((s_wide + 2) * (s_bottom - s_top));
  523.  
  524.             if (noise_w) {
  525.                 beep += tone_step;
  526.                 sound(beep);
  527.             }
  528.  
  529.             delay(shrink_wait);
  530.  
  531.             if (noise_w) {
  532.                 beep += tone_step;
  533.                 sound(beep);
  534.             }
  535.  
  536.  
  537.         }
  538.  
  539.  
  540.     }   /* end of if shrink_w */
  541.  
  542. tosm:
  543.  
  544.     if (noise_w && !shrink_w)  {
  545.         sound(tone);
  546.         delay(shrink_wait);
  547.         delay(shrink_wait);
  548.  
  549.     }
  550.  
  551.     puttext((param[pptr]-sx),(param[pptr+1]-sy),(param[pptr+2]+sx),(param[pptr+3]+sy),scrbufptr);
  552.  
  553.  
  554.     --pop_id;
  555.     pptr = (pop_id*PARAMS);
  556.  
  557.     if (!(param[pptr+7]))
  558.         window(param[pptr],param[pptr+1],param[pptr+2],param[pptr+3]);
  559.     else if (param[pptr+7] == THICK_BORDER)
  560.         window((param[pptr]+2),(param[pptr+1]+1),(param[pptr+2]-2),(param[pptr+3]-1));
  561.     else
  562.         window((param[pptr]+1),(param[pptr+1]+1),(param[pptr+2]-1),(param[pptr+3]-1));
  563.     textcolor(param[pptr+4]);
  564.     textbackground(param[pptr+5]);
  565.  
  566.     if (noise_w)
  567.         nosound();
  568.  
  569.     return pop_id;
  570.  
  571. }
  572.  
  573. /*************************************************************************/
  574.  
  575. build_window()
  576. {
  577.  
  578.     int s_top,s_bottom,s_left,s_right,s_wide,s_high,x,y,xadd;
  579.     char buf[FULL_SCREEN];
  580.     char ntop[160];
  581.     int pptr;
  582.     int wattribute;
  583.     int wide,high;
  584.     int    bufptr,lastptr;
  585.     unsigned int beep;
  586.  
  587.     window(1,1,rn,25);
  588.  
  589.     pptr = (pop_id*PARAMS);
  590.     wide = ((param[pptr+2] - param[pptr]) * 2);
  591.     high = ((wide + 2) * (param[pptr+3] - param[pptr+1]));
  592.     wattribute = (param[pptr+6] + (param[pptr+5] * 0x10));
  593.  
  594.     if (bord[0] != param[pptr+7]) {
  595.         check_border(pptr);
  596.     }
  597.  
  598.     bufptr = 1;
  599.     while (bufptr < FULL_SCREEN) {
  600.         buf[bufptr] = wattribute;
  601.         bufptr += 2;
  602.     }
  603.  
  604.  
  605.       if (!explode_w) {
  606.         if (noise_w)
  607.             sound(tone);
  608.         goto tosmall;
  609.       }
  610.  
  611.     x = (param[pptr+3] - param[pptr+1]);
  612.     y = (param[pptr+2] - param[pptr]);
  613.     if ((y < 12) || (x < 8))
  614.         goto tosmall;
  615.  
  616.     s_top = (param[pptr+1] + ((x/2)-1));
  617.     s_bottom = (param[pptr+3] - ((x/2)-1));
  618.  
  619.     s_left = (param[pptr] + ((y/2)-4));
  620.     s_right = (param[pptr+2] - ((y/2)-4));
  621.  
  622.     s_wide = ((s_right - s_left) * 2);
  623.     s_high = ((s_wide + 2) * (s_bottom - s_top));
  624.  
  625.     xadd = ((y / x)+1);
  626.  
  627.     beep = tone;
  628.  
  629.     while (TRUE) {
  630.         buf[0] = bord[4];
  631.         bufptr = 2;
  632.         while (bufptr < s_wide) {
  633.             buf[bufptr] = bord[1];
  634.             bufptr += 2;
  635.         }
  636.         buf[bufptr] = bord[5];
  637.         bufptr += 2;
  638.         while (bufptr < s_high) {
  639.              if (param[pptr+7] == THICK_BORDER) {
  640.                 buf[bufptr] = buf[bufptr+2] = bord[3];
  641.                 bufptr += 4;
  642.                 lastptr = (bufptr-6);
  643.                 while (bufptr < (lastptr+s_wide)) {
  644.                     buf[bufptr] = SPACE;
  645.                     bufptr += 2;
  646.                 }
  647.                 buf[bufptr] = buf[bufptr+2] = bord[3];
  648.                 bufptr += 4;
  649.             }
  650.             else {
  651.                 buf[bufptr] = bord[3];
  652.                 bufptr += 2;
  653.                 lastptr = (bufptr-2);
  654.                 while (bufptr < (lastptr+s_wide)) {
  655.                     buf[bufptr] = SPACE;
  656.                     bufptr += 2;
  657.                 }
  658.                 buf[bufptr] = bord[3];
  659.                 bufptr += 2;
  660.             }
  661.         }
  662.         buf[bufptr] = bord[6];
  663.         bufptr += 2;
  664.         while (bufptr < (s_wide+s_high)) {
  665.             buf[bufptr] = bord[2];
  666.             bufptr += 2;
  667.         }
  668.         buf[bufptr] = bord[7];
  669.         puttext(s_left,s_top,s_right,s_bottom,buf);
  670.  
  671.         --s_top;
  672.         ++s_bottom;
  673.         s_left -= xadd;
  674.         s_right += xadd;
  675.  
  676.         if (s_top <= param[pptr+1])
  677.             s_top = param[pptr+1];
  678.         if (s_bottom >= param[pptr+3])
  679.             s_bottom = param[pptr+3];
  680.         if (s_left <= param[pptr])
  681.             s_left = param[pptr];
  682.         if (s_right >= param[pptr+2])
  683.             s_right = param[pptr+2];
  684.  
  685.         s_wide = ((s_right - s_left) * 2);
  686.         s_high = ((s_wide + 2) * (s_bottom - s_top));
  687.  
  688.         if (noise_w) {
  689.             beep += tone_step;
  690.             sound(beep);
  691.         }
  692.  
  693.         delay(explode_wait);
  694.  
  695.         if (noise_w) {
  696.             beep += tone_step;
  697.             sound(beep);
  698.         }
  699.  
  700.         if ((s_top == param[pptr+1]) && (s_bottom == param[pptr+3]) && (s_left == param[pptr]) && (s_right == param[pptr+2]))
  701.             break;
  702.  
  703.     }   /* end of while (TRUE) */
  704.  
  705.  
  706. tosmall:
  707.  
  708.     buf[0] = bord[4];
  709.     bufptr = 2;
  710.     while (bufptr < wide) {
  711.         buf[bufptr] = bord[1];
  712.         bufptr += 2;
  713.     }
  714.     buf[bufptr] = bord[5];
  715.     bufptr += 2;
  716.     while (bufptr < high) {
  717.          if (param[pptr+7] == THICK_BORDER) {
  718.             buf[bufptr] = buf[bufptr+2] = bord[3];
  719.             bufptr += 4;
  720.             lastptr = (bufptr-6);
  721.             while (bufptr < (lastptr+wide)) {
  722.                 buf[bufptr] = SPACE;
  723.                 bufptr += 2;
  724.             }
  725.             buf[bufptr] = buf[bufptr+2] = bord[3];
  726.             bufptr += 4;
  727.         }
  728.         else {
  729.             buf[bufptr] = bord[3];
  730.             bufptr += 2;
  731.             lastptr = (bufptr-2);
  732.             while (bufptr < (lastptr+wide)) {
  733.                 buf[bufptr] = SPACE;
  734.                 bufptr += 2;
  735.             }
  736.             buf[bufptr] = bord[3];
  737.             bufptr += 2;
  738.         }
  739.     }
  740.     buf[bufptr] = bord[6];
  741.     bufptr += 2;
  742.     while (bufptr < (wide+high)) {
  743.         buf[bufptr] = bord[2];
  744.         bufptr += 2;
  745.     }
  746.     buf[bufptr] = bord[7];
  747.     puttext(param[pptr],param[pptr+1],param[pptr+2],param[pptr+3],buf);
  748.  
  749.     if (param[pptr+8]) {
  750.         bufptr = 0;
  751.         while (bufptr < 160) {
  752.             buf[bufptr] = '█';
  753.             ++bufptr;
  754.             buf[bufptr] = shadow_attr;
  755.             ++bufptr;
  756.         }
  757.  
  758.          switch(param[pptr+8]) {
  759.             case TOP_LEFT_WIDE:
  760.                 puttext((param[pptr]-2),(param[pptr+1]-1),(param[pptr+2]-2),(param[pptr+1]-1),buf);
  761.                 puttext((param[pptr]-2),(param[pptr+1]-1),(param[pptr]-1),(param[pptr+3]-1),buf);
  762.                 break;
  763.             case TOP_RIGHT_WIDE:
  764.                 puttext((param[pptr]+2),(param[pptr+1]-1),(param[pptr+2]+2),(param[pptr+1]-1),buf);
  765.                 puttext((param[pptr+2]+1),(param[pptr+1]-1),(param[pptr+2]+2),(param[pptr+3]-1),buf);
  766.                 break;
  767.             case BOTTOM_LEFT_WIDE:
  768.                 puttext((param[pptr]-2),(param[pptr+3]+1),(param[pptr+2]-2),(param[pptr+3]+1),buf);
  769.                 puttext((param[pptr]-2),(param[pptr+1]+1),(param[pptr]-1),(param[pptr+3]+1),buf);
  770.                 break;
  771.             case BOTTOM_RIGHT_WIDE:
  772.                 puttext((param[pptr]+2),(param[pptr+3]+1),(param[pptr+2]+2),(param[pptr+3]+1),buf);
  773.                 puttext((param[pptr+2]+1),(param[pptr+1]+1),(param[pptr+2]+2),(param[pptr+3]+1),buf);
  774.                 break;
  775.              case TOP_LEFT_SHADOW:
  776.                 gettext((param[pptr]-1),(param[pptr+1]-1),(param[pptr+2]-1),(param[pptr+1]-1),ntop);
  777.                 bufptr = 0;
  778.                 while (bufptr < 160) {
  779.                     ntop[bufptr] = '▄';
  780.                     ++bufptr;
  781.                     ntop[bufptr] = ((ntop[bufptr] & 0x70) | shadow_attr);
  782.                     ++bufptr;
  783.                 }
  784.                 puttext((param[pptr]-1),(param[pptr+1]-1),(param[pptr+2]-1),(param[pptr+1]-1),ntop);
  785.                 puttext((param[pptr]-1),(param[pptr+1]),(param[pptr]-1),(param[pptr+3]-1),buf);
  786.                 gettext((param[pptr]-1),(param[pptr+3]),(param[pptr]-1),(param[pptr+3]),ntop);
  787.                 ntop[0] = '▀';
  788.                 ntop[1] = ((ntop[1] & 0x70) | shadow_attr);
  789.                 puttext((param[pptr]-1),(param[pptr+3]),(param[pptr]-1),(param[pptr+3]),ntop);
  790.                 break;
  791.             case TOP_RIGHT_SHADOW:
  792.                 gettext((param[pptr]+1),(param[pptr+1]-1),(param[pptr+2]+1),(param[pptr+1]-1),ntop);
  793.                 bufptr = 0;
  794.                 while (bufptr < 160) {
  795.                     ntop[bufptr] = '▄';
  796.                     ++bufptr;
  797.                     ntop[bufptr] = ((ntop[bufptr] & 0x70) | shadow_attr);
  798.                     ++bufptr;
  799.                 }
  800.                 puttext((param[pptr]+1),(param[pptr+1]-1),(param[pptr+2]+1),(param[pptr+1]-1),ntop);
  801.                 puttext((param[pptr+2]+1),(param[pptr+1]),(param[pptr+2]+1),(param[pptr+3]-1),buf);
  802.                 gettext((param[pptr+2]+1),(param[pptr+3]),(param[pptr+2]+1),(param[pptr+3]),ntop);
  803.                 ntop[0] = '▀';
  804.                 ntop[1] = ((ntop[1] & 0x70) | shadow_attr);
  805.                 puttext((param[pptr+2]+1),(param[pptr+3]),(param[pptr+2]+1),(param[pptr+3]),ntop);
  806.                 break;
  807.             case BOTTOM_LEFT_SHADOW:
  808.                 gettext((param[pptr]-1),(param[pptr+3]+1),(param[pptr+2]-1),(param[pptr+3]+1),ntop);
  809.                 bufptr = 0;
  810.                 while (bufptr < 160) {
  811.                     ntop[bufptr] = '▀';
  812.                     ++bufptr;
  813.                     ntop[bufptr] = ((ntop[bufptr] & 0x70) | shadow_attr);
  814.                     ++bufptr;
  815.                 }
  816.                 puttext((param[pptr]-1),(param[pptr+3]+1),(param[pptr+2]-1),(param[pptr+3]+1),ntop);
  817.                 puttext((param[pptr]-1),(param[pptr+1]+1),(param[pptr]-1),(param[pptr+3]),buf);
  818.                 gettext((param[pptr]-1),(param[pptr+1]),(param[pptr]-1),(param[pptr+1]),ntop);
  819.                 ntop[0] = '▄';
  820.                 ntop[1] = ((ntop[1] & 0x70) | shadow_attr);
  821.                 puttext((param[pptr]-1),(param[pptr+1]),(param[pptr]-1),(param[pptr+1]),ntop);
  822.                 break;
  823.             case BOTTOM_RIGHT_SHADOW:
  824.                 gettext((param[pptr]+1),(param[pptr+3]+1),(param[pptr+2]+1),(param[pptr+3]+1),ntop);
  825.                 bufptr = 0;
  826.                 while (bufptr < 160) {
  827.                     ntop[bufptr] = '▀';
  828.                     ++bufptr;
  829.                     ntop[bufptr] = ((ntop[bufptr] & 0x70) | shadow_attr);
  830.                     ++bufptr;
  831.                 }
  832.                 puttext((param[pptr]+1),(param[pptr+3]+1),(param[pptr+2]+1),(param[pptr+3]+1),ntop);
  833.                 puttext((param[pptr+2]+1),(param[pptr+1]+1),(param[pptr+2]+1),(param[pptr+3]),buf);
  834.                 gettext((param[pptr+2]+1),(param[pptr+1]),(param[pptr+2]+1),(param[pptr+1]),ntop);
  835.                 ntop[0] = '▄';
  836.                 ntop[1] = ((ntop[1] & 0x70) | shadow_attr);
  837.                 puttext((param[pptr+2]+1),(param[pptr+1]),(param[pptr+2]+1),(param[pptr+1]),ntop);
  838.                 break;
  839.         }
  840.  
  841.     }
  842.  
  843.  
  844.     if (!(param[pptr+7]))
  845.         window(param[pptr],param[pptr+1],param[pptr+2],param[pptr+3]);
  846.     else if (param[pptr+7] == THICK_BORDER)
  847.         window((param[pptr]+2),(param[pptr+1]+1),(param[pptr+2]-2),(param[pptr+3]-1));
  848.     else
  849.         window((param[pptr]+1),(param[pptr+1]+1),(param[pptr+2]-1),(param[pptr+3]-1));
  850.  
  851.     textcolor(param[pptr+4]);
  852.     textbackground(param[pptr+5]);
  853.  
  854.     if (noise_w)
  855.         nosound();
  856.  
  857. }
  858.  
  859. /*************************************************************************/
  860.  
  861. check_border(bptr)
  862. int bptr;
  863. {
  864.  
  865.         bord[0] = param[bptr+7];
  866.         switch(param[bptr+7]) {
  867.             case NO_BORDER:
  868.                 bord[1] = bord[2] = bord[3] = bord[4] = bord[5] = bord[6] = bord[7] = ' ';
  869.                 break;
  870.             case SINGLE_BORDER:
  871.                 bord[1] = bord[2] = '─';
  872.                 bord[3] = '│';
  873.                 bord[4] = '┌';
  874.                 bord[5] = '┐';
  875.                 bord[6] = '└';
  876.                 bord[7] = '┘';
  877.                 break;
  878.             case DOUBLE_BORDER:
  879.                 bord[1] = bord[2] = '═';
  880.                 bord[3] = '║';
  881.                 bord[4] = '╔';
  882.                 bord[5] = '╗';
  883.                 bord[6] = '╚';
  884.                 bord[7] = '╝';
  885.                 break;
  886.             case THIN_BORDER:
  887.                 bord[1] = '▀';
  888.                 bord[2] = '▄';
  889.                 bord[3] = bord[4] = bord[5] = bord[6] = bord[7] = '█';
  890.                 break;
  891.             case THICK_BORDER:
  892.                 bord[1] = bord[2] = bord[3] = bord[4] = bord[5] = bord[6] = bord[7] = '█';
  893.                 break;
  894.         }
  895.  
  896. }
  897.