home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / graphics / _xview.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  41.0 KB  |  1,977 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _xview.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 <math.h>
  17. #include <string.h>
  18. #include <stdio.h>
  19. #include <values.h>
  20.  
  21. #include <X11/X.h>
  22. #include <X11/Xlib.h>
  23.  
  24. #include <xview/xview.h>
  25. #include <xview/canvas.h>
  26. #include <xview/cms.h>
  27. #include <xview/scrollbar.h>
  28. #include <xview/xv_xrect.h>
  29. #include <xview/panel.h>
  30. #include <xview/font.h>
  31. #include <xview/notice.h>
  32. #include <xview/openmenu.h>
  33. #include <xview/icon.h>
  34.  
  35.  
  36. #undef TRACE 
  37.  
  38. #ifdef TRACE
  39. #define DPRINT(x) printf x
  40. #else
  41. #define DPRINT(x)
  42. #endif
  43.  
  44.  
  45. #define XPIX(coord) (int)(xorigin + (coord)*x_draw_scale)
  46. #define YPIX(coord) (int)(yorigin - (coord)*x_draw_scale)
  47.  
  48. #define XREAL(pix)  ((double)(pix-xorigin)/x_draw_scale)
  49. #define YREAL(pix)  ((double)(yorigin-pix)/x_draw_scale)
  50.  
  51.  
  52. extern Notify_error notify_dispatch();
  53.  
  54. static repaint_count;
  55.  
  56.  
  57. static short icon_image[] = {
  58.  
  59. #include "leda.icon"
  60.  
  61. };
  62.  
  63. static mpr_static(leda_icon_pixrect,64,64,1,icon_image);
  64.  
  65.  
  66. static char default_frame_label[128];
  67.  
  68. /* pr_tex_dashed */
  69. static unsigned char dotted[2] = { 2,6 };
  70. static unsigned char dashed[2] = { 4,4 };
  71.  
  72. static char frame_label[80];
  73.  
  74. static char read_frame_format[] = "%8.2f %8.2f      %s";
  75.  
  76. static Frame    frame;
  77. static Canvas    canvas;
  78. static Pixwin  *pw = 0;
  79.  
  80. static Pixmap   buffer_pixmap[8];
  81. static int      buffer_width[8];
  82. static int      buffer_height[8];
  83.  
  84. static int              pixel_table[8];
  85. static Xv_cmsdata    cms_data;    
  86. static unsigned char    red[8], green[8], blue[8];
  87.  
  88.  
  89. static char     text_panel_answer[256];
  90.  
  91. static Frame   panel_frame;
  92. static Panel   panel;
  93. static Icon    icon;
  94.  
  95. static void panel_input_notify();
  96. static void init_panel_frame();
  97. static void panel_input_text_notify();
  98. static void init_panel_text_frame();
  99. static void text_panel_menu_proc();
  100.  
  101.  
  102. typedef void (*PRD)();
  103. typedef void (*PMA)();
  104.  
  105. static void x_draw_mouse_default_action(x,y) 
  106. double x,y;
  107. { /* do nothing */}
  108.  
  109. PRD x_draw_redraw = 0;
  110. PMA x_draw_mouse_action = x_draw_mouse_default_action;
  111.  
  112. static int x_draw_done;
  113.  
  114. static Xv_Font text_font,bold_font,message_font;
  115. static Display *display;
  116. static Drawable drawable;
  117. static int screen;
  118.  
  119. static GC  gc;
  120.  
  121. static int xpix_mode_op;
  122.  
  123. static int draw_init_done = FALSE;
  124.  
  125. static int xdots,ydots, xorigin,yorigin;  /* pixels          */
  126.  
  127. static int mouse_key,mouse_xpix, mouse_ypix; 
  128. static int mouse_last_xpix, mouse_last_ypix;
  129. static int mouse_start_xpix, mouse_start_ypix;  /* start for segments  ... */
  130. static int mouse_read_kind;
  131.  
  132.  
  133. static double mouse_xreal,mouse_yreal;
  134. static double mouse_last_xreal,mouse_last_yreal;
  135. static double mouse_start_xreal,mouse_start_yreal;
  136.  
  137.  
  138. /* external variables */
  139.  
  140. int SCREEN_WIDTH = 1152;
  141. int SCREEN_HEIGHT = 900;
  142.    
  143. double x_draw_xmax,x_draw_xmin,x_draw_ymax,x_draw_ymin,x_draw_scale;   
  144.  
  145. int    x_draw_grid_mode;
  146. int    x_draw_depth;
  147.  
  148. int    x_draw_line_width, x_draw_node_width, x_draw_line_style, x_draw_color,
  149.        x_draw_text_mode, x_draw_drawing_mode, x_draw_screen_flush;
  150.  
  151.  
  152.  
  153. static int  screen_width, screen_height;
  154.  
  155.  
  156.  
  157.  
  158. static Xv_singlecolor x_draw_color_map[] = {
  159.  
  160.  {  255,  255,  255 },  /* white  */
  161.  {    0,    0,    0 },  /* black  */
  162.  {  255,    0,    0 },  /* red    */
  163.  {    0,  255,    0 },  /* green  */
  164.  {    0,  100,  255 },  /* blue   */
  165.  {  128,  128,    0 },  /* yellow */
  166.  {  128,    0,  178 },  /* violet */
  167.  {  192,   64,    0 }   /* orange */
  168.  
  169. };
  170.  
  171.  
  172. static int Line_style = 0;
  173.  
  174.  
  175.  
  176. x_draw_flush() { XFlush(display); }
  177.  
  178. x_draw_set_redraw(f)
  179. PRD f;
  180. { x_draw_redraw = f; }
  181.  
  182. x_draw_set_frame_label(message)
  183. char* message;
  184. { /* strcpy(frame_label,message);  */
  185.   window_set(frame,FRAME_LABEL,message,0);
  186. }
  187.  
  188.  
  189. x_draw_reset_frame_label() 
  190. { /* strcpy(frame_label,default_frame_label); } */
  191.   window_set(frame,FRAME_LABEL,default_frame_label,0);
  192.  }
  193.  
  194.  
  195. x_draw_set_gc_read_mouse()
  196. { XGCValues gc_val;
  197.   gc_val.function = GXxor; 
  198.   gc_val.foreground = pixel_table[1];
  199.   gc_val.line_style = LineSolid;
  200.   gc_val.line_width = 1;
  201.   XChangeGC(display,gc,GCForeground|GCFunction|GCLineStyle|GCLineWidth,&gc_val);
  202.   XFlush(display);
  203. }
  204.  
  205. x_draw_reset_gc()
  206. { XGCValues gc_val;
  207.   gc_val.function   = xpix_mode_op; 
  208.   gc_val.foreground = pixel_table[x_draw_color];
  209.   gc_val.line_style = Line_style;
  210.   gc_val.line_width = x_draw_line_width;
  211.   XChangeGC(display,gc,GCForeground|GCFunction|GCLineStyle|GCLineWidth,&gc_val);
  212.   XFlush(display);
  213. }
  214.  
  215. void x_draw_mouse_segment_action(x,y)
  216. double x,y;
  217. {
  218.   XDrawLine(display,drawable,gc,mouse_start_xpix,mouse_start_ypix,XPIX(x),YPIX(y));
  219.  
  220. }
  221.  
  222. void x_draw_mouse_rect_action(x,y)
  223. double x,y;
  224. { 
  225.     x_draw_rectangle(mouse_start_xreal,mouse_start_yreal,x,y,1,1);
  226.  } 
  227.  
  228. void x_draw_mouse_circle_action(x,y)
  229. double x,y;
  230. {   double r = hypot(x - mouse_start_xreal, y - mouse_start_yreal);
  231.     x_draw_circle(mouse_start_xreal, mouse_start_yreal, r, 1, 1);    
  232. }
  233.  
  234.  
  235. x_draw_init_fonts()
  236. { /* initialize fonts: text_font, bold_font, message_font */
  237.  
  238.   XGCValues gc_val;
  239.  
  240.  text_font = (Xv_Font)xv_find(frame, FONT,
  241.                          FONT_FAMILY, FONT_FAMILY_DEFAULT_FIXEDWIDTH,
  242.                          FONT_STYLE,  FONT_STYLE_NORMAL,
  243.                          FONT_SIZE,   14,
  244.                          0);
  245.  
  246.  bold_font = (Xv_Font)xv_find(frame, FONT,
  247.                          FONT_FAMILY, FONT_FAMILY_DEFAULT_FIXEDWIDTH,
  248.                          FONT_STYLE,  FONT_STYLE_BOLD,
  249.                          FONT_SIZE,   14,
  250.                          0);
  251.  
  252.  message_font = (Xv_Font)xv_find(frame, FONT,
  253.                          FONT_FAMILY, FONT_FAMILY_LUCIDA_FIXEDWIDTH,
  254.                          FONT_STYLE,  FONT_STYLE_NORMAL,
  255.                          FONT_SIZE,   24,
  256.                          0);
  257.  
  258.     if (!text_font)    
  259.      { fprintf(stderr,"Cannot open text font\n");
  260.        text_font = (Xv_Font)xv_get(frame,XV_FONT);
  261.       }
  262.  
  263.     if (!bold_font)    
  264.      { fprintf(stderr,"Cannot open bold font\n");
  265.        bold_font = (Xv_Font)xv_get(frame,XV_FONT);
  266.       }
  267.  
  268.     if (!message_font) 
  269.      { fprintf(stderr,"Cannot open message font\n");
  270.        message_font = (Xv_Font)xv_get(frame,XV_FONT);
  271.       }
  272.  
  273.  
  274.       gc_val.font = (Font)xv_get(text_font,XV_XID);
  275.       XChangeGC(display,gc,GCFont,&gc_val);
  276. }
  277.  
  278. x_draw_set_font(fname)
  279. char* fname;
  280. {
  281.   XGCValues gc_val;
  282.   Xv_Font f;
  283.  
  284.   xv_set(frame,FRAME_BUSY,TRUE,NULL);
  285.   f = (Xv_Font)xv_find(frame,FONT,FONT_NAME,fname,NULL);
  286.   xv_set(frame,FRAME_BUSY,FALSE,NULL);
  287.  
  288.   if (f) 
  289.   { text_font = f;
  290.     gc_val.font = (Font)xv_get(text_font,XV_XID);
  291.     XChangeGC(display,gc,GCFont,&gc_val);
  292.    }
  293.  
  294. }
  295.  
  296.  
  297. int x_draw_set_color(col)
  298. int col;
  299. { int save = x_draw_color;
  300.   x_draw_color = (x_draw_depth==1 && col > 1) ? 1 : col;
  301.   XSetForeground(display,gc,pixel_table[x_draw_color]);
  302.   return save;
  303.  }
  304.  
  305.  
  306. int x_draw_set_line_width(w)
  307. int w;
  308. { XGCValues gc_val;
  309.   int save = x_draw_line_width;
  310.   x_draw_line_width = w;
  311.   gc_val.line_width = x_draw_line_width;
  312.   XChangeGC(display,gc,GCLineWidth,&gc_val);
  313.   return save;
  314. }
  315.  
  316.  
  317. int x_draw_set_line_style(s)
  318. int s;
  319. { XGCValues gc_val;
  320.  
  321.   int save = x_draw_line_style;
  322.  
  323.   x_draw_line_style = s;
  324.  
  325.    switch (x_draw_line_style)  {
  326.  
  327.    case 0 : Line_style = LineSolid;
  328.             break;
  329.  
  330.    case 1 : Line_style = LineOnOffDash;
  331.             XSetDashes(display,gc,0,dashed,2);
  332.             break;
  333.  
  334.    case 2 : Line_style = LineOnOffDash;
  335.             XSetDashes(display,gc,0,dotted,2);
  336.             break;
  337.  
  338.    default: Line_style = LineSolid;
  339.             break;
  340.  
  341.    }
  342.  
  343.   gc_val.line_style = Line_style;
  344.   XChangeGC(display,gc,GCLineStyle,&gc_val);
  345.   return save;
  346. }
  347.  
  348. int x_draw_set_node_width(w)
  349. int w;
  350. { int save = x_draw_node_width;
  351.   x_draw_node_width = w;
  352.   return save;
  353.  }
  354.  
  355. int x_draw_set_text_mode(m)
  356. int m;
  357. { int save = x_draw_text_mode;
  358.   x_draw_text_mode = m;
  359.   return save;
  360.  }
  361.  
  362. int x_draw_set_mode(m)
  363. int m;
  364. { 
  365.   XGCValues gc_val;
  366.  
  367.   int save = x_draw_drawing_mode;
  368.  
  369.   x_draw_drawing_mode = m;
  370.  
  371.  
  372.   DPRINT(("x_draw_set_mode %d\n",x_draw_drawing_mode));
  373.  
  374.    switch (x_draw_drawing_mode)  {
  375.  
  376.    case 0 : xpix_mode_op = GXcopy;
  377.             break;
  378.  
  379.    case 1 : xpix_mode_op = GXxor;
  380.             break;
  381.  
  382.    case 2 : xpix_mode_op = GXor;
  383.             break;
  384.  
  385.    default: break;
  386.  
  387.    }
  388.  
  389.   gc_val.function = xpix_mode_op; 
  390.   XChangeGC(display,gc,GCFunction,&gc_val);
  391.  
  392.   return save;
  393. }
  394.  
  395.  
  396. static void x_draw_event_proc(canvas,event)
  397. Canvas canvas;
  398. Event* event;
  399. { 
  400.   char s[32];
  401.  
  402.  
  403.   int k = event_id(event); 
  404.  
  405.  
  406.   switch (k) {
  407.  
  408.   case ACTION_SELECT:
  409.   case MS_LEFT:   if (event_is_up(event)) break;
  410.                   mouse_key = 1;
  411.  
  412.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  413.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  414.                   break;
  415.  
  416.   case ACTION_ADJUST:
  417.   case MS_MIDDLE: if (event_is_up(event)) break;
  418.                   mouse_key = 2;
  419.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  420.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  421.                   break;
  422.  
  423.   case ACTION_MENU:
  424.   case MS_RIGHT:  if (event_is_up(event)) break;
  425.                   mouse_key = 3;
  426.                   if (event_ctrl_is_down(event))  mouse_key +=3;
  427.                   if (event_shift_is_down(event)) mouse_key = -mouse_key;
  428.                   break;
  429.  
  430.  
  431.   case LOC_MOVE: 
  432.   case LOC_WINENTER : 
  433.   case LOC_WINEXIT : 
  434.            mouse_xpix = event_x(event);
  435.            mouse_ypix = event_y(event);
  436.  
  437.            if (x_draw_grid_mode)  x_draw_cursor();
  438.          
  439.            mouse_xreal =  x_draw_xmin+((double)mouse_xpix)/x_draw_scale;
  440.            mouse_yreal =  x_draw_ymax-((double)mouse_ypix)/x_draw_scale;
  441.          
  442.          if (x_draw_grid_mode) 
  443.          { 
  444.            mouse_xreal = x_draw_grid_mode * (int)(mouse_xreal/x_draw_grid_mode + ((mouse_xreal > 0) ? 0.5 : -0.5));
  445.  
  446.            mouse_yreal = x_draw_grid_mode * (int)(mouse_yreal/x_draw_grid_mode + ((mouse_yreal > 0) ? 0.5 : -0.5));
  447.  
  448.            mouse_xpix  = XPIX(mouse_xreal);
  449.            mouse_ypix  = YPIX(mouse_yreal);
  450.          
  451.            x_draw_cursor();
  452.          }
  453.        
  454.        /* sprintf(s,read_frame_format, mouse_xreal,mouse_yreal,frame_label);
  455.           window_set(frame,FRAME_LABEL,s,0);
  456.        */
  457.  
  458.          sprintf(s,"%8.2f %8.2f", mouse_xreal,mouse_yreal);
  459.  
  460.          XDrawImageString(display,drawable,gc,xdots-160,13,s,strlen(s));
  461.        
  462.        
  463.          if (x_draw_mouse_action) /* user defined action */
  464.          { x_draw_mouse_action(mouse_last_xreal,mouse_last_yreal);
  465.            x_draw_mouse_action(mouse_xreal,mouse_yreal);
  466.           }
  467.        
  468.          mouse_last_xpix = mouse_xpix;
  469.          mouse_last_ypix = mouse_ypix;
  470.        
  471.          mouse_last_xreal = mouse_xreal;
  472.          mouse_last_yreal = mouse_yreal;
  473.        
  474.          break;
  475.  
  476.      } /* switch */
  477.  
  478. /*
  479. printf("event_if = %d  key = %d  xreal = %f yreal = %f\n",k,mouse_key, mouse_xreal,mouse_yreal);
  480. fflush(stdout);
  481. */
  482.  
  483.  
  484. }
  485.  
  486. int x_read_mouse(kind, xstart,ystart,x,y)
  487. int    kind;   /* 0: point, 1: segment, 2:rectangle, 3: circle */
  488. double xstart;
  489. double ystart;
  490. double *x;
  491. double *y;
  492. { 
  493.   PMA f;
  494.   int key;
  495.   
  496.   switch(kind) {
  497.  
  498.   case 0 : f = x_draw_mouse_default_action;
  499.           break;
  500.  
  501.   case 1:  f = x_draw_mouse_segment_action;
  502.            break;
  503.  
  504.   case 2:  f = x_draw_mouse_rect_action;
  505.            break;
  506.  
  507.   case 3:  f = x_draw_mouse_circle_action;
  508.            break;
  509.  
  510.   default: f = x_draw_mouse_default_action;
  511.            break;
  512.  
  513.   }
  514.  
  515.   key = x_read_mouse_action(f,xstart,ystart,x,y);
  516.  
  517.   return key;
  518.  
  519. }
  520.  
  521. int x_read_mouse_action(action, xstart,ystart,x,y)
  522. PMA   action;
  523. double xstart;
  524. double ystart;
  525. double *x;
  526. double *y;
  527. { 
  528.   DPRINT(("x_read_mouse_action\n"));
  529.   x_draw_mouse_action = action;
  530.  
  531.   x_draw_set_gc_read_mouse();
  532.  
  533.  
  534.   mouse_key = 0;
  535.  
  536.   mouse_start_xreal = xstart;
  537.   mouse_start_yreal = ystart;
  538.  
  539.   mouse_start_xpix = XPIX(xstart);
  540.   mouse_start_ypix = YPIX(ystart);
  541.  
  542.   if (x_draw_grid_mode) x_draw_cursor();
  543.  
  544.   if (x_draw_mouse_action)  /* user defined action */
  545.   { x_draw_mouse_action(mouse_last_xreal,mouse_last_yreal);
  546.    }
  547.  
  548.  
  549.   /* notify-loop */
  550.  
  551.   while (!mouse_key && !x_draw_done)  notify_dispatch();
  552.  
  553.   
  554.  
  555.   if (x_draw_mouse_action)  /* user defined action */
  556.   { x_draw_mouse_action(mouse_xreal,mouse_yreal);
  557.    }
  558.  
  559.   if (x_draw_grid_mode) x_draw_cursor();
  560.  
  561.   *x = mouse_xreal;
  562.   *y = mouse_yreal;
  563.  
  564.   x_draw_reset_gc();
  565.  
  566.   if (x_draw_done) return 0;
  567.  
  568.   return mouse_key;
  569. }
  570.   
  571.  
  572. static void x_draw_canvas_repaint_proc(canvas,paint_window,dpy,xwin,xrects)
  573. Canvas canvas;
  574. Xv_Window paint_window;
  575. Display *dpy;
  576. Window  xwin;
  577. Xv_xrectlist *xrects;
  578. {
  579.   repaint_count++;
  580.  
  581.   if (repaint_count > 2)
  582.   fprintf(stderr,"LEDA warning: repaint count = %d\n", repaint_count);
  583.   fflush(stderr);
  584. /*
  585.   if (draw_init_done)
  586.       x_draw_init(x_draw_xmin,x_draw_xmax,x_draw_ymin,x_draw_grid_mode); 
  587. */
  588. }
  589.  
  590. static void x_draw_canvas_resize_proc(canvas,width,height)
  591. Canvas canvas;
  592. int    width;
  593. int    height;
  594. {
  595. /*
  596.  printf("RESIZE canvas = %d  widht = %d  height =%d\n",canvas,width,height);
  597.  fflush(stdout);
  598. */
  599.   if (draw_init_done)
  600.       x_draw_init(x_draw_xmin,x_draw_xmax,x_draw_ymin,x_draw_grid_mode); 
  601. }
  602.  
  603.  
  604.  
  605.  
  606. Notify_value x_draw_notice_destroy(frame, status)
  607. Frame frame;
  608. Destroy_status status;
  609. {
  610.   DPRINT(("x_draw_notice_destroy called\n"));
  611.  
  612.   /*if (status != DESTROY_CHECKING) */
  613.     x_draw_done = 1;
  614.  
  615.   return (notify_next_destroy_func(frame,status));
  616. }
  617.  
  618.  
  619. /*
  620. static error_proc(object,avlist)
  621. Xv_object    object;
  622. Attr_avlist  avlist;
  623. { char  buf[32];
  624.   printf("%s\n", xv_error_format(object,avlist));
  625.   printf("Dump core ? ");
  626.   fflush(stdout);
  627.   if (gets(buf) && (buf[0] == 'y')) abort();
  628.   return XV_OK;
  629.  }
  630. */
  631.   
  632.  
  633.  
  634. x_draw_init_window(w_width,w_height,w_xpos,w_ypos,frame_label)
  635. int w_width,
  636.     w_height,
  637.     w_xpos,
  638.     w_ypos;
  639. char* frame_label;
  640. { 
  641.   int       i, *xpixels;
  642.   Xv_Screen xv_screen;
  643.   XGCValues gc_val;
  644.   Rect      *r;
  645.  
  646.  
  647.   DPRINT(("x_draw_init_window\n"));
  648.   if (pw!=0) 
  649.   { fprintf(stderr,"warning: second initialization of window ignored.\n");
  650.     return;
  651.    } 
  652.  
  653.   strcpy(default_frame_label,frame_label);
  654.  
  655. /*
  656.   xv_init(XV_ERROR_PROC, error_proc,0);
  657. */
  658.  
  659.  
  660.   /* initalize the colormap segment data and set the required RGB values */
  661.  
  662.   (red)[0] =  255; (green)[0] = 255; (blue)[0] =  255 ;  /* white  */
  663.   (red)[1] =    0; (green)[1] =   0; (blue)[1] =    0 ;  /* black  */
  664.   (red)[2] =  255; (green)[2] =   0; (blue)[2] =    0 ;  /* red    */
  665.   (red)[3] =    0; (green)[3] = 255; (blue)[3] =    0 ;  /* green  */
  666.   (red)[4] =    0; (green)[4] = 100; (blue)[4] =  255 ;  /* blue   */
  667.   (red)[5] =  128; (green)[5] = 128; (blue)[5] =    0 ;  /* yellow */
  668.   (red)[6] =  128; (green)[6] =   0; (blue)[6] =  178 ;  /* violet */
  669.   (red)[7] =  192; (green)[7] =  64; (blue)[7] =    0 ;  /* orange */
  670.  
  671.     cms_data.type = XV_STATIC_CMS;
  672.     cms_data.size = 8;
  673.     cms_data.rgb_count = 8;
  674.     cms_data.index = 0;
  675.     cms_data.red = red;
  676.     cms_data.green = green;
  677.     cms_data.blue = blue;
  678.  
  679.   icon = icon_create(ICON_IMAGE, &leda_icon_pixrect, 0);
  680.  
  681.  
  682.   repaint_count = 0;
  683.  
  684.  
  685.   frame = window_create(0, FRAME, 
  686.               WIN_X,        w_xpos,
  687.               WIN_Y,        w_ypos,
  688.               WIN_WIDTH,    w_width-10,
  689.               WIN_HEIGHT,   w_height-30,
  690.               WIN_IGNORE_EVENT,      WIN_REPAINT,
  691.               FRAME_NO_CONFIRM, TRUE,
  692.               FRAME_LABEL, default_frame_label, 
  693.               0);
  694.  
  695. /*
  696.   icon = (Icon)xv_create(frame,ICON,
  697.                          ICON_IMAGE,icon_image,
  698.                          XV_X, 100,
  699.                          XV_Y, 100,
  700.                          0);
  701.  
  702. */
  703.  
  704.   window_set(frame, FRAME_ICON, icon,0);
  705.  
  706.   window_set(frame, WIN_SHOW, TRUE, 0);
  707.  
  708.   canvas = window_create(frame, CANVAS,
  709.               WIN_EVENT_PROC,        x_draw_event_proc,
  710.               CANVAS_REPAINT_PROC,   x_draw_canvas_repaint_proc,
  711.               CANVAS_RESIZE_PROC,    x_draw_canvas_resize_proc,
  712.               CANVAS_X_PAINT_WINDOW, TRUE,
  713.               WIN_CMS_NAME,          "palette",
  714.               WIN_CMS_DATA,          &cms_data,
  715.               WIN_IGNORE_EVENT,      WIN_REPAINT,
  716.               0); 
  717.  
  718.  
  719.  
  720. /*
  721.   xv_create(canvas,SCROLLBAR,
  722.             SCROLLBAR_DIRECTION, SCROLLBAR_HORIZONTAL, 0);
  723.  
  724.   xv_create(canvas,SCROLLBAR,
  725.             SCROLLBAR_DIRECTION, SCROLLBAR_VERTICAL, 0);
  726. */
  727.  
  728.  
  729.  
  730.  
  731.  
  732.   /* Get the actual indices into the colormap and store them in pixel_table */
  733.  
  734.   xpixels = (int *)xv_get(canvas, WIN_X_COLOR_INDICES);
  735.  
  736.   for (i = 0; i < 8; i++) pixel_table[i] = xpixels[i];
  737.     
  738.   pw = canvas_pixwin(canvas);
  739.  
  740.   xv_set(canvas_paint_window(canvas),
  741.     WIN_EVENT_PROC,          x_draw_event_proc,
  742.     WIN_CONSUME_EVENTS,      WIN_RIGHT_KEYS, LOC_MOVE,
  743.                              LOC_WINENTER, LOC_WINEXIT,
  744.                              WIN_MOUSE_BUTTONS,
  745.                              0,
  746.     WIN_IGNORE_EVENTS,       WIN_REPAINT,WIN_UP_EVENTS,0,
  747.     0); 
  748.  
  749.   notify_interpose_destroy_func(frame,x_draw_notice_destroy);
  750.  
  751.  
  752.  
  753.   display   = (Display *)xv_get(frame,XV_DISPLAY);
  754.   drawable  = (Drawable)xv_get(pw,XV_XID);
  755.   xv_screen = (Xv_Screen)xv_get(frame,XV_SCREEN);
  756.   screen    = (int)xv_get(xv_screen,SCREEN_NUMBER);
  757.  
  758.   gc    = DefaultGC(display,screen);
  759.   x_draw_depth = DefaultDepth(display,screen);
  760.  
  761.   screen_width = DisplayWidth(display,screen);
  762.   screen_height = DisplayHeight(display,screen);
  763.  
  764.   XSetLineAttributes(display,gc,1,LineSolid,CapButt,JoinMiter);
  765.  
  766.   x_draw_init_fonts();
  767.  
  768.   x_draw_set_line_style(0);
  769.   x_draw_set_line_width(1);
  770.   x_draw_set_mode(0);
  771.   x_draw_set_node_width(12);
  772.   x_draw_set_text_mode(0); 
  773.  
  774.   x_draw_color = 1;
  775.   gc_val.foreground = BlackPixel(display,screen); 
  776.   XChangeGC(display,gc,GCForeground,&gc_val);
  777.  
  778.   for(i=0;i<8;i++)
  779.   { buffer_width[i] = 0;
  780.     buffer_height[i] = 0;
  781.    }
  782.  
  783.   x_draw_xmin = 0;
  784.   x_draw_ymin = 0;
  785.   x_draw_xmax = 0;
  786.   x_draw_ymax = 0;
  787.   x_draw_scale = 1;
  788.   mouse_xpix = 0;
  789.   mouse_ypix = 0;
  790.  
  791.  
  792.  
  793.  
  794.   i = 0;
  795.   while (repaint_count < 2 && i < 100000)  /* wait for 2 REPAINT events */
  796.   { notify_dispatch();
  797.     i++;
  798.    }
  799.  
  800.   repaint_count = 2;
  801.  
  802. /*
  803.   printf("i = %d  count = %d\n",i,repaint_count);
  804.   fflush(stdout);
  805. */
  806.  
  807.   x_draw_reset_frame_label();
  808.  
  809.   XFlush(display);
  810.  
  811. }
  812.  
  813. x_draw_init(x0,x1,y0,g_mode)
  814. double x0,x1,y0;
  815. int g_mode;
  816. {
  817.   double x,y;
  818.  
  819.   DPRINT(("x_draw_init\n"));
  820.  
  821.   draw_init_done = TRUE;
  822.  
  823.   if (x0>=x1) 
  824.   {fprintf(stderr,"Illegal arguments in draw_init: x0 (%f) >= x1 (%f)\n",x0,x1);
  825.    abort();
  826.    }
  827.  
  828.   x_draw_grid_mode = g_mode; 
  829.  
  830.   x_draw_reset_frame_label();
  831.  
  832.   xdots = (int)window_get(canvas, CANVAS_WIDTH);
  833.   ydots = (int)window_get(canvas, CANVAS_HEIGHT);
  834.  
  835.  
  836.   x_draw_scale = ((double)xdots)/(x1-x0);
  837.  
  838.   /* at least grid distance of 2 pixels */
  839.   if ((x_draw_grid_mode) && (x_draw_grid_mode*x_draw_scale < 2)) 
  840.   { x_draw_grid_mode=0;  
  841.     fprintf(stderr,"warning: grid distance to small.\n");
  842.    }
  843.  
  844.   if (x_draw_grid_mode) 
  845.   { if (x_draw_scale < 1) x_draw_scale = 1;
  846.     else x_draw_scale = (int)x_draw_scale;
  847.     DPRINT(("grid mode %d ; draw scale %d\n",x_draw_grid_mode,x_draw_scale));
  848.   }
  849.  
  850.   x_draw_xmin = x0;
  851.   x_draw_ymin = y0;
  852.   x_draw_xmax = x0+xdots/x_draw_scale;
  853.   x_draw_ymax = y0+ydots/x_draw_scale;
  854.  
  855.   xorigin = -x0*x_draw_scale;
  856.   yorigin = ydots+y0*x_draw_scale;
  857.  
  858.   mouse_xreal = 0;
  859.   mouse_yreal = 0;
  860.  
  861.   x_draw_clear(0);   
  862.  
  863.   if (x_draw_grid_mode)  x_draw_cursor();
  864.  
  865.   notify_dispatch();
  866.  
  867.   if (x_draw_grid_mode)  x_draw_cursor();
  868.  
  869.   if (x_draw_redraw) (*x_draw_redraw)();
  870.  
  871.   XFlush(display);
  872.  
  873. }
  874.  
  875.  
  876. x_show_window() 
  877. { while (!x_draw_done) notify_dispatch();
  878.  }
  879.  
  880. x_draw_end()
  881. { if (pw)
  882.   { pw_close(pw);
  883.     /* window_destroy(frame); */
  884.     pw = 0;
  885.    }
  886. }
  887.  
  888. x_draw_line(x1, y1, x2, y2, col)
  889. double x1,y1,x2,y2;
  890. int col;
  891. { 
  892.   int C[4];
  893.   int i;
  894.  
  895.   int M = 32768;   /* 2^15    */ 
  896.  
  897.   double slope;
  898.  
  899.   DPRINT(("x_draw_line %d\n",xpix_mode_op));
  900.  
  901.   C[0] = XPIX(x1);
  902.   C[1] = YPIX(y1);
  903.   C[2] = XPIX(x2);
  904.   C[3] = YPIX(y2);
  905.  
  906.   DPRINT(("x_draw_line %d  %d  %d  %d\n\n",C[0],C[1],C[2],C[3]));
  907.  
  908.   /* 
  909.     Fehler beim Clipping fuer Koordinaten mit Absolutwert in
  910.     [i*2^15..(i+1)*2^15-1],i ungerade.
  911.   */
  912.  
  913.   for(i=0; i<4; i++)
  914.     if ((C[i]/M) % 2) C[i] = -C[i];
  915.  
  916.  
  917.  
  918.  
  919.   if (col != x_draw_color) x_draw_set_color(col);
  920.  
  921.   XDrawLine(display,drawable,gc,C[0],C[1],C[2],C[3]);
  922.  
  923.   if (x_draw_screen_flush)
  924.     XFlush(display);
  925. }
  926.  
  927.  
  928. x_draw_point(x,y,col)
  929. double x,y;
  930. int col;
  931. { 
  932.   int X = XPIX(x);
  933.   int Y = YPIX(y);
  934.  
  935.   xv_vector(pw,X-2,Y-2,X+2,Y+2,PIX_SRC^PIX_DST,1);
  936.   xv_vector(pw,X+1,Y-1,X+2,Y-2,PIX_SRC^PIX_DST,1);
  937.   xv_vector(pw,X-1,Y+1,X-2,Y+2,PIX_SRC^PIX_DST,1);
  938.  
  939.   if (x_draw_screen_flush) XFlush(display);
  940. }
  941.  
  942. x_draw_arc(x0,y0,a,b,col)
  943. double x0,y0;
  944. int a,b,col;
  945. { 
  946.  
  947.   if (col != x_draw_color) x_draw_set_color(col);
  948.  
  949.   XDrawArc(display,drawable,gc,XPIX(x0)-a,YPIX(y0)-b,2*a,2*b,0,360*64);
  950.  
  951.   if (x_draw_screen_flush)
  952.     XFlush(display);
  953.  
  954. }
  955.  
  956. x_draw_filled_arc(x0,y0,a,b,col)
  957. double x0,y0;
  958. int a,b,col;
  959. { 
  960.   if (col != x_draw_color) x_draw_set_color(col);
  961.  
  962.   XFillArc(display,drawable,gc,XPIX(x0)-a,YPIX(y0)-b,2*a,2*b,0,360*64);
  963.  
  964.   if (x_draw_screen_flush)
  965.     XFlush(display);
  966.  
  967. }
  968.  
  969. x_draw_node(x0,y0,col)
  970. double x0,y0;
  971. int col;
  972. { int save = x_draw_set_line_width(1); 
  973.   x_draw_arc(x0,y0,x_draw_node_width,x_draw_node_width,col); 
  974.   x_draw_set_line_width(save); 
  975.  }
  976.  
  977. x_draw_filled_node(x0,y0,col)
  978. double x0,y0;
  979. int col;
  980. { x_draw_filled_arc(x0,y0,x_draw_node_width,x_draw_node_width,col); }
  981.  
  982.  
  983. x_draw_text_node(x0,y0,s,col)
  984. double x0,y0;
  985. int col;
  986. char* s;
  987. { XGCValues gc_val;
  988.   int save;
  989.  
  990.   gc_val.font = (Font)xv_get(bold_font,XV_XID);
  991.   XChangeGC(display,gc,GCFont,&gc_val);
  992.   save = x_draw_text_mode;
  993.   x_draw_text_mode = 0;  /* transparent */
  994.  
  995.   if (x_draw_depth==1 || col == 1)
  996.      x_draw_node(x0,y0,1);
  997.   else
  998.      x_draw_filled_node(x0,y0,col);
  999.  
  1000.   x_draw_ctext(x0,y0,s,1);
  1001.   x_draw_text_mode = save;
  1002.  
  1003.   gc_val.font = (Font)xv_get(text_font,XV_XID);
  1004.   XChangeGC(display,gc,GCFont,&gc_val);
  1005.  }
  1006.  
  1007. x_draw_int_node(x0,y0,i,col)
  1008. double x0,y0;
  1009. int i,col;
  1010. { char buf[16];
  1011.   sprintf(buf,"%d",i);
  1012.   x_draw_text_node(x0,y0,buf,col);
  1013.  }
  1014.  
  1015. x_draw_ellipse(x0,y0,a,b,col)
  1016. double x0,y0,a,b; 
  1017. int col;
  1018. { int A = (int)(a*x_draw_scale);
  1019.   int B = (int)(b*x_draw_scale);
  1020.   x_draw_arc(x0,y0,A,B,col); }
  1021.  
  1022. x_draw_filled_ellipse(x0,y0,a,b,col)
  1023. double x0,y0,a,b; 
  1024. int col;
  1025. { int A = (int)(a*x_draw_scale);
  1026.   int B = (int)(b*x_draw_scale);
  1027.   x_draw_filled_arc(x0,y0,A,B,col); }
  1028.  
  1029.  
  1030. x_draw_circle(x0,y0,r,col)
  1031. double x0,y0,r; 
  1032. int col;
  1033. { int R = (int)(r*x_draw_scale);
  1034.   x_draw_arc(x0,y0,R,R,col); }
  1035.  
  1036.  
  1037. x_draw_filled_circle(x0,y0,r,col)
  1038. double x0,y0,r; 
  1039. int col;
  1040. { int R = (int)(r*x_draw_scale);
  1041.   x_draw_filled_arc(x0,y0,R,R,col); }
  1042.  
  1043.  
  1044. x_draw_xpix(x)
  1045. double x;
  1046. { return XPIX(x); }
  1047.  
  1048. x_draw_ypix(x)
  1049. double x;
  1050. { return YPIX(x); }
  1051.  
  1052. x_draw_pix(x,y,col)
  1053. double x,y;
  1054. int col;
  1055. { 
  1056.   if (col != x_draw_color) x_draw_set_color(col);
  1057.  
  1058.  
  1059.   XDrawPoint(display,drawable,gc,XPIX(x),YPIX(y));
  1060.  
  1061.   if (x_draw_screen_flush)
  1062.     XFlush(display);
  1063. }
  1064.  
  1065.  
  1066. x_draw_plot_xy(x0,x1,f,col)
  1067. double x0,x1;
  1068. double (*f)();
  1069. int col;
  1070. { 
  1071.   XPoint *points;
  1072.  
  1073.   int x = XPIX(x0);
  1074.   int y_old = YPIX((*f)(x0));
  1075.   int i,y_new;
  1076.   int size = 0;
  1077.   int n = 0;
  1078.  
  1079.   if (col != x_draw_color) x_draw_set_color(col);
  1080.  
  1081.   for(x = XPIX(x0)+1; x <= XPIX(x1); x++)
  1082.   { y_new = YPIX((*f)(XREAL(x)));
  1083.     if (y_new > y_old)
  1084.        size += (y_new-y_old+1);
  1085.     else
  1086.        size += (y_old-y_new+1);
  1087.     y_old = y_new;
  1088.    }
  1089.  
  1090.   points = (XPoint *) malloc(2*size*sizeof(short));
  1091.  
  1092.   y_old = YPIX((*f)(x0));
  1093.  
  1094.   for(x = XPIX(x0)+1; x <= XPIX(x1); x++)
  1095.   { y_new = YPIX((*f)(XREAL(x)));
  1096.     if (y_new > y_old)
  1097.       for(i=y_old; i<=y_new; i++)  
  1098.       { points[n].x = (short) x; 
  1099.         points[n].y = (short) i;
  1100.         n++;
  1101.        }
  1102.     else
  1103.       for(i=y_old; i>=y_new; i--)  
  1104.       { points[n].x = (short) x; 
  1105.         points[n].y = (short) i;
  1106.         n++;
  1107.        }
  1108.     y_old = y_new;
  1109.   }
  1110.  
  1111.  XDrawPoints(display,drawable,gc,points,size,CoordModeOrigin);
  1112.   
  1113.  free((char*)points);
  1114.  
  1115.  
  1116.   if (x_draw_screen_flush)
  1117.     XFlush(display);
  1118. }
  1119.  
  1120. x_draw_plot_yx(y0,y1,f,col)
  1121. double y0,y1;
  1122. double (*f)();
  1123. int col;
  1124. { 
  1125.   XPoint *points;
  1126.  
  1127.   int y;
  1128.   int i,x_new;
  1129.   int x_old = XPIX((*f)(y0));
  1130.   int size = 0;
  1131.   int n = 0;
  1132.  
  1133.   if (col != x_draw_color) x_draw_set_color(col);
  1134.  
  1135.   for(y = YPIX(y0)-1; y >= YPIX(y1); y++)
  1136.   { x_new = XPIX((*f)(YREAL(y)));
  1137.     if (x_new > x_old)
  1138.        size += (x_new-x_old+1);
  1139.     else
  1140.        size += (x_old-x_new+1);
  1141.     x_old = x_new;
  1142.    }
  1143.  
  1144.   points = (XPoint *) malloc(2*size*sizeof(short));
  1145.  
  1146.   x_old = XPIX((*f)(y0));
  1147.  
  1148.   for(y = YPIX(y0)-1; y >= YPIX(y1); y--)
  1149.   {
  1150.     x_new = XPIX((*f)(YREAL(y)));
  1151.     if (x_new > x_old)
  1152.       for(i=x_old; i<=x_new; i++)  
  1153.       { points[n].x = (short) i; 
  1154.         points[n].y = (short) y;
  1155.         n++;
  1156.        }
  1157.     else
  1158.       for(i=x_old; i>=x_new; i--)  
  1159.       { points[n].x = (short) i; 
  1160.         points[n].y = (short) y;
  1161.         n++;
  1162.        }
  1163.     x_old = x_new;
  1164.   }
  1165.  
  1166.  XDrawPoints(display,drawable,gc,points,size,CoordModeOrigin);
  1167.   
  1168.  free((char*)points);
  1169.  
  1170.  
  1171.   if (x_draw_screen_flush)
  1172.     XFlush(display);
  1173. }
  1174.  
  1175.  
  1176. x_draw_filled_polygon(n,xcoord,ycoord,col)
  1177. int col, n;
  1178. double *xcoord, *ycoord;
  1179. {
  1180.  XPoint *edges;
  1181.  int i;
  1182.  
  1183.  edges = (XPoint *) malloc(2*n*sizeof(short));
  1184.  
  1185.  for(i=0;i<n;i++) 
  1186.  { edges[i].x = (short) XPIX(xcoord[i]);
  1187.    edges[i].y = (short) YPIX(ycoord[i]);
  1188.   }
  1189.  
  1190.   if (col != x_draw_color) x_draw_set_color(col);
  1191.  
  1192.  XFillPolygon(display,drawable,gc,edges,n,Convex,CoordModeOrigin);
  1193.  
  1194.  free((char*)edges);
  1195.  
  1196.   if (x_draw_screen_flush)
  1197.     XFlush(display);
  1198.  
  1199.  }
  1200.  
  1201. x_draw_polygon(n,xcoord,ycoord,col)
  1202. int col, n;
  1203. double *xcoord, *ycoord;
  1204. { int i;
  1205.  
  1206.   for(i=0;i<n-1;i++) 
  1207.     x_draw_line(xcoord[i],ycoord[i], xcoord[i+1],ycoord[i+1],col);
  1208.  
  1209.   x_draw_line(xcoord[n-1],ycoord[n-1],xcoord[0],ycoord[0],col);
  1210.  
  1211.  }
  1212.  
  1213. x_draw_rectangle(x1,y1,x2,y2,col)
  1214. double x1,y1,x2,y2;
  1215. int col;
  1216. {
  1217.  x_draw_line(x1,y1,x1,y2,col);
  1218.  x_draw_line(x1,y2,x2,y2,col);
  1219.  x_draw_line(x2,y2,x2,y1,col);
  1220.  x_draw_line(x2,y1,x1,y1,col);
  1221.  
  1222.  }
  1223.  
  1224.  
  1225. x_draw_filled_rectangle(x1,y1,x2,y2,col)
  1226. double x1,y1,x2,y2; 
  1227. int col;
  1228. { double xcoord[4], ycoord[4];
  1229.  
  1230.  xcoord[0] = x1;   
  1231.  ycoord[0] = y1;   
  1232.  xcoord[1] = x1;  
  1233.  ycoord[1] = y2;   
  1234.  xcoord[2] = x2; 
  1235.  ycoord[2] = y2;   
  1236.  xcoord[3] = x2;
  1237.  ycoord[3] = y1;
  1238.  
  1239.  x_draw_filled_polygon(4,xcoord,ycoord,col);
  1240.  
  1241.  }
  1242.  
  1243.  
  1244. x_draw_copy(x1,y1,x2,y2,buf)
  1245. double x1,y1,x2,y2;
  1246. int buf;
  1247. {
  1248.   int w = (int)((x2-x1)*x_draw_scale);
  1249.   int h = (int)((y2-y1)*x_draw_scale);
  1250.  
  1251.   if (w<=0 || h <=0) return;
  1252.  
  1253.   buffer_pixmap[buf] = XCreatePixmap(display,drawable,w,h,x_draw_depth);
  1254.   buffer_width[buf] = w;
  1255.   buffer_height[buf] = h;
  1256.  
  1257.   XCopyArea(display,drawable,buffer_pixmap[buf],gc, XPIX(x1),YPIX(y2),w,h,0,0);
  1258.  
  1259.  }
  1260.  
  1261.  
  1262. x_draw_cut(x1,y1,x2,y2,buf)
  1263. double x1,y1,x2,y2;
  1264. int buf;
  1265. { x_draw_copy(x1,y1,x2,y2,buf);
  1266.   x_draw_filled_rectangle(x1,y1,x2,y2,0);
  1267.  }
  1268.  
  1269. x_draw_paste(buf,x,y)
  1270. double x,y;
  1271. int buf;
  1272. { int w = buffer_width[buf];
  1273.   int h = buffer_height[buf];
  1274.   if(w>0 && h>0)
  1275.   XCopyArea(display,buffer_pixmap[buf],drawable,gc,0,0,w,h,XPIX(x),YPIX(y)-h);
  1276.  }
  1277.  
  1278.  
  1279. x_draw_clear_buf(i)
  1280. int i;
  1281. { buffer_height[i] = buffer_width[i] = 0; }
  1282.  
  1283.  
  1284. /*
  1285. x_draw_copy_rect(x1,y1,x2,y2,x,y)
  1286. { x_draw_copy(x1,y1,x2,y2,0);
  1287.   x_draw_paste(0,x,y);
  1288.  }
  1289. */
  1290.  
  1291. x_draw_copy_rect(x1,y1,x2,y2,x,y)
  1292. double x1,y1,x2,y2,x,y;
  1293. {
  1294.   Pixmap P;
  1295.  
  1296.   int w = (int)((x2-x1)*x_draw_scale);
  1297.   int h = (int)((y2-y1)*x_draw_scale);
  1298.  
  1299.   int X1 = XPIX(x1);
  1300.   int Y1 = YPIX(y2);
  1301.  
  1302.   int X = XPIX(x);
  1303.   int Y = YPIX(y)-h;
  1304.  
  1305.   int save;
  1306.  
  1307.   P = XCreatePixmap(display,drawable,w,h,x_draw_depth);
  1308.  
  1309.   save  = x_draw_set_mode(0);   /* src-mode */
  1310.  
  1311.   XCopyArea(display,drawable,P,gc, X1,Y1,w,h,0,0);
  1312.  
  1313.   XCopyArea(display,P,drawable,gc,0,0,w,h,X,Y);
  1314.  
  1315.   x_draw_set_mode(save);
  1316.  
  1317.   if (x_draw_screen_flush)
  1318.     XFlush(display);
  1319.  }
  1320.  
  1321.  
  1322. x_draw_move_rect(x1,y1,x2,y2,x,y)
  1323. double x1,y1,x2,y2,x,y;
  1324. {
  1325.   Pixmap P;
  1326.  
  1327.   int w = (int)((x2-x1)*x_draw_scale);
  1328.   int h = (int)((y2-y1)*x_draw_scale);
  1329.  
  1330.   int X1 = XPIX(x1);
  1331.   int Y1 = YPIX(y2);
  1332.  
  1333.   int X = XPIX(x);
  1334.   int Y = YPIX(y)-h;
  1335.  
  1336.   int i,j;
  1337.  
  1338.   int save;
  1339.  
  1340.   P = XCreatePixmap(display,drawable,w,h,x_draw_depth);
  1341.  
  1342.   save  = x_draw_set_mode(0);   /* src-mode */
  1343.  
  1344.   XCopyArea(display,drawable,P,gc, X1,Y1,w,h,0,0);
  1345.  
  1346.   save  = x_draw_set_mode(1);   /* xor-mode */
  1347.  
  1348.   while (X1!=X || Y1!=Y)
  1349.   {
  1350.     if (X1<X) i = X1+1;
  1351.     if (X1>X) i = X1-1;
  1352.     if (Y1<Y) j = Y1+1;
  1353.     if (Y1>Y) j = Y1-1;
  1354.     
  1355.     XCopyArea(display,P,drawable,gc,0,0,w,h,i,j);
  1356.     XCopyArea(display,P,drawable,gc,0,0,w,h,X1,Y1);
  1357.  
  1358.     X1 = i;
  1359.     Y1 = j;
  1360.    }
  1361.  
  1362.   x_draw_set_mode(save);
  1363.  
  1364.  
  1365.   if (x_draw_screen_flush)
  1366.     XFlush(display);
  1367.  }
  1368.  
  1369.  
  1370.  
  1371. x_draw_clear(col)
  1372. int col;
  1373. {
  1374.  int i=0;
  1375.  int n = 4;
  1376.  double x,y;
  1377.  
  1378.  
  1379.  XPoint *grid_points;
  1380.  
  1381. /*
  1382.  x_draw_filled_rectangle(x_draw_xmin,x_draw_xmax,x_draw_ymin,x_draw_ymax,col);
  1383. */
  1384.  
  1385.  XClearWindow(display,drawable);
  1386.  
  1387.  n = 0;
  1388.  if (x_draw_grid_mode) /* draw grid */
  1389.  { for(x = (int)(x_draw_xmin/x_draw_grid_mode)*x_draw_grid_mode; x<=x_draw_xmax; x+=x_draw_grid_mode)
  1390.    for(y = (int)(x_draw_ymin/x_draw_grid_mode)*x_draw_grid_mode; y<=x_draw_ymax; y+=x_draw_grid_mode)
  1391.      n++;
  1392.  
  1393.    grid_points = (XPoint *) malloc(2*n*sizeof(short));
  1394.  
  1395.    for(x = (int)(x_draw_xmin/x_draw_grid_mode)*x_draw_grid_mode; x<=x_draw_xmax; x+=x_draw_grid_mode)
  1396.    for(y = (int)(x_draw_ymin/x_draw_grid_mode)*x_draw_grid_mode; y<=x_draw_ymax; y+=x_draw_grid_mode)
  1397.    { if (x*y == 0) x_draw_filled_arc(x,y,2,2,1);
  1398.      else { grid_points[i].x = (short) XPIX(x);
  1399.             grid_points[i].y = (short) YPIX(y);
  1400.             i++;
  1401.            }
  1402.     }
  1403.  
  1404.    XDrawPoints(display,drawable,gc,grid_points,n,CoordModeOrigin);
  1405.   }
  1406.  
  1407.   if (x_draw_screen_flush)
  1408.     XFlush(display);
  1409.  }
  1410.  
  1411.  
  1412. /* TEXT  */
  1413.  
  1414. x_draw_message(line,s,col)
  1415. int line;
  1416. char * s;
  1417. int col;
  1418. { 
  1419.   XGCValues gc_val;
  1420.  
  1421.   int x = 30;
  1422.   int y = 30*line+15;
  1423.  
  1424.   if (col != x_draw_color) x_draw_set_color(col);
  1425.  
  1426.   gc_val.font     = (Font)xv_get(message_font,XV_XID);
  1427.   gc_val.function = GXxor; 
  1428.   XChangeGC(display,gc,GCFont|GCFunction,&gc_val);
  1429.  
  1430.   XDrawString(display,drawable,gc,x,y,s,strlen(s));
  1431.  
  1432.   gc_val.font     = (Font)xv_get(text_font,XV_XID);
  1433.   gc_val.function = xpix_mode_op; 
  1434.   XChangeGC(display,gc,GCFont|GCFunction,&gc_val);
  1435.  
  1436.   if (x_draw_screen_flush)
  1437.     XFlush(display);
  1438. }
  1439.  
  1440.  
  1441. x_draw_text(x,y,s,col)
  1442. double x,y;
  1443. char * s;
  1444. int col;
  1445. { 
  1446.  
  1447.   DPRINT(("x_draw_text im modus %d\n",xpix_mode_op));
  1448.  
  1449.   if (col != x_draw_color) x_draw_set_color(col);
  1450.  
  1451.   if(x_draw_text_mode == 1) /* opaque */
  1452.      XDrawImageString(display,drawable,gc,XPIX(x),YPIX(y),s,strlen(s));
  1453.   else  
  1454.      XDrawString(display,drawable,gc,XPIX(x),YPIX(y),s,strlen(s));
  1455.  
  1456.   if (x_draw_screen_flush)
  1457.     XFlush(display);
  1458. }
  1459.  
  1460. x_draw_ctext(x,y,s,col)
  1461. double x,y;
  1462. char * s;
  1463. int col;
  1464. { 
  1465.   Font_string_dims dims;
  1466.  
  1467.   DPRINT(("x_draw_ctext im modus %d\n",xpix_mode_op));
  1468.  
  1469.   if (col != x_draw_color) x_draw_set_color(col);
  1470.  
  1471.   xv_get(text_font,FONT_STRING_DIMS,s,&dims);
  1472.   x -= ((double)dims.width)/(2*x_draw_scale);
  1473.   y -= ((double)dims.height)/(3*x_draw_scale);
  1474.  
  1475.   x_draw_text(x,y,s,col);
  1476.  
  1477. }
  1478.  
  1479. x_draw_int(x0,y0,i,col)
  1480. double x0,y0;
  1481. int i,col;
  1482. { 
  1483.   char buf[16];
  1484.   sprintf(buf,"%d",i);
  1485.   x_draw_ctext(x0,y0,buf,col);
  1486.  }
  1487.  
  1488.  
  1489. x_draw_cursor()
  1490. { 
  1491.   int X,Y;
  1492.  
  1493.   X = XPIX(mouse_xreal);
  1494.   Y = YPIX(mouse_yreal);
  1495.  
  1496.   xv_vector(pw,X,Y,X+10,Y,PIX_SRC^PIX_DST,1);
  1497.   xv_vector(pw,X,Y,X-10,Y,PIX_SRC^PIX_DST,1);
  1498.   xv_vector(pw,X,Y,X,Y+10,PIX_SRC^PIX_DST,1);
  1499.   xv_vector(pw,X,Y,X,Y-10,PIX_SRC^PIX_DST,1);
  1500.  
  1501. }
  1502.  
  1503.  
  1504.  
  1505. int x_draw_confirm(header)
  1506. char *header;
  1507. { /* ask for yes or no */
  1508.   char* s[2];
  1509.   s[0] = "NO";
  1510.   s[1] = "YES";
  1511.   return x_draw_read_panel(header,2,s,0);
  1512. }
  1513.  
  1514. int x_draw_acknowledge(header)
  1515. char *header;
  1516. { /* ask for ok */
  1517.   char* s[1];
  1518.   s[0] = "OK";
  1519.   return x_draw_read_panel(header,1,s,0);
  1520. }
  1521.  
  1522. /*
  1523. int x_draw_confirm(s)
  1524. char *s;
  1525. { 
  1526.   return x_confirm(s,0);
  1527. }
  1528.  
  1529. int x_draw_acknowledge(s)
  1530. char *s;
  1531. {
  1532.   return x_confirm(s,1);
  1533. }
  1534.  
  1535. int
  1536. x_confirm(message, ok_only)
  1537. char    *message;
  1538. int    ok_only;
  1539. {
  1540.     int        answer;
  1541.   
  1542.     if (ok_only) 
  1543.       answer = notice_prompt(frame,NULL,
  1544.                 NOTICE_MESSAGE_STRINGS, message , NULL,
  1545.                 NOTICE_BUTTON_YES,      "OK",
  1546.                 NULL) ;
  1547.     else
  1548.       answer = notice_prompt(frame,NULL,
  1549.                 NOTICE_MESSAGE_STRINGS, message , NULL,
  1550.                 NOTICE_BUTTON_YES,      "YES",
  1551.                 NOTICE_BUTTON_NO,       "NO",
  1552.                 NULL) ;
  1553.  
  1554.     XFlush(display);
  1555.     return answer;
  1556. }
  1557. */
  1558.  
  1559.  
  1560.  
  1561. /* notify proc */
  1562. static void panel_input_notify(item, event)
  1563. Panel_item    item;
  1564. Event        *event;
  1565. {
  1566.     xv_set(panel,PANEL_CLIENT_DATA,(int)panel_get(item, PANEL_CLIENT_DATA),0);
  1567.  
  1568.     notify_stop();
  1569.  
  1570. }
  1571.  
  1572. int x_draw_screen_width()
  1573. { Rect *r;
  1574.   Frame frame = window_create(0, FRAME,NULL); 
  1575.   r = (Rect *) window_get(frame, WIN_SCREEN_RECT);
  1576.   window_destroy(frame);
  1577.   return(r->r_width);
  1578. }
  1579.  
  1580.  
  1581. int x_draw_screen_height()
  1582. { Rect *r;
  1583.   Frame frame = window_create(0, FRAME,NULL); 
  1584.   r = (Rect *) window_get(frame, WIN_SCREEN_RECT);
  1585.   window_destroy(frame);
  1586.   return(r->r_height);
  1587. }
  1588.  
  1589.  
  1590. static void
  1591. center_frame(frame)
  1592. Frame frame;
  1593. { Rect * r;
  1594.   int left,top,width,height;
  1595.  
  1596.     /* center frame on the screen */
  1597.  
  1598.     height = (int) window_get(frame, WIN_HEIGHT);
  1599.     width = (int) window_get(frame, WIN_WIDTH);
  1600.  
  1601.     left = (screen_width - width) / 2;
  1602.     top = (screen_height - height) / 2;
  1603.  
  1604.     if (left < 0) left = 0;
  1605.     if (top < 0) top = 0;
  1606.  
  1607.     window_set(frame, WIN_X, left, WIN_Y, top, 0);
  1608. }
  1609.  
  1610.  
  1611. static void 
  1612. init_panel_frame(message,num,label,vertical)
  1613. char    *message;
  1614. int     num;
  1615. char   **label;
  1616. int    vertical;
  1617. {
  1618.     Panel_item        message_item,button[64],but;
  1619.     int            i,w,left, top, panel_width[64], width, height;
  1620.     Rect        *r;
  1621.   
  1622.  
  1623.     panel_frame = window_create(0, FRAME,
  1624.                              FRAME_SHOW_LABEL, FALSE,
  1625.                              FRAME_NO_CONFIRM, TRUE, 
  1626.                              WIN_X, 100, WIN_Y, 100, 0);
  1627.  
  1628.  
  1629.    panel = window_create(panel_frame, PANEL, WIN_FONT, text_font, 0);
  1630.  
  1631.  
  1632.  
  1633.     message_item = panel_create_item(panel, PANEL_MESSAGE, 
  1634.                            PANEL_LABEL_STRING, message,
  1635.                            PANEL_LABEL_BOLD, TRUE,
  1636.                            PANEL_ITEM_X, 12,
  1637.                            PANEL_ITEM_Y, 10,
  1638.                        0);
  1639.  
  1640.     r = (Rect *) panel_get(message_item, PANEL_ITEM_RECT);
  1641.  
  1642.     left = 12;
  1643.  
  1644.     height = rect_bottom(r) + 15;
  1645.  
  1646.     button[0] = panel_create_item(panel, PANEL_BUTTON, 
  1647.                   PANEL_ITEM_X, left, PANEL_ITEM_Y, height, 
  1648.                   PANEL_LABEL_STRING, label[0],       
  1649.                   PANEL_CLIENT_DATA, 0,
  1650.                   PANEL_NOTIFY_PROC, panel_input_notify,
  1651.                   0);
  1652.  
  1653.       but = panel_create_item(panel, PANEL_BUTTON, 
  1654.                     PANEL_ITEM_Y, (i+1) * height,
  1655.                     PANEL_LABEL_STRING, "0",  
  1656.                     0);
  1657.  
  1658.       panel_width[0] =  panel_get(but,PANEL_ITEM_X) -left -10;
  1659.  
  1660.       w = panel_width[0];
  1661.  
  1662.        
  1663.       xv_destroy(but);
  1664.       
  1665.  
  1666.     if (vertical)
  1667.     for(i=1;i<num;i++)
  1668.     { button[i] = panel_create_item(panel, PANEL_BUTTON, 
  1669.                   PANEL_ITEM_X, left, PANEL_ITEM_Y, (i+1) * height,
  1670.                   PANEL_LABEL_STRING, label[i],     
  1671.                   PANEL_CLIENT_DATA, i,
  1672.                   PANEL_NOTIFY_PROC, panel_input_notify,
  1673.                   0);
  1674.  
  1675.       but = panel_create_item(panel, PANEL_BUTTON, 
  1676.                     PANEL_ITEM_Y, (i+1) * height,
  1677.                     PANEL_LABEL_STRING, "0",  
  1678.                     0);
  1679.  
  1680.       panel_width[i] =  panel_get(but,PANEL_ITEM_X) -left -10;
  1681.  
  1682.       if (w < panel_width[i]) w = panel_width[i];
  1683.  
  1684.        
  1685.       xv_destroy(but);
  1686.       
  1687.      }
  1688.     else
  1689.     { for(i=1;i<num;i++)
  1690.         button[i] = panel_create_item(panel, PANEL_BUTTON, 
  1691.                     PANEL_ITEM_Y, height,
  1692.                     PANEL_LABEL_STRING, label[i],  
  1693.                     PANEL_CLIENT_DATA, i,
  1694.                     PANEL_NOTIFY_PROC, panel_input_notify,
  1695.                     0);
  1696.  
  1697.       but = panel_create_item(panel, PANEL_BUTTON, 
  1698.                     PANEL_ITEM_Y, height,
  1699.                     PANEL_LABEL_STRING, "0",  
  1700.                     0);
  1701.  
  1702.       w = panel_get(but,PANEL_ITEM_X) -left -10;
  1703.  
  1704.       xv_destroy(but);
  1705.  
  1706.       for(i=0;i<num;i++) panel_width[i] = w;
  1707.  
  1708.      }
  1709.  
  1710.    /* center buttons under the message  or vice versa */
  1711.  
  1712.    for(i=0;i<num;i++)
  1713.    { left = (w - panel_width[i]) / 2;  
  1714.      panel_set(button[i],PANEL_ITEM_X,panel_get(button[i],PANEL_ITEM_X)+left,0);
  1715.     }
  1716.  
  1717.     left = (r->r_width - w) / 2;  
  1718.  
  1719.     if (left < 0) 
  1720.       panel_set(message_item,PANEL_ITEM_X,12-left,0);
  1721.     else
  1722.       for(i=0;i<num;i++)
  1723.         panel_set(button[i],PANEL_ITEM_X,panel_get(button[i],PANEL_ITEM_X)+left,0);
  1724.  
  1725.  
  1726.  
  1727.     window_fit(panel);
  1728.     window_fit(panel_frame);
  1729.  
  1730.     center_frame(panel_frame);
  1731. }
  1732.  
  1733.  
  1734. int x_draw_read_panel(message,n,labels,vertical)
  1735. char    *message;
  1736. int n;
  1737. char    **labels;
  1738. int    vertical;
  1739. {
  1740.     int answer;
  1741.  
  1742.     if (x_draw_grid_mode) x_draw_cursor();
  1743.  
  1744.     /* create the panel_frame */
  1745.     init_panel_frame(message,n,labels,vertical);
  1746.  
  1747.  
  1748.     xv_main_loop(panel_frame);
  1749.  
  1750.     answer = (int)xv_get(panel,PANEL_CLIENT_DATA);
  1751.  
  1752.  
  1753.     /* destroy the panel_frame */
  1754.     window_destroy(panel_frame);
  1755.  
  1756.     if (x_draw_grid_mode) x_draw_cursor();
  1757.  
  1758.     x_draw_reset_gc();
  1759.  
  1760.     XFlush(display);
  1761.  
  1762.     return answer;
  1763.  
  1764. }
  1765.  
  1766.  
  1767.  
  1768.  
  1769. char* x_draw_read_text_panel(message,menu_label,n,items)
  1770. char    *message;
  1771. char    *menu_label;
  1772. int      n;
  1773. char   **items;
  1774. {
  1775.     if (x_draw_grid_mode) x_draw_cursor();
  1776.  
  1777.     /* create the panel_frame */
  1778.     init_panel_text_frame(message,menu_label,n,items);
  1779.  
  1780.     xv_main_loop(panel_frame);
  1781.  
  1782.     /* destroy the panel_frame */
  1783.     window_destroy(panel_frame);
  1784.  
  1785.     if (x_draw_grid_mode) x_draw_cursor();
  1786.  
  1787.     x_draw_reset_gc();
  1788.  
  1789.     XFlush(display);
  1790.  
  1791.     return text_panel_answer;
  1792.  
  1793. }
  1794.  
  1795.  
  1796.  
  1797. static Panel_item panel_text_item;
  1798.  
  1799. static void 
  1800. init_panel_text_frame(message,menu_label,n,items)
  1801. char    *message;
  1802. char    *menu_label;
  1803. int      n;
  1804. char  **items;
  1805. {
  1806.     
  1807.     int       left, top, width, height;
  1808.     Rect  *r;
  1809.     int    i;
  1810.     Menu   menu;
  1811.     int    cols;
  1812.  
  1813.  
  1814.     cols =  1+ n/15;
  1815.   
  1816.  
  1817.     panel_frame = window_create(0, FRAME,
  1818.                              FRAME_SHOW_LABEL, FALSE,
  1819.                              FRAME_NO_CONFIRM, TRUE, 
  1820.                              WIN_X, mouse_xpix, WIN_Y, mouse_ypix, 0);
  1821.  
  1822.  
  1823.     panel = window_create(panel_frame, PANEL, WIN_FONT, text_font, 0);
  1824.  
  1825.  
  1826.  
  1827.  
  1828.     panel_text_item = panel_create_item(panel, PANEL_TEXT, 
  1829.                            PANEL_ITEM_Y, 18,
  1830.                            PANEL_NOTIFY_PROC,  panel_input_text_notify,
  1831.                            PANEL_LABEL_STRING, message,
  1832.                            PANEL_VALUE_DISPLAY_LENGTH, 20,
  1833.                            PANEL_VALUE_STORED_LENGTH, 256, 
  1834.                        0);
  1835.     
  1836. /*
  1837.     if (n>0)
  1838.     { menu = (Menu)xv_create(NULL, MENU,
  1839.                              MENU_NCOLS, cols,
  1840.                              MENU_NOTIFY_PROC, text_panel_menu_proc,
  1841.                              0);
  1842.  
  1843.       for(i=0;i<n;i++) menu_set(menu,MENU_STRING_ITEM,items[i],i,0);
  1844.  
  1845.       (void) xv_create(panel, PANEL_BUTTON,
  1846.                               PANEL_LABEL_STRING, menu_label,
  1847.                               PANEL_ITEM_MENU,    menu, 
  1848.                               0);
  1849.      }
  1850. */
  1851.  
  1852.  
  1853.     window_fit(panel);
  1854.     window_fit(panel_frame);
  1855.  
  1856.     center_frame(panel_frame);
  1857.  
  1858.     window_set(panel, PANEL_CARET_ITEM, panel_text_item, 0);
  1859.  
  1860. }
  1861.  
  1862.  
  1863. /* notify proc */
  1864.  
  1865. static void panel_input_text_notify(item, event)    /* pressing return */
  1866. Panel_item    item;
  1867. Event        *event;
  1868. {
  1869.     strcpy(text_panel_answer,(char*)panel_get_value(item));
  1870.     notify_stop();
  1871. }
  1872.  
  1873.  
  1874. static void text_panel_menu_proc(menu, menu_item)  /* selecting menu */
  1875. Menu menu;
  1876. Menu_item menu_item;
  1877. {
  1878.     xv_set(panel_text_item,PANEL_VALUE,xv_get(menu_item, MENU_STRING),0);
  1879.     strcpy(text_panel_answer,xv_get(menu_item, MENU_STRING));
  1880.     notify_stop();
  1881. }
  1882.  
  1883.  
  1884.  
  1885.  
  1886.  
  1887. void x_draw_notice(mesg)
  1888. char* mesg;
  1889. {
  1890.     notice_prompt(frame, NULL,
  1891.         NOTICE_FOCUS_XY,        500,200,
  1892.         NOTICE_MESSAGE_STRINGS, mesg, NULL,
  1893.         NOTICE_BUTTON_YES,      "OK",
  1894.         NULL);
  1895. }
  1896.  
  1897. static done_proc(subframe)
  1898. Frame subframe;
  1899. { xv_set(subframe,XV_SHOW,FALSE,0);
  1900.   notify_stop();
  1901.  }
  1902.  
  1903. x_draw_message_panel(argc, argv)
  1904. char *argv[];
  1905. {   int max_len,i,left, top, width, height;
  1906.     Rect        *r;
  1907.     Panel_item but;
  1908.  
  1909.     if (x_draw_grid_mode) x_draw_cursor();
  1910.  
  1911.     panel_frame = (Frame)xv_create(NULL, FRAME, 
  1912.                                    FRAME_LABEL, argv[0], 
  1913.                                    WIN_X, 10,
  1914.                                    WIN_Y, 10,
  1915.                                    NULL);
  1916.  
  1917.  
  1918. /*
  1919.  
  1920.     panel_frame = (Frame)xv_create(frame, FRAME_CMD,
  1921.                                          WIN_X, 10,
  1922.                                          WIN_Y, 10,
  1923.                                          WIN_WIDTH, 10,
  1924.                                          WIN_HEIGHT, 10,
  1925.                                          FRAME_CMD_PUSHPIN_IN, TRUE,
  1926.                                          FRAME_LABEL, argv[0],
  1927.                                          FRAME_DONE_PROC, done_proc,
  1928.                                          NULL);
  1929. */
  1930.  
  1931.     panel = window_create(panel_frame, PANEL, 
  1932.                                        PANEL_LAYOUT, PANEL_VERTICAL,
  1933.                                        WIN_FONT, text_font, 0);
  1934.  
  1935.     if (argc > 1)
  1936.     { xv_create(panel, PANEL_MESSAGE, 
  1937.                 PANEL_ITEM_Y, 10,
  1938.                 PANEL_ITEM_X, 25,
  1939.                 PANEL_LABEL_BOLD, TRUE, 
  1940.                 PANEL_LABEL_STRING, argv[1],
  1941.                 NULL);
  1942.       max_len = strlen(argv[1]);
  1943.      }
  1944.  
  1945.     for(i = 2; i< argc; i++)
  1946.     { if (max_len < strlen(argv[i])) 
  1947.           max_len = strlen(argv[i]);
  1948.       xv_create(panel, PANEL_MESSAGE, 
  1949.                 PANEL_ITEM_X, 25,
  1950.                 PANEL_LABEL_BOLD, TRUE, 
  1951.                 PANEL_LABEL_STRING, argv[i],
  1952.                 NULL);
  1953.      }
  1954.  
  1955.     but = xv_create(panel, PANEL_BUTTON,
  1956.                 PANEL_LABEL_STRING, "OK",
  1957.                 PANEL_CLIENT_DATA, 0,
  1958.                 PANEL_NOTIFY_PROC, panel_input_notify,
  1959.                 NULL);
  1960.  
  1961.  
  1962.     window_fit(panel);
  1963.     window_fit(panel_frame);
  1964.  
  1965.     width = xv_get(panel_frame,WIN_WIDTH);
  1966.     panel_set(but,PANEL_ITEM_X,width/2 - 15,0);
  1967.  
  1968.  
  1969.     center_frame(panel_frame);
  1970.  
  1971.     xv_main_loop(panel_frame);
  1972.  
  1973.     window_destroy(panel_frame);
  1974.  
  1975.     if (x_draw_grid_mode) x_draw_cursor();
  1976. }
  1977.