home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / graphics / _sunview.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  30.3 KB  |  1,483 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _sunview.c
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <suntool/sunview.h>
  17. #include <suntool/canvas.h>
  18. #include <suntool/panel.h>
  19. #include <math.h>
  20. #include <string.h>
  21. #include <stdio.h>
  22.  
  23.  
  24. #define NOCLIP 0x1
  25.  
  26. #define XCOL(c) PIX_SRC ^ PIX_DST | PIX_COLOR(c)
  27.  
  28. #define COL(c) PIX_SRC|PIX_COLOR(c)
  29.  
  30. #define pix_mode(c) (pix_mode_op  | PIX_COLOR(c))
  31.  
  32. #define XPIX(coord) (int)(xorigin + (coord)*x_draw_scale)
  33. #define YPIX(coord) (int)(yorigin - (coord)*x_draw_scale)
  34.  
  35. #define XREAL(pix)  ((double)(pix-xorigin)/x_draw_scale)
  36. #define YREAL(pix)  ((double)(yorigin-pix)/x_draw_scale)
  37.  
  38.  
  39. extern Notify_error notify_dispatch();
  40.  
  41. static short icon_image[] = {
  42.  
  43. #include "leda.icon"
  44.  
  45. };
  46.  
  47. static mpr_static(leda_icon_pixrect,64,64,1,icon_image);
  48.  
  49.  
  50.  
  51. static char default_frame_label[128];
  52.  
  53. static char frame_label[80];
  54.  
  55. static char read_frame_format[] = "%8.2f %8.2f      %s";
  56.  
  57. static Frame    frame;
  58. static Canvas    canvas;
  59. static Pixwin  *pw = 0;
  60. static Icon    icon;
  61.  
  62. static Frame panel_frame;
  63. static Panel panel;
  64.  
  65. typedef void (*PRD)();
  66. typedef void (*PMA)();
  67.  
  68. static void x_draw_default_redraw() { /* do nothing */ }
  69.  
  70. static void x_draw_mouse_default_action(x,y) 
  71. double x,y;
  72. { /* do nothing */}
  73.  
  74. PRD x_draw_redraw = x_draw_default_redraw;
  75. PMA x_draw_mouse_action = x_draw_mouse_default_action;
  76.  
  77. static int x_draw_done;
  78.  
  79. static Pixfont *font;
  80.  
  81. static int pix_mode_op;
  82.  
  83. static int xdots,ydots, xorigin,yorigin;  /* pixels          */
  84.  
  85. static int mouse_key,mouse_xpix, mouse_ypix; 
  86. static int mouse_last_xpix, mouse_last_ypix;
  87. static int mouse_start_xpix, mouse_start_ypix;  /* start for segments  ... */
  88. static int mouse_read_kind;
  89.  
  90.  
  91. static double mouse_xreal,mouse_yreal;
  92. static double mouse_last_xreal,mouse_last_yreal;
  93. static double mouse_start_xreal,mouse_start_yreal;
  94.  
  95.  
  96. /* external variables */
  97.  
  98.  
  99. int SCREEN_WIDTH = 1152;
  100. int SCREEN_HEIGHT = 900;
  101.  
  102.    
  103. double x_draw_xmax,x_draw_xmin,x_draw_ymax,x_draw_ymin,x_draw_scale;   
  104.  
  105. int x_draw_grid_mode;
  106. int x_draw_depth;
  107.  
  108. int    x_draw_line_width, 
  109.        x_draw_node_width, 
  110.        x_draw_line_style, 
  111.        x_draw_text_mode, 
  112.        x_draw_drawing_mode,
  113.        x_draw_screen_flush;
  114.  
  115.  
  116. static unsigned char RED[256],GREEN[256],BLUE[256];
  117.  
  118. static char* x_draw_default_font = "screen.r.12";
  119.  
  120.  
  121. static Pr_texture *Line_style = 0;
  122.  
  123. static Pr_texture *solid;
  124. static Pr_texture *dashed;
  125. static Pr_texture *dotted;
  126.  
  127. /*
  128. x_draw_new_color(r,g,b)
  129. int r,g,b;
  130. { int col = col_count;
  131.   col_count++;
  132.   RED[col] =   r;  
  133.   GREEN[col] =   g;  
  134.   BLUE[col] =   b;
  135.   pw_setcmsname(pw,"new_color");
  136.   pw_putcolormap(pw,0,col_count,RED,GREEN,BLUE);
  137.   return col;
  138.  }
  139. */
  140.  
  141.  
  142.  
  143. x_draw_init_colors()
  144. { RED[0] = 255;  GREEN[0] = 255;  BLUE[0] = 255;  /* white  */
  145.   RED[1] =   0;  GREEN[1] =   0;  BLUE[1] =   0;  /* black  */
  146.   RED[2] = 255;  GREEN[2] =   0;  BLUE[2] =   0;  /* red    */
  147.   RED[3] =   0;  GREEN[3] = 255;  BLUE[3] =   0;  /* green  */
  148.   RED[4] =   0;  GREEN[4] = 100;  BLUE[4] = 255;  /* blue   */
  149.   RED[5] = 128;  GREEN[5] = 128;  BLUE[5] =   0;  /* yellow */
  150.   RED[6] = 128;  GREEN[6] =   0;  BLUE[6] = 178;  /* violet */
  151.   RED[7] = 192;  GREEN[7] =  64;  BLUE[7] =   0;  /* orange */
  152. /*
  153. indigo: RED[]  =  64;     GREEN[]  =   0;  BLUE[]  =  76; 
  154. */
  155.   pw_setcmsname(pw,"new_color");
  156.   pw_putcolormap(pw,0,8,RED,GREEN,BLUE);
  157.  }
  158.  
  159.  
  160. x_draw_set_redraw(f)
  161. PRD f;
  162. { x_draw_redraw = f; }
  163.  
  164. x_draw_set_frame_label(message)
  165. char* message;
  166. { strcpy(frame_label,message); }
  167.  
  168. x_draw_reset_frame_label()
  169. { strcpy(frame_label,default_frame_label); }
  170.  
  171. void x_draw_mouse_segment_action(x,y)
  172. double x,y;
  173. { pw_vector(pw, mouse_start_xpix,mouse_start_ypix,
  174.                 XPIX(x), YPIX(y),PIX_SRC^PIX_DST,1); 
  175. }
  176.  
  177. void x_draw_mouse_rect_action(x,y)
  178. double x,y;
  179. {   int save_pix_mode = pix_mode_op;
  180.     pix_mode_op = PIX_SRC ^ PIX_DST;
  181.     x_draw_rectangle(mouse_start_xreal,mouse_start_yreal,x,y,1,1);
  182.     pix_mode_op = save_pix_mode;
  183.  } 
  184.  
  185. void x_draw_mouse_circle_action(x,y)
  186. double x,y;
  187. {   double r = hypot(x - mouse_start_xreal, y - mouse_start_yreal);
  188.     int save_pix_mode = pix_mode_op;
  189.     pix_mode_op = PIX_SRC ^ PIX_DST;
  190.     x_draw_circle(mouse_start_xreal, mouse_start_yreal, r, 1, 1);    
  191.     pix_mode_op = save_pix_mode;
  192. }
  193.  
  194.  
  195. x_draw_set_font(fname)
  196. char* fname;
  197. { char buf[256];
  198.   Pixfont *f;
  199.  
  200.   sprintf(buf,"/usr/lib/fonts/fixedwidthfonts/%s",fname); 
  201.  
  202.   if ( f=pf_open(buf) ) 
  203.   { font =f ;
  204.     return 1;
  205.    }
  206.   else return 0;
  207.  
  208. }
  209.  
  210. x_draw_set_line_style(s)
  211. int s;
  212. { int save = x_draw_line_style;
  213.   x_draw_line_style = s;
  214.    
  215.    switch (x_draw_line_style)  {
  216.  
  217.    case 0 : Line_style = solid;
  218.             break;
  219.  
  220.    case 1 : Line_style = dashed;
  221.             break;
  222.  
  223.    case 2 : Line_style = dotted;
  224.             break;
  225.  
  226.    default: break;
  227.  
  228.    }
  229.   return save;
  230. }
  231.  
  232. int x_draw_set_mode(m)
  233. int m;
  234. { int save = x_draw_drawing_mode;
  235.   x_draw_drawing_mode = m;
  236.    
  237.    switch (x_draw_drawing_mode)  {
  238.  
  239.    case 0 : pix_mode_op  = PIX_SRC;
  240.             break;
  241.  
  242.    case 1 : pix_mode_op = PIX_SRC ^ PIX_DST;
  243.             break;
  244.  
  245.    default: break;
  246.  
  247.    }
  248.   return save;
  249. }
  250.  
  251. int x_draw_set_line_width(w)
  252. int w;
  253. { int save = x_draw_line_width;
  254.   x_draw_line_width = w;
  255.   return save;
  256.  }
  257.  
  258. int x_draw_set_node_width(w)
  259. int w;
  260. { int save = x_draw_node_width;
  261.   x_draw_node_width = w;
  262.   return save;
  263.  }
  264.  
  265. int x_draw_set_text_mode(m)
  266. int m;
  267. { int save = x_draw_text_mode;
  268.   x_draw_text_mode = m;
  269.   return save;
  270.  }
  271.  
  272.  
  273.  
  274. static void my_event_proc(canvas,event)
  275. Canvas canvas;
  276. Event* event;
  277. { 
  278.   char s[256];
  279.  
  280.   /*int k = event_action(event);  does not work for SUN3  */
  281.  
  282.   int k = event_id(event);
  283.  
  284.   switch (k) {
  285.  
  286.   case WIN_RESIZE: x_draw_init(x_draw_xmin,x_draw_xmax,x_draw_ymin,x_draw_grid_mode);
  287.                    break;
  288.  
  289.   case MS_LEFT:   mouse_key = 1;
  290.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  291.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  292.                   break;
  293.  
  294.   case MS_MIDDLE: mouse_key = 2;
  295.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  296.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  297.                   break;
  298.  
  299.   case MS_RIGHT:  mouse_key = 3;
  300.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  301.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  302.                   break;
  303.  
  304.   case KEY_RIGHT(7): /* left arrow */
  305.                      mouse_xpix -= (int)x_draw_scale*x_draw_grid_mode;
  306.                      window_set(canvas,WIN_MOUSE_XY,mouse_xpix,mouse_ypix,0);
  307.                      break;
  308.  
  309.   case KEY_RIGHT(9): /* right arrow */
  310.                      mouse_xpix += (int)x_draw_scale*x_draw_grid_mode;
  311.                      window_set(canvas,WIN_MOUSE_XY,mouse_xpix,mouse_ypix,0);
  312.                      break;
  313.  
  314.   case KEY_RIGHT(11): /* down arrow */
  315.                      mouse_ypix += (int)x_draw_scale*x_draw_grid_mode;
  316.                      window_set(canvas,WIN_MOUSE_XY,mouse_xpix,mouse_ypix,0);
  317.                      break;
  318.  
  319.   case KEY_RIGHT(5): /* up arrow */
  320.                      mouse_ypix -= (int)x_draw_scale*x_draw_grid_mode;
  321.                      window_set(canvas,WIN_MOUSE_XY,mouse_xpix,mouse_ypix,0);
  322.                      break;
  323.  
  324.   case KEY_RIGHT(1): /* center */
  325.                      mouse_xpix = XPIX(0);
  326.                      mouse_ypix = YPIX(0);
  327.                      window_set(canvas,WIN_MOUSE_XY,mouse_xpix,mouse_ypix,0);
  328.                      break;
  329.  
  330.  
  331.   default: mouse_xpix = event_x(event);
  332.            mouse_ypix = event_y(event);
  333.            break;
  334.  
  335.   }
  336.  
  337.  
  338.   if (x_draw_grid_mode)  x_draw_cursor();
  339.   
  340.     mouse_xreal =  x_draw_xmin+((double)mouse_xpix)/x_draw_scale;
  341.     mouse_yreal =  x_draw_ymax-((double)mouse_ypix)/x_draw_scale;
  342.   
  343.   if (x_draw_grid_mode) 
  344.   { 
  345.     mouse_xreal = x_draw_grid_mode * (int)(mouse_xreal/x_draw_grid_mode + ((mouse_xreal > 0) ? 0.5 : -0.5));
  346.     mouse_yreal = x_draw_grid_mode * (int)(mouse_yreal/x_draw_grid_mode + ((mouse_yreal > 0) ? 0.5 : -0.5));
  347.     mouse_xpix  = XPIX(mouse_xreal);
  348.     mouse_ypix  = YPIX(mouse_yreal);
  349.   
  350.     x_draw_cursor();
  351.   }
  352.  
  353.  
  354.   sprintf(s,read_frame_format, mouse_xreal,mouse_yreal,frame_label);
  355.   window_set(frame,FRAME_LABEL,s,0);
  356.  
  357.  
  358.   if (x_draw_mouse_action)  /* user defined action */
  359.   { x_draw_mouse_action(mouse_last_xreal,mouse_last_yreal);
  360.     x_draw_mouse_action(mouse_xreal,mouse_yreal);
  361.    }
  362.     
  363.  
  364.   mouse_last_xpix = mouse_xpix;
  365.   mouse_last_ypix = mouse_ypix;
  366.  
  367.   mouse_last_xreal = mouse_xreal;
  368.   mouse_last_yreal = mouse_yreal;
  369.  
  370. }
  371.  
  372. int x_read_mouse(kind, xstart,ystart,x,y)
  373. int    kind;   /* 0: point, 1: segment, 2:rectangle, 3: circle */
  374. double xstart;
  375. double ystart;
  376. double *x;
  377. double *y;
  378. { 
  379.   PMA f;
  380.  
  381.   switch(kind) {
  382.  
  383.   case 0 : f = x_draw_mouse_default_action;
  384.           break;
  385.  
  386.   case 1:  f = x_draw_mouse_segment_action;
  387.            break;
  388.  
  389.   case 2:  f = x_draw_mouse_rect_action;
  390.            break;
  391.  
  392.   case 3:  f = x_draw_mouse_circle_action;
  393.            break;
  394.  
  395.   default: f = x_draw_mouse_default_action;
  396.            break;
  397.  
  398.   }
  399.  
  400.   return x_read_mouse_action(f,xstart,ystart,x,y);
  401.  
  402. }
  403.  
  404. int x_read_mouse_action(action, xstart,ystart,x,y)
  405. PMA   action;
  406. double xstart;
  407. double ystart;
  408. double *x;
  409. double *y;
  410. { 
  411.   x_draw_mouse_action = action;
  412.  
  413.   mouse_key = 0;
  414.  
  415.   mouse_start_xreal = xstart;
  416.   mouse_start_yreal = ystart;
  417.  
  418.   mouse_start_xpix = XPIX(xstart);
  419.   mouse_start_ypix = YPIX(ystart);
  420.  
  421.   if (x_draw_grid_mode) x_draw_cursor();
  422.  
  423.   if (x_draw_mouse_action)  /* user defined action */
  424.   { x_draw_mouse_action(mouse_last_xreal,mouse_last_yreal);
  425.    }
  426.  
  427.  
  428.  
  429.   while (!mouse_key && !x_draw_done)  notify_dispatch();
  430.  
  431.   if (x_draw_done) return 0;
  432.  
  433.  
  434.   if (x_draw_mouse_action)  /* user defined action */
  435.   { x_draw_mouse_action(mouse_xreal,mouse_yreal);
  436.    }
  437.  
  438.  
  439.   if (x_draw_grid_mode) x_draw_cursor();
  440.  
  441.   *x = mouse_xreal;
  442.   *y = mouse_yreal;
  443.  
  444.  
  445.   return mouse_key;
  446. }
  447.   
  448.  
  449.  
  450.  
  451.  
  452.  
  453. Notify_value my_notice_destroy(frame, status)
  454. Frame frame;
  455. Destroy_status status;
  456. {
  457.   if (status !=DESTROY_CHECKING)
  458.   {
  459.     x_draw_done = 1;
  460.     (void) notify_stop();
  461.    }
  462.  
  463.   return (notify_next_destroy_func(frame,status));
  464. }
  465.  
  466.  
  467.  
  468.  
  469. x_draw_init_window(w_width,w_height,w_xpos,w_ypos,label)
  470. int w_width,
  471.     w_height,
  472.     w_xpos,
  473.     w_ypos;
  474. char* label;
  475. { 
  476.   if (pw!=0) 
  477.   { fprintf(stderr,"warning: second initialization of window ignored.\n");
  478.     return;
  479.    } 
  480.  
  481.   strcpy(default_frame_label,label);
  482.  
  483.   icon = icon_create(ICON_IMAGE, &leda_icon_pixrect, 0);
  484.  
  485.   frame = window_create(0, FRAME, 
  486.               WIN_WIDTH,    w_width,
  487.               WIN_HEIGHT,   w_height,
  488.               WIN_X,        w_xpos,
  489.               WIN_Y,        w_ypos,
  490.               FRAME_ICON,  icon,
  491.               FRAME_NO_CONFIRM, TRUE,
  492.               FRAME_LABEL, default_frame_label, 0);
  493.  
  494.   canvas = window_create(frame, CANVAS, 
  495.               WIN_CONSUME_KBD_EVENT,    WIN_RIGHT_KEYS,
  496.               WIN_IGNORE_PICK_EVENT,    WIN_UP_EVENTS,
  497.               WIN_EVENT_PROC,           my_event_proc,
  498.               0); 
  499.  
  500.   pw = canvas_pixwin(canvas);
  501.  
  502.   notify_interpose_destroy_func(frame,my_notice_destroy);
  503.  
  504.   window_set(frame,WIN_SHOW,TRUE,0);
  505.  
  506.  
  507.  
  508. /* init panel */
  509.  
  510.     panel_frame = window_create(0, FRAME,
  511.                              FRAME_NO_CONFIRM, TRUE, 
  512.                              WIN_X, 100, WIN_Y, 100, 0);
  513.  
  514.     panel = window_create(panel_frame, PANEL, 0);
  515.  
  516.  
  517.  
  518.   x_draw_set_font(x_draw_default_font);
  519.  
  520.   pix_mode_op = PIX_SRC;
  521.  
  522.   x_draw_init_colors(); 
  523.  
  524.   solid  = 0;
  525.   dashed = (Pr_texture*) malloc(sizeof(Pr_texture));
  526.   dashed->pattern = pr_tex_dashed;
  527.   dotted = (Pr_texture*) malloc(sizeof(Pr_texture));
  528.   dotted->pattern = pr_tex_dotted;
  529.  
  530.   x_draw_line_style   = 0;   /* solid */
  531.   x_draw_node_width   = 12;
  532.   x_draw_line_width   = 1;
  533.   x_draw_text_mode    = 0;   /* transparent   */
  534.   x_draw_drawing_mode = 0;   /* src           */
  535.  
  536. }
  537.  
  538.  
  539. x_draw_init(x0,x1,y0,g_mode)
  540. double x0,x1,y0;
  541. int g_mode;
  542. {
  543.   double x,y;
  544.  
  545.   if (x0>=x1) 
  546.   { fprintf(stderr,"Illegal arguments in draw_init: x0 >= x1\n");
  547.     exit(1);
  548.    }
  549.  
  550.   x_draw_grid_mode = g_mode; 
  551.  
  552.   x_draw_reset_frame_label();
  553.  
  554.   xdots = (int)window_get(canvas, CANVAS_WIDTH);
  555.   ydots = (int)window_get(canvas, CANVAS_HEIGHT);
  556.  
  557.   x_draw_depth = pw->pw_pixrect->pr_depth;
  558.  
  559.   x_draw_scale = ((double)xdots)/(x1-x0);
  560.  
  561.   /* at least grid distance of 2 pixels */
  562.   if ((x_draw_grid_mode) && (x_draw_grid_mode*x_draw_scale < 2)) 
  563.   { x_draw_grid_mode=0;  
  564.     fprintf(stderr,"warning: grid distance to small.\n");
  565.    }
  566.  
  567.   if (x_draw_grid_mode) 
  568.     if (x_draw_scale < 1) x_draw_scale = 1;
  569.     else x_draw_scale = (int)x_draw_scale;
  570.  
  571.   x_draw_xmin = x0;
  572.   x_draw_ymin = y0;
  573.   x_draw_xmax = x0+xdots/x_draw_scale;
  574.   x_draw_ymax = y0+ydots/x_draw_scale;
  575.  
  576.   xorigin = -x0*x_draw_scale;
  577.   yorigin = ydots+y0*x_draw_scale;
  578.  
  579.   mouse_xreal = 0;
  580.   mouse_yreal = 0;
  581.  
  582.   x_draw_clear(0);
  583.  
  584.  if (x_draw_grid_mode)  x_draw_cursor();
  585.  
  586.  notify_dispatch();
  587.  
  588.  if (x_draw_grid_mode)  x_draw_cursor();
  589.  
  590.  (*x_draw_redraw)();
  591.  
  592. }
  593.  
  594.  
  595. x_show_window() 
  596. { while (!x_draw_done) notify_dispatch(); }
  597.  
  598. x_draw_end()
  599. { if (pw)
  600.   { pw_close(pw);
  601.     pf_close(font);
  602.     /* window_destroy(frame); */
  603.     pw = 0;
  604.    }
  605. }
  606.  
  607. x_draw_line(x1, y1, x2, y2, col)
  608. double x1,y1,x2,y2;
  609. int col;
  610. { 
  611.   int C[4];
  612.   int i;
  613.   int M = 32768;   /* 2^15    */ 
  614.  
  615.   Pr_brush br;
  616.   br.width = x_draw_line_width;
  617.  
  618.  
  619.   C[0] = XPIX(x1);
  620.   C[1] = YPIX(y1);
  621.   C[2] = XPIX(x2);
  622.   C[3] = YPIX(y2);
  623.  
  624.   /* 
  625.     Fehler beim Clipping fuer Koordinaten mit Absolutwert in
  626.     [i*2^15..(i+1)*2^15-1],i ungerade.
  627.   */
  628.  
  629.  /*
  630.   for(i=0; i<4; i++)
  631.     if ((C[i]/M) % 2) C[i] = -C[i];
  632.  
  633.  */
  634.  
  635.   pw_line(pw,C[0],C[1],C[2],C[3],&br,Line_style,pix_mode(col));
  636.  
  637. }
  638.  
  639.  
  640. x_draw_point(x,y,col)
  641. double x,y;
  642. int col;
  643.  
  644. { int X,Y;
  645.  
  646.   Pr_brush br;
  647.   br.width = 1;
  648.  
  649.   X = XPIX(x);
  650.   Y = YPIX(y);
  651.  
  652.   if (x_draw_depth==1 && col>1) col = 1;
  653.  
  654.   pw_line(pw,X-2,Y-2,X+2,Y+2,&br,solid,pix_mode(col));
  655.   pw_line(pw,X+1,Y-1,X+2,Y-2,&br,solid,pix_mode(col));
  656.   pw_line(pw,X-1,Y+1,X-2,Y+2,&br,solid,pix_mode(col));
  657.  
  658.  
  659. }
  660.  
  661.  
  662. x_draw_node(x0,y0,col)
  663. double x0,y0;
  664. int col;
  665.  
  666. { int X0,Y0,x,y,e;
  667.  
  668.   int r = x_draw_node_width;
  669.  
  670.   struct pr_pos *points;
  671.   int n = 8*r;
  672.   int i = 0;
  673.  
  674.   points = (struct pr_pos*) malloc(n*sizeof(struct pr_pos));
  675.  
  676.  
  677.   X0 = XPIX(x0);
  678.   Y0 = YPIX(y0);
  679.  
  680.   if (x_draw_depth==1 && col>1) col = 1;
  681.  
  682.     x = 0;
  683.     y = r;
  684.     e = 3-2*y;
  685.  
  686.    points[i].x = X0;   points[i].y = Y0+r;
  687.    i++;
  688.    points[i].x = X0;   points[i].y = Y0-r;
  689.    i++;
  690.    points[i].x = X0+r; points[i].y = Y0;
  691.    i++;
  692.    points[i].x = X0-r; points[i].y = Y0;
  693.    i++;
  694.   
  695.     for (x=1;x<y;)
  696.     { points[i].x = X0+x; points[i].y = Y0+y;
  697.       i++;
  698.       points[i].x = X0+x; points[i].y = Y0-y;
  699.       i++;
  700.       points[i].x = X0-x; points[i].y = Y0+y;
  701.       i++;
  702.       points[i].x = X0-x; points[i].y = Y0-y;
  703.       i++;
  704.       points[i].x = X0+y; points[i].y = Y0+x;
  705.       i++;
  706.       points[i].x = X0+y; points[i].y = Y0-x;
  707.       i++;
  708.       points[i].x = X0-y; points[i].y = Y0+x;
  709.       i++;
  710.       points[i].x = X0-y; points[i].y = Y0-x;
  711.       i++;
  712.  
  713.       x++;
  714.       if (e>=0) { y--; e = e - 4*y; }
  715.       e = e + 4*x + 2;
  716.      }
  717.  
  718.  
  719.    points[i].x = X0+x; points[i].y = Y0+y;
  720.    i++;
  721.    points[i].x = X0+x; points[i].y = Y0-y;
  722.    i++;
  723.    points[i].x = X0-x; points[i].y = Y0+y;
  724.    i++;
  725.    points[i].x = X0-x; points[i].y = Y0-y;
  726.    i++;
  727.  
  728.    pw_polypoint(pw,0,0,i,points,pix_mode(col));
  729.  
  730.    free((char*)points);
  731.  
  732. }
  733.  
  734. x_draw_message(line,s,c)
  735. int line;
  736. char* s;
  737. int c;
  738. { int x = 30;
  739.   int y = 30*line;;
  740.   x_draw_set_font("cour.b.24");
  741.   pw_ttext(pw,x,y,XCOL(c),font,s);
  742.   x_draw_set_font(x_draw_default_font);
  743. }
  744.  
  745. x_draw_text_node(x0,y0,s,col)
  746. double x0,y0;
  747. int col;
  748. char* s;
  749. { 
  750.   if (x_draw_depth==1 || col == 1)
  751.    { x_draw_node(x0,y0,1);
  752.      x_draw_ctext(x0,y0,s,1);
  753.     }
  754.   else
  755.    { x_draw_filled_node(x0,y0,col);
  756.      x_draw_ctext(x0,y0,s,0);
  757.     }
  758.  
  759.  }
  760.  
  761. x_draw_int_node(x0,y0,i,col)
  762. double x0,y0;
  763. int i,col;
  764. { 
  765.   char buf[16];
  766.   sprintf(buf,"%d",i);
  767.   x_draw_text_node(x0,y0,buf,col);
  768.  }
  769.  
  770.  
  771. x_draw_filled_node(x0,y0,col)
  772. double x0,y0;
  773. int col;
  774. { 
  775.   int X0,Y0,x,y,e;
  776.   int r = x_draw_node_width;
  777.  
  778.   Pr_brush br;
  779.   br.width = 1;
  780.  
  781.   X0 = XPIX(x0);
  782.   Y0 = YPIX(y0);
  783.  
  784.   x = 1;
  785.   y = r;
  786.   e = 3-2*r;
  787.  
  788.   pw_line(pw,X0,Y0+y,X0,Y0-y,&br,0,pix_mode(col));
  789.  
  790.   while (x<=y)
  791.   { pw_line(pw,X0+x,Y0+y,X0+x,Y0,  &br,0,pix_mode(col));
  792.     pw_line(pw,X0+x,Y0-y,X0+x,Y0-1,&br,0,pix_mode(col));
  793.     pw_line(pw,X0-x,Y0+y,X0-x,Y0,  &br,0,pix_mode(col));
  794.     pw_line(pw,X0-x,Y0-y,X0-x,Y0-1,&br,0,pix_mode(col));
  795.  
  796.  
  797.     if (x<y && e>=0) 
  798.     { pw_line(pw,X0+y,Y0+x,X0+y,Y0,  &br,0,pix_mode(col));
  799.       pw_line(pw,X0+y,Y0-x,X0+y,Y0-1,&br,0,pix_mode(col));
  800.       pw_line(pw,X0-y,Y0+x,X0-y,Y0,  &br,0,pix_mode(col));
  801.       pw_line(pw,X0-y,Y0-x,X0-y,Y0-1,&br,0,pix_mode(col));
  802.       y--; 
  803.       e = e - 4*y; 
  804.      }
  805.  
  806.     x++;
  807.  
  808.     e = e + 4*x + 2;
  809.    }
  810.  
  811. }
  812.  
  813. x_draw_ellipse()
  814. { fprintf(stderr,"sorry, draw ellipse not iplemented\n"); }
  815.  
  816. x_draw_filled_ellipse()
  817. { fprintf(stderr,"sorry, draw ellipse not iplemented\n"); }
  818.  
  819. x_draw_circle(x0,y0,r,col)
  820. double x0,y0,r; 
  821. int col;
  822.  
  823. { int save = x_draw_node_width;
  824.   x_draw_node_width = (int)(r*x_draw_scale);
  825.   x_draw_node(x0,y0,col);
  826.   x_draw_node_width = save;
  827.  }
  828.  
  829.  
  830. x_draw_filled_circle(x0,y0,r,col)
  831. double x0,y0,r; 
  832. int col;
  833. { int save = x_draw_node_width;
  834.   x_draw_node_width = (int)(r*x_draw_scale);
  835.   x_draw_filled_node(x0,y0,col);
  836.   x_draw_node_width = save;
  837.  }
  838.  
  839.  
  840. x_draw_xpix(x)
  841. double x;
  842. { return XPIX(x); }
  843.  
  844. x_draw_ypix(x)
  845. double x;
  846. { return YPIX(x); }
  847.  
  848. x_draw_pix(x,y,col)
  849. double x,y;
  850. int col;
  851. { pw_put(pw,XPIX(x),YPIX(y),col); }
  852.  
  853.  
  854. x_draw_plot_xy(x0,x1,f,col)
  855. double x0,x1;
  856. double (*f)();
  857. int col;
  858. { 
  859.  
  860.   int x = XPIX(x0);
  861.   int y_old = YPIX((*f)(x0));
  862.   int i,y_new;
  863.   int size = 0;
  864.   int n = 0;
  865.  
  866.   struct pr_pos *points;
  867.  
  868.   for(x = XPIX(x0)+1; x <= XPIX(x1); x++)
  869.   { y_new = YPIX((*f)(XREAL(x)));
  870.     if (y_new > y_old)
  871.        size += (y_new-y_old+1);
  872.     else
  873.        size += (y_old-y_new+1);
  874.     y_old = y_new;
  875.    }
  876.  
  877.   points = (struct pr_pos*) malloc(size*sizeof(struct pr_pos));
  878.  
  879.   y_old = YPIX((*f)(x0));
  880.  
  881.   for(x = XPIX(x0)+1; x <= XPIX(x1); x++)
  882.   { y_new = YPIX((*f)(XREAL(x)));
  883.     if (y_new > y_old)
  884.       for(i=y_old; i<=y_new; i++)  
  885.       { points[n].x = x; 
  886.         points[n].y = i;
  887.         n++;
  888.        }
  889.     else
  890.       for(i=y_old; i>=y_new; i--)  
  891.       { points[n].x = x; 
  892.         points[n].y = i;
  893.         n++;
  894.        }
  895.     y_old = y_new;
  896.   }
  897.  
  898.  pw_polypoint(pw,0,0,size,points,pix_mode(col));
  899.  
  900.  free((char*)points);
  901.   
  902. }
  903.  
  904. x_draw_plot_yx(y0,y1,f,col)
  905. double y0,y1;
  906. double (*f)();
  907. int col;
  908. { 
  909.  
  910.   int y;
  911.   int i,x_new;
  912.   int x_old = XPIX((*f)(y0));
  913.   int size = 0;
  914.   int n = 0;
  915.  
  916.   struct pr_pos *points;
  917.  
  918.   for(y = YPIX(y0)-1; y >= YPIX(y1); y--)
  919.   { x_new = XPIX((*f)(YREAL(y)));
  920.     if (x_new > x_old)
  921.        size += (x_new-x_old+1);
  922.     else
  923.        size += (x_old-x_new+1);
  924.     x_old = x_new;
  925.    }
  926.  
  927.   points = (struct pr_pos*) malloc(size*sizeof(struct pr_pos));
  928.  
  929.   x_old = XPIX((*f)(y0));
  930.  
  931.   for(y = YPIX(y0)-1; y >= YPIX(y1); y--)
  932.   { 
  933.     x_new = XPIX((*f)(YREAL(y)));
  934.     if (x_new > x_old)
  935.       for(i=x_old; i<=x_new; i++)  
  936.       { points[n].x = i; 
  937.         points[n].y = y;
  938.         n++;
  939.        }
  940.     else
  941.       for(i=x_old; i>=x_new; i--)  
  942.       { points[n].x = i; 
  943.         points[n].y = y;
  944.         n++;
  945.        }
  946.     x_old = x_new;
  947.   }
  948.  
  949.  pw_polypoint(pw,0,0,size,points,pix_mode(col));
  950.  
  951.  free((char*)points);
  952.   
  953. }
  954.  
  955.  
  956. x_draw_filled_polygon(n,xcoord,ycoord,col)
  957. int col, n;
  958. double *xcoord, *ycoord;
  959. {struct pr_pos *edges;
  960.  int i;
  961.  
  962.  edges = (struct pr_pos*) malloc(n*sizeof(struct pr_pos));
  963.  
  964.  for(i=0;i<n;i++) 
  965.  { edges[i].x = XPIX(xcoord[i]);
  966.    edges[i].y = YPIX(ycoord[i]);
  967.   }
  968.  
  969.  pw_polygon_2(pw,0,0,1,&n,edges,pix_mode(col),0,0,0);
  970.  
  971. /*
  972.  free((char*)edges);
  973. */
  974.  
  975.  }
  976.  
  977. x_draw_polygon(n,xcoord,ycoord,col)
  978. int col, n;
  979. double *xcoord, *ycoord;
  980. { int i;
  981.  
  982.   for(i=0;i<n-1;i++) 
  983.     x_draw_line(xcoord[i],ycoord[i], xcoord[i+1],ycoord[i+1],col);
  984.  
  985.   x_draw_line(xcoord[n-1],ycoord[n-1],xcoord[0],ycoord[0],col);
  986.  
  987.  }
  988.  
  989. x_draw_rectangle(x1,y1,x2,y2,col)
  990. double x1,y1,x2,y2;
  991. int col;
  992. {
  993.  x_draw_line(x1,y1,x1,y2,col);
  994.  x_draw_line(x1,y2,x2,y2,col);
  995.  x_draw_line(x2,y2,x2,y1,col);
  996.  x_draw_line(x2,y1,x1,y1,col);
  997.  
  998.  }
  999.  
  1000.  
  1001. x_draw_filled_rectangle(x1,y1,x2,y2,col)
  1002. double x1,y1,x2,y2; 
  1003. int col;
  1004. { double xcoord[4], ycoord[4];
  1005.  
  1006.  xcoord[0] = x1;   
  1007.  ycoord[0] = y1;   
  1008.  xcoord[1] = x1;  
  1009.  ycoord[1] = y2;   
  1010.  xcoord[2] = x2; 
  1011.  ycoord[2] = y2;   
  1012.  xcoord[3] = x2;
  1013.  ycoord[3] = y1;
  1014.  
  1015.  x_draw_filled_polygon(4,xcoord,ycoord,col);
  1016.  
  1017.  }
  1018.  
  1019. x_draw_copy_rect(x1,y1,x2,y2,x,y)
  1020. double x1,y1,x2,y2,x,y;
  1021. {
  1022.  pw_copy(pw,XPIX(x1),YPIX(y1),(x2-x1)*x_draw_scale,(y2-y1)*x_draw_scale,
  1023.          pix_mode(1), pw,XPIX(x),YPIX(y));
  1024.  }
  1025.  
  1026.  
  1027. x_draw_clear(col)
  1028. int col;
  1029. {struct pr_pos edges[4];
  1030.  struct pr_pos *grid_points;
  1031.  int i=0;
  1032.  int n = 4;
  1033.  double x,y;
  1034.  int save;
  1035.  
  1036.  edges[0].x = 0;
  1037.  edges[0].y = 0;
  1038.  edges[1].x = xdots;
  1039.  edges[1].y = 0;
  1040.  edges[2].x = xdots;
  1041.  edges[2].y = ydots;
  1042.  edges[3].x = 0;
  1043.  edges[3].y = ydots;
  1044.  
  1045.  pw_polygon_2(pw,0,0,1,&n,edges,COL(col),0,0,0);
  1046.  
  1047.  save = x_draw_set_node_width(1);
  1048.  
  1049.  n = 0;
  1050.  if (x_draw_grid_mode) /* draw grid */
  1051.  { for(x = (int)(x_draw_xmin/x_draw_grid_mode)*x_draw_grid_mode; x<=x_draw_xmax; x+=x_draw_grid_mode)
  1052.    for(y = (int)(x_draw_ymin/x_draw_grid_mode)*x_draw_grid_mode; y<=x_draw_ymax; y+=x_draw_grid_mode)
  1053.      n++;
  1054.  
  1055.    grid_points = (struct pr_pos*) malloc(n*sizeof(struct pr_pos));
  1056.  
  1057.  
  1058.    for(x = (int)(x_draw_xmin/x_draw_grid_mode)*x_draw_grid_mode; x<=x_draw_xmax; x+=x_draw_grid_mode)
  1059.    for(y = (int)(x_draw_ymin/x_draw_grid_mode)*x_draw_grid_mode; y<=x_draw_ymax; y+=x_draw_grid_mode)
  1060.    { if (x*y == 0) x_draw_filled_node(x,y,1,1);
  1061.      else { grid_points[i].x = XPIX(x);
  1062.             grid_points[i].y = YPIX(y);
  1063.             i++;
  1064.            }
  1065.     }
  1066.    pw_polypoint(pw,0,0,n,grid_points,COL(1));
  1067.   }
  1068.  
  1069.   x_draw_set_node_width(save);
  1070.  
  1071.  }
  1072.  
  1073.  
  1074. /* TEXT  */
  1075.  
  1076. x_draw_text(x,y,s,col)
  1077. double x,y;
  1078. char * s;
  1079. int col;
  1080. { if (x_draw_text_mode == 1)   /* opaque */
  1081.     pw_text(pw,XPIX(x),YPIX(y),pix_mode(col),font,s);
  1082.   else
  1083.     pw_ttext(pw,XPIX(x),YPIX(y),pix_mode(col),font,s);
  1084. }
  1085.  
  1086. x_draw_ctext(x,y,s,col)
  1087. double x,y;
  1088. char * s;
  1089. int col;
  1090. { 
  1091.   struct pr_size size;
  1092.   size = pf_textwidth(strlen(s),font,s);
  1093.   x -= ((double)size.x)/(2*x_draw_scale);
  1094.   y -= ((double)size.y)/(3*x_draw_scale);
  1095.   x_draw_text(x,y,s,col);
  1096. }
  1097.  
  1098.  
  1099. x_draw_int(x0,y0,i,col)
  1100. double x0,y0;
  1101. int i,col;
  1102. { 
  1103.   char buf[16];
  1104.   sprintf(buf,"%d",i);
  1105.   x_draw_ctext(x0,y0,buf,col);
  1106.  }
  1107.  
  1108.  
  1109. x_draw_cursor()
  1110. { 
  1111.   int X,Y;
  1112.  
  1113.   X = XPIX(mouse_xreal);
  1114.   Y = YPIX(mouse_yreal);
  1115.  
  1116.   pw_vector(pw,X,Y,X+10,Y,PIX_SRC^PIX_DST,1);
  1117.   pw_vector(pw,X,Y,X-10,Y,PIX_SRC^PIX_DST,1);
  1118.   pw_vector(pw,X,Y,X,Y+10,PIX_SRC^PIX_DST,1);
  1119.   pw_vector(pw,X,Y,X,Y-10,PIX_SRC^PIX_DST,1);
  1120.  
  1121. }
  1122.  
  1123.  
  1124. int x_draw_screen_width()
  1125. { Rect *r;
  1126.   Frame frame = window_create(0, FRAME,NULL); 
  1127.   r = (Rect *) window_get(frame, WIN_SCREEN_RECT);
  1128.   window_destroy(frame);
  1129.   return(r->r_width);
  1130. }
  1131.  
  1132.  
  1133. int x_draw_screen_height()
  1134. { Rect *r;
  1135.   Frame frame = window_create(0, FRAME,NULL); 
  1136.   r = (Rect *) window_get(frame, WIN_SCREEN_RECT);
  1137.   window_destroy(frame);
  1138.   return(r->r_height);
  1139. }
  1140.  
  1141. static void
  1142. center_frame(frame)
  1143. Frame frame;
  1144. { Rect * r;
  1145.   int left,top,width,height;
  1146.  
  1147.     /* center frame on the screen */
  1148.  
  1149.     r = (Rect *) window_get(frame, WIN_SCREEN_RECT);
  1150.  
  1151.     width = (int) window_get(frame, WIN_WIDTH);
  1152.     height = (int) window_get(frame, WIN_HEIGHT);
  1153.  
  1154.     left = (r->r_width - width) / 2;
  1155.     top = (r->r_height - height) / 2;
  1156.  
  1157.     if (left < 0)
  1158.     left = 0;
  1159.     if (top < 0)
  1160.     top = 0;
  1161.  
  1162.     window_set(frame, WIN_X, left, WIN_Y, top, 0);
  1163. }
  1164.  
  1165.  
  1166. int x_draw_confirm(header)
  1167. char *header;
  1168. { /* ask for yes or no */
  1169.   char* s[2];
  1170.   s[0] = "NO";
  1171.   s[1] = "YES";
  1172.   return x_draw_read_panel(header,2,s,0);
  1173. }
  1174.  
  1175. int x_draw_acknowledge(header)
  1176. char *header;
  1177. { /* ask for ok */
  1178.   char *s = "OK";
  1179.   return x_draw_read_panel(header,1,&s,0);
  1180. }
  1181.  
  1182. static Frame    init_panel_frame();
  1183. static void    panel_input_notify();
  1184. static int      panel_answer;
  1185.  
  1186. int x_draw_read_panel(message,n,labels,vertical)
  1187. char    *message;
  1188. int n;
  1189. char    **labels;
  1190. int    vertical;
  1191. {
  1192.     Frame    panel_frame;
  1193.     int        answer;
  1194.  
  1195.     if (x_draw_grid_mode) x_draw_cursor();
  1196.  
  1197.     /* create the panel_frame */
  1198.     panel_frame = init_panel_frame(message,n,labels,vertical);
  1199.  
  1200.     /* make the user answer */
  1201.     window_main_loop(panel_frame);
  1202.  
  1203.     /* destroy the panel_frame */
  1204.     window_set(panel_frame, FRAME_NO_CONFIRM, TRUE, 0);
  1205.     window_destroy(panel_frame);
  1206.  
  1207.     if (x_draw_grid_mode) x_draw_cursor();
  1208.  
  1209.     return panel_answer;
  1210. }
  1211.  
  1212.  
  1213. static Frame
  1214. init_panel_frame(message,num,label,vertical)
  1215. char    *message;
  1216. int     num;
  1217. char   **label;
  1218. int    vertical;
  1219. {
  1220.     Frame        panel_frame;
  1221.     Panel        panel;
  1222.     Panel_item        message_item;
  1223.     int            left, top, width, height;
  1224.     struct pixrect    *pr[32];
  1225.     Rect                *r;
  1226.     int                 i;
  1227.  
  1228.     panel_frame = window_create(0, FRAME, FRAME_SHOW_LABEL, FALSE, 0);
  1229.  
  1230.     panel = window_create(panel_frame, PANEL, 0);
  1231.  
  1232.     message_item = panel_create_item(panel, PANEL_MESSAGE, 
  1233.                            PANEL_LABEL_STRING, message,
  1234.                        0);
  1235.  
  1236.     r = (Rect *) panel_get(message_item, PANEL_ITEM_RECT);
  1237.  
  1238.     width = 0;
  1239.  
  1240.     for(i=0;i<num;i++)
  1241.     { pr[i] = panel_button_image(panel, label[i], 3, 0);
  1242.       width += pr[i]->pr_width;
  1243.      }
  1244.  
  1245.     /* center buttons under the message */
  1246.  
  1247.     left = (r->r_width - width) / 2;
  1248.     if (left < 0)
  1249.     left = 0;
  1250.  
  1251.     height = rect_bottom(r) + 5;
  1252.     top = height;
  1253.  
  1254.     panel_create_item(panel, PANEL_BUTTON, 
  1255.         PANEL_ITEM_X, left, PANEL_ITEM_Y, top,
  1256.             PANEL_LABEL_IMAGE, pr[0],
  1257.             PANEL_CLIENT_DATA, 0,
  1258.             PANEL_NOTIFY_PROC, panel_input_notify,
  1259.             0);
  1260.  
  1261.  
  1262.     for(i=1;i<num;i++)
  1263.     { if (vertical)
  1264.          panel_create_item(panel, PANEL_BUTTON, 
  1265.                  PANEL_ITEM_X, left, PANEL_ITEM_Y, top+=height,
  1266.                  PANEL_LABEL_IMAGE, pr[i],
  1267.                  PANEL_CLIENT_DATA, i,
  1268.                  PANEL_NOTIFY_PROC, panel_input_notify,
  1269.                  0);
  1270.       else
  1271.          panel_create_item(panel, PANEL_BUTTON, 
  1272.                     PANEL_LABEL_IMAGE, pr[i],
  1273.                     PANEL_CLIENT_DATA, i,
  1274.                     PANEL_NOTIFY_PROC, panel_input_notify,
  1275.                     0);
  1276.     }
  1277.  
  1278.  
  1279.     window_fit(panel);
  1280.     window_fit(panel_frame);
  1281.  
  1282.     center_frame(panel_frame);
  1283.  
  1284.     return panel_frame;
  1285.  
  1286. }
  1287.  
  1288.  
  1289. /* notify proc */
  1290. static void panel_input_notify(item, event)
  1291. Panel_item    item;
  1292. Event        *event;
  1293. {   panel_answer = (int)panel_get(item, PANEL_CLIENT_DATA);
  1294.     notify_stop(); 
  1295. }
  1296.  
  1297.  
  1298.  
  1299.  
  1300. /* Text Panels */
  1301.  
  1302.  
  1303. static Frame  init_text_panel_frame();
  1304. static void   text_panel_ok_notify();
  1305. static void   text_panel_input_notify();
  1306. static void   text_panel_menu_proc();
  1307. static char   text_panel_answer[256];
  1308.  
  1309. static char **text_panel_menu_strings;
  1310. static Menu   text_panel_menu;
  1311. static Frame  text_panel_frame;
  1312. static Panel  text_panel;
  1313. static Panel_item panel_text_item;
  1314.  
  1315. char* x_draw_read_text_panel(message,menu_label,n,items)
  1316. int      n;
  1317. char   **items;
  1318. char    *message;
  1319. char    *menu_label;
  1320. {
  1321.     if (x_draw_grid_mode) x_draw_cursor();
  1322.  
  1323.     init_text_panel_frame(message,menu_label,n,items);
  1324.  
  1325.     window_main_loop(text_panel_frame);
  1326.  
  1327.     window_set(text_panel_frame, FRAME_NO_CONFIRM, TRUE, 0);
  1328.     window_destroy(text_panel_frame);
  1329.  
  1330.     if (x_draw_grid_mode) x_draw_cursor();
  1331.  
  1332.     return text_panel_answer;
  1333. }
  1334.  
  1335.  
  1336.  
  1337.  
  1338.  
  1339. static Frame
  1340. init_text_panel_frame(message,menu_l,n,items)
  1341. int      n;
  1342. char    *message;
  1343. char    *menu_l;
  1344. char   **items;
  1345. {
  1346.     Panel_item        message_item;
  1347.     int            left, top, width, height;
  1348.     Rect        *r;
  1349.     int i;
  1350.     int cols;
  1351.     char* menu_label[64];
  1352.   
  1353.     cols = 1 +n/15;
  1354.  
  1355.     sprintf(menu_label,"%s -->",menu_l);
  1356.  
  1357.  
  1358.     text_panel_frame = window_create(0, FRAME, FRAME_SHOW_LABEL, FALSE, 0);
  1359.  
  1360.     text_panel = window_create(text_panel_frame, PANEL, 0);
  1361.  
  1362.     panel_text_item = panel_create_item(text_panel, PANEL_TEXT, 
  1363.                            PANEL_ITEM_Y, 15,
  1364.                            PANEL_NOTIFY_PROC,  text_panel_input_notify,
  1365.                            PANEL_LABEL_STRING, message,
  1366.                            PANEL_VALUE_DISPLAY_LENGTH, 25,
  1367.                            PANEL_VALUE_STORED_LENGTH, 256, 
  1368.                         /* PANEL_VALUE, default_text,   */
  1369.                        0);
  1370.  
  1371.     if (n > 0)
  1372.     { text_panel_menu_strings = items;
  1373.  
  1374.       text_panel_menu = menu_create( MENU_DEFAULT, 0, MENU_NCOLS, cols, 0);
  1375.  
  1376.       for(i=0;i<n;i++) menu_set(text_panel_menu,MENU_STRING_ITEM,items[i],i,0);
  1377.  
  1378.       panel_create_item(text_panel, PANEL_BUTTON,
  1379.               PANEL_LABEL_IMAGE,panel_button_image(text_panel,menu_label,0,0), 
  1380.               PANEL_EVENT_PROC, text_panel_menu_proc,
  1381.                         0);
  1382.      }
  1383.  
  1384.  
  1385.     window_fit(text_panel);
  1386.     window_fit(text_panel_frame);
  1387.  
  1388.     center_frame(text_panel_frame);
  1389.  
  1390. }
  1391.  
  1392.  
  1393. /* notify proc */
  1394. static void text_panel_input_notify(item, event)
  1395. Panel_item    item;
  1396. Event        *event;
  1397. {
  1398.     strcpy(text_panel_answer,(char*)panel_get_value(item));
  1399.     notify_stop();
  1400. }
  1401.  
  1402.  
  1403. static void text_panel_menu_proc(item, event)
  1404. Panel_item item;
  1405. Event *event;
  1406. { int i;
  1407.   if (event_id(event) == MS_RIGHT && event_is_down(event))
  1408.   { i = (int)menu_show(text_panel_menu, text_panel, event,0);
  1409.     window_set(panel_text_item,PANEL_VALUE,text_panel_menu_strings[i],0);
  1410.     strcpy(text_panel_answer,text_panel_menu_strings[i]);
  1411.     notify_stop();
  1412.    }
  1413.   else panel_default_handle_event(item,event);
  1414. }
  1415.  
  1416. void x_draw_flush() {}
  1417.  
  1418. void x_draw_notice() {}
  1419.  
  1420.  
  1421. x_draw_message_panel(argc, argv)
  1422. char *argv[];
  1423. {
  1424.     Frame      panel_frame;
  1425.     Panel      panel;
  1426.     Panel_item item,but;
  1427.     int        i,left, top, width, height;
  1428.     Rect      *r;
  1429.  
  1430.     if (x_draw_grid_mode) x_draw_cursor();
  1431.  
  1432.     panel_frame = window_create(0, FRAME,
  1433.                                 FRAME_LABEL, argv[0],
  1434.                                 0);
  1435.  
  1436.     panel = window_create(panel_frame, PANEL,0);
  1437.  
  1438.     if (argc > 1)
  1439.     { item = panel_create_item(panel, PANEL_MESSAGE, 
  1440.                 PANEL_ITEM_Y,20,
  1441.                 PANEL_ITEM_X,25,
  1442.                 PANEL_LABEL_BOLD, TRUE, 
  1443.                 PANEL_LABEL_STRING, argv[1],
  1444.                 NULL);
  1445.       r = (Rect *) panel_get(item, PANEL_ITEM_RECT);
  1446.       width = r->r_width;
  1447.      }
  1448.  
  1449.     for(i = 2; i< argc; i++)
  1450.     { item = panel_create_item(panel, PANEL_MESSAGE, 
  1451.                 PANEL_ITEM_X,25,
  1452.                 PANEL_ITEM_Y,20*i,
  1453.                 PANEL_LABEL_BOLD, TRUE, 
  1454.                 PANEL_LABEL_STRING, argv[i],
  1455.                 NULL);
  1456.       r = (Rect *) panel_get(item, PANEL_ITEM_RECT);
  1457.       if (width < r->r_width) width = r->r_width;
  1458.      }
  1459.  
  1460.     but = panel_create_item(panel, PANEL_BUTTON,
  1461. /*
  1462.                 PANEL_ITEM_X,width/2 - 15,
  1463. */
  1464.                 PANEL_CLIENT_DATA, 0,
  1465.                 PANEL_LABEL_IMAGE, panel_button_image(panel, "OK", 3, 0),
  1466.                 PANEL_NOTIFY_PROC, panel_input_notify,
  1467.                 NULL);
  1468.  
  1469.     window_fit(panel);
  1470.     window_fit(panel_frame);
  1471.  
  1472.     center_frame(panel_frame);
  1473.  
  1474.     window_main_loop(panel_frame);
  1475.  
  1476.     window_set(panel_frame, FRAME_NO_CONFIRM, TRUE, 0);
  1477.     window_destroy(panel_frame);
  1478.  
  1479.     if (x_draw_grid_mode) x_draw_cursor();
  1480.  
  1481. }
  1482.  
  1483.