home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume15 / touchup / part05 / drawing.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-06-14  |  15.7 KB  |  692 lines
  1.  
  2. /**************************************************************************
  3.    Touchup a bitmap graphics editor for the Sun Workstation running SunView
  4.    Copyright (c) 1988 by Raymond Kreisel
  5.    1/22/88 @ Suny Stony Brook
  6.  
  7.    This program may be redistributed without fee as long as this copyright
  8.    notice is intact.
  9.  
  10. ==> PLEASE send comments and bug reports to one of the following addresses:
  11.  
  12.        Ray Kreisel
  13.        CS Dept., SUNY at Stony Brook, Stony Brook NY 11794
  14.  
  15.        UUCP: {allegra, philabs, pyramid, research}!sbcs!rayk   
  16.        ARPA-Internet: rayk@sbcs.sunysb.edu            
  17.        CSnet: rayk@suny-sb
  18.        (If nobody is home at any of the above addresses try:
  19.         S72QKRE@TOWSONVX.BITNET                    )
  20.  
  21.  "If I get home before daylight, I just might get some sleep tonight...."
  22.  
  23. **************************************************************************/
  24. /**************************************************************************
  25.     file: drawing.c
  26.     purpose: This file has most of the functions that draw stuff
  27.     on the screen.
  28.  
  29.     modifications:
  30.         date:    Tue Mar 22 22:04:58 EST 1988
  31.         author:    rayk
  32.         changes:add comments
  33. **************************************************************************/
  34.  
  35. #include"header.h"
  36.  
  37. struct pr_pos poly_points[MAX_POLY];
  38.  
  39. struct pixrect *brush_temp_pr = NULL;
  40.  
  41. /*
  42.  * What we do that someone selects a new pattern
  43.  */
  44. select_pattern(item, event)
  45. Panel_item      item;
  46. Event           *event;
  47. {
  48.   panel_set(current_pattern,PANEL_LABEL_IMAGE,pattern[(int)panel_get_value(pattern_choice)],0);
  49.  
  50. }
  51.  
  52.  
  53. /*
  54.  * let the user define his own patterns to paint with
  55.  * works for color and mono
  56.  */
  57. pattern_define(item, event)
  58. Panel_item      item;
  59. Event           *event;
  60. {
  61.  
  62.   if (select_pt_x == -1)
  63.      {
  64.     ERROR("Select a point first, then select Define Pattern.");
  65.     set_select_mode();
  66.     return(0);
  67.      }
  68.   select_point(select_pt_x,select_pt_y);
  69.   if (image_depth > 1)
  70.    {
  71.       pattern[39]  = my_mem_create(PATTERN_SIZE,PATTERN_SIZE,image_depth);
  72.       pattern40_pr = *(pattern[39]);
  73.    }
  74.   pr_rop(pattern[39],0,0,PATTERN_SIZE,PATTERN_SIZE,
  75.         PIX_SRC,pw->pw_prretained,select_pt_x-PATTERN_SIZE/2,
  76.         select_pt_y-PATTERN_SIZE/2);
  77.  
  78.   panel_paint(pattern_choice,PANEL_NO_CLEAR);
  79.   reset_point();
  80.   print_msg("The user defined pattern is now stored in the last pattern element.");
  81. }
  82.  
  83.  
  84. /*
  85.  * Take the current text string and put that Baby up on the bitmap
  86.  * in the right font
  87.  */
  88. draw_text()
  89. {
  90. int x,y;
  91.  
  92.   if (select_pt_x != -1)
  93.     {
  94.       x = select_pt_x;
  95.       y = select_pt_y;
  96.       clean_point();
  97.       save_screen();
  98.       pw_text(pw,x,y,PIX_COLOR(cur_color) | PIX_SRC,font_array[(int)panel_get_value(text_size_item)],
  99.         (char*)panel_get_value(text_panel));
  100.     }
  101.   else
  102.     {
  103.       ERROR("Select a point first, fill in TEXT STRING, then select ABC.");
  104.       window_set(panel,PANEL_CARET_ITEM,text_panel,0);
  105.       set_select_mode();
  106.     }
  107. }
  108.  
  109.  
  110. /*
  111.  * draw a line on the bitmap
  112.  */
  113. draw_line(x1,y1,x2,y2,ROP,color)
  114. int x1,y1,x2,y2,ROP,color;
  115. {
  116.   pw_vector(pw,x1,y1,x2,y2,ROP,color);
  117. }
  118.  
  119.  
  120. /*
  121.  * draw a rectangle on the bitmap
  122.  */
  123. draw_rectangle(x1,y1,x2,y2)
  124. int x1,y1,x2,y2;
  125. {
  126.   top_x = x1;
  127.   top_y = y1;
  128.   bottom_x = x2;
  129.   bottom_y = y2;
  130.   if ((int)panel_get_value(command_choice)==RECT_F)
  131.     fill_region();
  132.   else
  133.     reset_region();
  134.   if ((int)panel_get_value(border_cycle))
  135.   {
  136.     pw_vector(pw,x1,y1,x2,y1,PIX_SRC,cur_color);
  137.     pw_vector(pw,x2,y1,x2,y2,PIX_SRC,cur_color);
  138.     pw_vector(pw,x2,y2,x1,y2,PIX_SRC,cur_color);
  139.     pw_vector(pw,x1,y2,x1,y1,PIX_SRC,cur_color);
  140.   }
  141. }
  142.  
  143.  
  144. /*
  145.  * highlight the selected region on the drawing area by throwing up a
  146.  * XORed rectangle
  147.  */
  148. select_region(pw,x1,y1,x2,y2)
  149. struct pixwin *pw;
  150. int x1,y1,x2,y2;
  151. {
  152.   pw_vector(pw,x1,y1,x2,y1,PIX_XOR,1);
  153.   pw_vector(pw,x2,y1,x2,y2,PIX_XOR,1);
  154.   pw_vector(pw,x2,y2,x1,y2,PIX_XOR,1);
  155.   pw_vector(pw,x1,y2,x1,y1,PIX_XOR,1);
  156. }
  157.  
  158.  
  159. /*
  160.  * reset the current REGION
  161.  */
  162. reset_region()
  163. {
  164.   top_x=0;
  165.   top_y=0;
  166.   bottom_x=0;
  167.   bottom_y=0;
  168. }
  169.  
  170.  
  171. /*
  172.  * draw up a point, how stupid ???
  173.  */
  174. draw_point(pw,x,y)
  175. struct pixwin *pw;
  176. int x,y;
  177. {
  178.   pw_put(pw,x,y,cur_color);
  179. }
  180.  
  181.  
  182. /*
  183.  * Draw up the paint brush by copying the current pattern
  184.  * through a stencil of the current brush
  185.  */
  186. draw_brush(pw,x,y)
  187. struct pixwin *pw;
  188. int x,y;
  189. {
  190.   if (brush_temp_pr == NULL)
  191.     brush_temp_pr = my_mem_create(PATTERN_SIZE,PATTERN_SIZE,1);
  192.  
  193.  
  194.   if (((int)panel_get_value(pattern_choice) != 39) || (image_depth == 1))
  195.   {
  196.     if (brush_temp_pr->pr_depth != 1)
  197.     {
  198.          MY_pr_destroy(brush_temp_pr);
  199.         brush_temp_pr = my_mem_create(PATTERN_SIZE,PATTERN_SIZE,1);
  200.     }
  201.     pr_replrop(brush_temp_pr,0,0,PATTERN_SIZE,PATTERN_SIZE, PIX_SRC,pattern[(int)panel_get_value(pattern_choice)],x,y);
  202.         pw_stencil(pw,x-PATTERN_SIZE/2,y-PATTERN_SIZE/2,PATTERN_SIZE,PATTERN_SIZE,PIX_COLOR(cur_color) | PIX_SRC,
  203.     brushes[(int)panel_get_value(brush_choice)],0,0,brush_temp_pr,0,0);
  204.   }
  205.   else
  206.   {
  207.     if (brush_temp_pr->pr_depth != image_depth)
  208.     {
  209.          MY_pr_destroy(brush_temp_pr);
  210.         brush_temp_pr = my_mem_create(PATTERN_SIZE,PATTERN_SIZE,image_depth);
  211.     }
  212.     pr_replrop(brush_temp_pr,0,0,PATTERN_SIZE,PATTERN_SIZE, PIX_SRC,pattern[(int)panel_get_value(pattern_choice)],x,y);
  213.         pw_stencil(pw,x-PATTERN_SIZE/2,y-PATTERN_SIZE/2,PATTERN_SIZE,PATTERN_SIZE, PIX_SRC,
  214.     brushes[(int)panel_get_value(brush_choice)],0,0,brush_temp_pr,0,0);
  215.  
  216.   }
  217.  
  218. }
  219.  
  220.  
  221. /*
  222.  * flip-flop two varibles (ints)
  223.  */
  224. swap(x,y)
  225. int *x,*y;
  226. {
  227. int temp;
  228.   temp = *x;
  229.   *x = *y;
  230.   *y = temp;
  231. }
  232.  
  233.  
  234. region_fix()
  235. {
  236.   if (top_x > bottom_x)
  237.      swap(&top_x,&bottom_x);
  238.   if (top_y > bottom_y)
  239.      swap(&top_y,&bottom_y);
  240. } 
  241.  
  242.  
  243. /*
  244.  * put the eraser on the drawing area
  245.  */
  246. erase_brush(pw,x,y)
  247. struct pixwin *pw;
  248. int x,y;
  249. {
  250.   select_region(pw,top_x,top_y,top_x+PATTERN_SIZE,top_y+PATTERN_SIZE);
  251.   pw_rop(pw,x-PATTERN_SIZE/2,y-PATTERN_SIZE/2,PATTERN_SIZE,PATTERN_SIZE, PIX_SRC,0,0,0);
  252.   top_x = x-PATTERN_SIZE/2; top_y= y-PATTERN_SIZE/2;
  253.   select_region(pw,top_x,top_y,top_x+PATTERN_SIZE,top_y+PATTERN_SIZE);
  254. }
  255.  
  256.  
  257. /*
  258.  * draw up some cross hairs to be used to select a point
  259.  */
  260. #define CROSS_HAIR 20
  261. select_point(x,y)
  262. int x,y;
  263. {
  264.   pw_vector(pw,x-CROSS_HAIR,y,x+CROSS_HAIR,y,PIX_XOR,1);
  265.   pw_vector(pw,x,y-CROSS_HAIR,x,y+CROSS_HAIR,PIX_XOR,1);
  266. }
  267.  
  268.  
  269. /*
  270.  * reset the currently selected point
  271.  */
  272. reset_point()
  273. {
  274.   select_pt_x = 0-1;
  275.   select_pt_y = 0-1;
  276. }
  277.  
  278.  
  279. /*
  280.  * take a currently selected region and invert that baby ! FAST !!!
  281.  */
  282. inverse_region()
  283. {
  284.   if (top_x || top_y || bottom_x || bottom_y)
  285.     {
  286.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  287.      region_fix();
  288.      pw_replrop(pw,top_x,top_y,bottom_x-top_x,bottom_y-top_y, PIX_XOR, pattern[0],0,0);
  289.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  290.     }
  291.   else
  292.     {
  293.      ERROR("Select a region first, then select INVERSE.");
  294.      panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  295.      mouse_parms();
  296.     }
  297. }
  298.  
  299.  
  300.  
  301. /*
  302.  * take a currently selected region and rotate around the center
  303.  * point.  SLOW !!
  304.  */
  305. rotate_region()
  306. {
  307. register i,j,t1,t2;
  308.  
  309.   if (top_x || top_y || bottom_x || bottom_y)
  310.     {
  311.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  312.      region_fix();
  313.      MY_pr_destroy(cut_buffer_pr);
  314.      cut_buffer_pr = my_mem_create(bottom_x-top_x,bottom_y-top_y,image_depth);
  315.      pr_rop(cut_buffer_pr,0,0,bottom_x-top_x,bottom_y-top_y,
  316.         PIX_SRC,pw->pw_prretained,top_x,top_y);
  317.      t1 = top_x + cut_buffer_pr->pr_size.x/2+ cut_buffer_pr->pr_size.y/2;
  318.      t2 = top_y - cut_buffer_pr->pr_size.x/2+ cut_buffer_pr->pr_size.y/2;
  319.      for (j = 0; j < cut_buffer_pr->pr_size.y; j++)
  320.        for (i = 0; i < cut_buffer_pr->pr_size.x; i++)
  321.         pw_rop(pw, t1-j, t2+i, 1,1, PIX_SRC, cut_buffer_pr,i,j);
  322.  
  323.      top_x = top_x + cut_buffer_pr->pr_size.x/2 - cut_buffer_pr->pr_size.y/2;
  324.      top_y = top_y - cut_buffer_pr->pr_size.x/2 + cut_buffer_pr->pr_size.y/2;
  325.      bottom_x = top_x + cut_buffer_pr->pr_size.y;
  326.      bottom_y = top_y + cut_buffer_pr->pr_size.x;
  327.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  328.     }
  329.   else
  330.     {
  331.      ERROR("Select a region first, then select ROTATE.");
  332.      panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  333.      mouse_parms();
  334.     }
  335. }
  336.  
  337.  
  338.  
  339. /*
  340.  * take a currently selected region and make a mirror image of it
  341.  */
  342. flip_hor_region()
  343. {
  344. register i;
  345.   if (top_x || top_y || bottom_x || bottom_y)
  346.     {
  347.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  348.      region_fix();
  349.      MY_pr_destroy(cut_buffer_pr);
  350.      cut_buffer_pr = my_mem_create(bottom_x-top_x,bottom_y-top_y,image_depth);
  351.      pr_rop(cut_buffer_pr,0,0,bottom_x-top_x,bottom_y-top_y,
  352.         PIX_SRC,pw->pw_prretained,top_x,top_y);
  353.      for (i = 0; i < cut_buffer_pr->pr_size.x; i++) {
  354.         pw_rop(pw, top_x+(cut_buffer_pr->pr_size.x - i)-1,top_y,
  355.             1,cut_buffer_pr->pr_size.y, PIX_SRC, cut_buffer_pr,i,0);
  356.     }
  357.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  358.     }
  359.   else
  360.     {
  361.      ERROR("Select a region first, then select MIRROR.");
  362.      panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  363.      mouse_parms();
  364.     }
  365. }
  366.  
  367.  
  368. /*
  369.  * take a currently selected region and turn it upside down
  370.  */
  371. flip_ver_region()
  372. {
  373. register i;
  374.   if (top_x || top_y || bottom_x || bottom_y)
  375.     {
  376.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  377.      region_fix();
  378.      MY_pr_destroy(cut_buffer_pr);
  379.      cut_buffer_pr = my_mem_create(bottom_x-top_x,bottom_y-top_y,image_depth);
  380.      pr_rop(cut_buffer_pr,0,0,bottom_x-top_x,bottom_y-top_y,
  381.         PIX_SRC,pw->pw_prretained,top_x,top_y);
  382.      for (i = 0; i < cut_buffer_pr->pr_size.y; i++) {
  383.         pw_rop(pw, top_x, top_y+(cut_buffer_pr->pr_size.y - i)-1,
  384.             cut_buffer_pr->pr_size.x, 1, PIX_SRC, cut_buffer_pr, 0, i);
  385.     }
  386.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  387.     }
  388.   else
  389.     {
  390.      ERROR("Select a region first, then select FLIP VERTICAL.");
  391.      panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  392.      mouse_parms();
  393.     }
  394. }
  395.  
  396.  
  397.  
  398. /*
  399.  * grab what is in the Cut/Paste buffer and put it up on the drawing area
  400.  */
  401. paste_region()
  402. {
  403. int ROP=PIX_SRC;
  404.  
  405.   if (select_pt_x == -1)
  406.      {
  407.     ERROR("Select a point first, then select PASTE.");
  408.     set_select_mode();
  409.     return(0);
  410.      }
  411.   if (cut_buffer_pr)
  412.   {
  413.      select_point(select_pt_x,select_pt_y);
  414.      save_screen();
  415.      pw_write(pw,select_pt_x,select_pt_y,cut_buffer_pr->pr_size.x,cut_buffer_pr->pr_size.y, ROP, cut_buffer_pr,0,0);
  416.      reset_point();
  417.   }
  418.   else
  419.     ERROR("The Cut/Paste buffer is empty.");
  420. }
  421.  
  422.  
  423. /*
  424.  * grab the currently selected region on the drawing area and stuff
  425.  * it into the cut/paste buffer AND destroy the source area by
  426.  * filling in with the current paint pattern
  427.  */
  428. cut_region()
  429. {
  430. int t1,t2,t3,t4;
  431.   if (top_x || top_y || bottom_x || bottom_y)
  432.     {
  433.       t1 = top_x;
  434.       t2 = top_y;
  435.       t3 = bottom_x;
  436.       t4 = bottom_y;
  437.       copy_region();
  438.       top_x = t1;
  439.       top_y = t2;
  440.       bottom_x = t3;
  441.       bottom_y = t4;
  442.       select_region(pw,top_x,top_y,bottom_x,bottom_y);
  443.       fill_region();
  444.       set_select_mode();
  445.       print_msg("Region copied to Cut/Paste buffer, select a point and then press PASTE.");
  446.     }
  447.    else
  448.     {
  449.      ERROR("Select a region first, then select CUT.");
  450.      panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  451.      mouse_parms();
  452.     }
  453. }
  454.  
  455.  
  456. /*
  457.  * grab the currently selected region on the drawing area and stuff
  458.  * it into the cut/paste buffer
  459.  */
  460. copy_region()
  461. {
  462.   if (top_x || top_y || bottom_x || bottom_y)
  463.     {
  464.      select_region(pw,top_x,top_y,bottom_x,bottom_y);
  465.      region_fix();
  466.      MY_pr_destroy(cut_buffer_pr);
  467.      cut_buffer_pr = my_mem_create(bottom_x-top_x,bottom_y-top_y,image_depth);
  468.      pr_rop(cut_buffer_pr,0,0,bottom_x-top_x,bottom_y-top_y,
  469.         PIX_SRC,pw->pw_prretained,top_x,top_y);
  470.      reset_region();
  471.     }
  472.    else
  473.     {
  474.     ERROR("Select a region first, then select COPY.");
  475.         panel_set(command_choice,PANEL_VALUE,SEL_REG,0);
  476.         mouse_parms();
  477.     }
  478. }
  479.  
  480.  
  481. /*
  482.  * take the cut/paste buffer and XOR it that stuff on to the drawing area
  483.  * so that I can move that sucker around FAST
  484.  */
  485. move_region(old_x,old_y,new_x,new_y)
  486. int old_x,old_y,new_x,new_y;
  487. {
  488.   if (cut_buffer_pr)
  489.     {
  490.      pw_write(pw,old_x-cut_buffer_pr->pr_size.x/2,
  491.          old_y-cut_buffer_pr->pr_size.y/2,
  492.          cut_buffer_pr->pr_size.x,
  493.          cut_buffer_pr->pr_size.y,
  494.          PIX_XOR, cut_buffer_pr,0,0);
  495.  
  496.      pw_write(pw,new_x-cut_buffer_pr->pr_size.x/2,
  497.          new_y-cut_buffer_pr->pr_size.y/2,
  498.          cut_buffer_pr->pr_size.x,
  499.          cut_buffer_pr->pr_size.y,
  500.          PIX_XOR, cut_buffer_pr,0,0);
  501.     }
  502.    else
  503.     {
  504.        ERROR("CUT or COPY a region first, then select MOVE.");
  505.     }
  506. }
  507.  
  508.  
  509. /*
  510.  * fill in a rectanglar region with the current paint pattern
  511.  */
  512. fill_region(item, event)
  513. Panel_item      item;
  514. Event           *event;
  515. {
  516.    if (top_x || top_y || bottom_x || bottom_y)
  517.     {
  518.       select_region(pw,top_x,top_y,bottom_x,bottom_y);
  519.       region_fix();
  520.       pw_replrop(pw,top_x,top_y,bottom_x-top_x,bottom_y-top_y,PIX_COLOR(cur_color) | PIX_SRC,pattern[(int)panel_get_value(pattern_choice)],0,0);
  521.       reset_region();
  522.     }
  523. }
  524.  
  525.  
  526. /*
  527.  * let the user lasso any free form region on the drawing area
  528.  * and stuff that into the cut/paste buffer
  529.  */
  530. laso_cut_paste()
  531. {
  532. int found;
  533. int i,no_points;
  534. int npts[1];
  535.  
  536.   top_x = image_wid;
  537.   top_y = image_hgt;
  538.   bottom_x = 0;
  539.   bottom_y = 0;
  540.  
  541.   i=0;
  542.   while ((i<MAX_PTS) && (ptlist[i++].x != -1));
  543.   no_points = --i;
  544.   npts[0] = no_points; 
  545.   pw_polygon_2(pw,0,0,1,npts,ptlist,PIX_XOR,pattern[0],0,0);
  546.   pw_polygon_2(pw,0,0,1,npts,ptlist,PIX_XOR,pattern[0],0,0);
  547.  
  548.   for (i=0;i < no_points;i++)
  549.     {
  550.         top_x = MIN(top_x,ptlist[i].x);
  551.         top_y = MIN(top_y,ptlist[i].y);
  552.         bottom_x = MAX(bottom_x,ptlist[i].x);
  553.         bottom_y = MAX(bottom_y,ptlist[i].y);
  554.         if (i>0)
  555.         pw_vector(pw,ptlist[i].x,ptlist[i].y,
  556.                  ptlist[i-1].x,ptlist[i-1].y,PIX_XOR,1);
  557.     }
  558.   for (i=0;i < no_points;i++)
  559.     {
  560.         ptlist[i].x -=top_x;
  561.         ptlist[i].y -=top_y;
  562.     }
  563.   MY_pr_destroy(cut_buffer_pr);
  564.   cut_buffer_pr = my_mem_create(bottom_x-top_x,bottom_y-top_y,image_depth);
  565.   pr_polygon_2(cut_buffer_pr,0,0,1,npts,ptlist,PIX_SRC,pw->pw_prretained,top_x,top_y);
  566.   reset_region();
  567.   print_msg("The selected area is now in the Cut/Paste buffer.");
  568. }
  569.  
  570.  
  571. /*
  572.  * the user can lasso any area on the screen by just encircling the
  573.  * object on the bitmap
  574.  * we do this by remembering all of the points the mouse moved to
  575.  * and make a polygon stencil from these points
  576.  */
  577. laso_addpt(py_pts,x,y)
  578. struct pr_pos py_pts[];
  579. int x,y;
  580. {
  581. int found;
  582. int i;
  583. int npts[1];
  584.  
  585.   found =0;
  586.   i=0;
  587.   while (i<MAX_PTS && !found)
  588.     {
  589.       if (py_pts[i++].x == -1)
  590.     found=TRUE;
  591.     }
  592.   i--;
  593.   npts[0] =i;
  594.         
  595.   py_pts[i].x = x;
  596.   py_pts[i].y = y;
  597.   if (i>0)
  598.     pw_vector(pw,py_pts[i].x,py_pts[i].y,py_pts[i-1].x,py_pts[i-1].y,PIX_XOR,1);
  599.   i++;
  600.   py_pts[i].x = 0-1;
  601.   py_pts[i].y = 0-1;
  602. }
  603.  
  604.  
  605. /*
  606.  * add a point to the list of vetexs in the current polygon
  607.  */
  608. poly_addpt(py_pts,x,y)
  609. struct pr_pos py_pts[];
  610. int x,y;
  611. {
  612. int found;
  613. int i;
  614.  
  615.   found =0;
  616.   i=0;
  617.   while (i<MAX_POLY && !found)
  618.     {
  619.       if (py_pts[i++].x == -1)
  620.     found=TRUE;
  621.     }
  622.   i--;
  623.        {
  624.          py_pts[i].x = x;
  625.          py_pts[i].y = y;
  626.      i++;
  627.      py_pts[i].x = 0-1;
  628.      py_pts[i].y = 0-1;
  629.        }
  630. }
  631.  
  632.  
  633. /*
  634.  * take the list of currnet vertexs and draw up the
  635.  * the polygon and fill it with the current paint pattern
  636.  */
  637. draw_poly(py_pts)
  638. struct pr_pos py_pts[];
  639. {
  640. int npts[1];
  641. int found;
  642. int i;
  643.  
  644.   if (py_pts[0].x == 0-1)
  645.     return(0);
  646.  
  647.   found =0;
  648.   i=0;
  649.   while (i<MAX_POLY && !found)
  650.     {
  651.       if (py_pts[i++].x == -1)
  652.     found=TRUE;
  653.     }
  654.   i--;
  655.  
  656.   npts[0] =i;
  657.  
  658.   /*
  659.    * do we want this baby filled ????
  660.    */ 
  661.   if ((int)panel_get_value(command_choice)==POLY_F)
  662.        pw_polygon_2(pw,0,0,1,npts,py_pts,PIX_COLOR(cur_color) | PIX_SRC,pattern[(int)panel_get_value(pattern_choice)],0,0);
  663.  
  664.   /*
  665.    * do we want to wrap the polygon up in a vector border
  666.    */
  667.   if ((int)panel_get_value(border_cycle))
  668.   {
  669.       i=1;
  670.       while (i<MAX_POLY && (py_pts[i].x != -1))
  671.         {
  672.         pw_vector(pw,py_pts[i].x,py_pts[i].y,
  673.                  py_pts[i-1].x,py_pts[i-1].y,PIX_SRC,cur_color);
  674.         i++;
  675.         }
  676.       i--;
  677.       pw_vector(pw,py_pts[i].x,py_pts[i].y,
  678.                  py_pts[0].x,py_pts[0].y,PIX_SRC,cur_color);
  679.   }
  680.   clean_poly();
  681. }
  682.  
  683.  
  684. /*
  685.  * reset the vertex list for the current polygon
  686.  */
  687. clean_poly()
  688. {
  689.   poly_points[0].x = 0-1;
  690.   poly_points[0].y = 0-1;
  691. }
  692.