home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / gle / d_x.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-29  |  17.4 KB  |  700 lines
  1. /*--------------------------------------------------------------*/
  2. /*    DecWindows Driver 1.0 , for GLE V3.0                 */
  3. /*--------------------------------------------------------------*/
  4. /*      NOTE: MUST be run from a DECwindow (vt100 window, or curses)     */
  5. /*---------------------------------------------------------------------------*/
  6. #include "all.h"
  7. #include <math.h>
  8. #include "core.h"
  9. #include "mygraph.h"
  10. #include "mydev.h"
  11. extern int gunit;
  12. extern struct gmodel g;
  13. /*---------------------------------------------------------------------------*/
  14. /*         XWindows stuff here         */
  15. /*-----------------------------------------------*/
  16. #ifdef VMS
  17. #include <decw$include/Xlib.h>
  18. #include <decw$include/Xutil.h>
  19. #else
  20. #include <X11/Xlib.h>
  21. #include <X11/Xutil.h>
  22. #endif
  23. #define FontName "-ADOBE-NEW CENTURY SCHOOLBOOK-MEDIUM-R-NORMAL--*-140-*-*-P-*"
  24. #define WindowName "CGLE Output"
  25. int maxxsize = 800;
  26. int maxysize = 800;
  27. int window1W;
  28. int window1H;
  29. Display *dpy;
  30. Window window1;
  31. GC gc,gcf;
  32. Screen *screen;
  33. static void doInitialize( );
  34. static int doDefineColor(int n);
  35. static void doCreateWindows( );
  36. static void doCreateGraphicsContext( );
  37. static void doLoadFont( );
  38. static void doExpose( );
  39. static void doWMHints( );
  40. static void doMapWindows( );
  41. static void doHandleEvents( );
  42. static void doButtonPress( );
  43.  
  44. /***************** doInitialize **************************/
  45. int color_table[9];
  46. static void doInitialize( )
  47. {
  48.     int i;
  49.     dpy = XOpenDisplay(0);
  50.     if (!dpy){
  51.         printf("Display not opened!\n");
  52.     scr_end();
  53.         exit(-1);
  54.     }
  55.     screen = XDefaultScreenOfDisplay(dpy);
  56.     doCreateWindows( );
  57.  
  58.     for (i=0;i<=9; i++) {
  59.     color_table[i] = doDefineColor(i);
  60.     }
  61.  
  62.     doCreateGraphicsContext( );
  63.  
  64.     XSync(dpy,False);
  65.     save_focus();
  66.  
  67.     doLoadFont( );
  68.  
  69.     doWMHints( );
  70.  
  71.     doMapWindows( );
  72. }
  73.  
  74. /******* doCreateWindows *********/
  75. static void doCreateWindows( )
  76. {
  77.     int window1X = (XWidthOfScreen(screen)-window1W);
  78.     int window1Y = 1;
  79.       XSetWindowAttributes xswa;
  80.  
  81.     /* Create the window1 window   width and height are global variables*/
  82.  
  83.     xswa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask
  84.             | VisibilityChangeMask;
  85.            /*  | ButtonPressMask; */
  86.     xswa.background_pixel = doDefineColor(0);
  87.  
  88.     window1 = XCreateWindow(dpy, XRootWindowOfScreen(screen),
  89.     window1X, window1Y, window1W, window1H, 0,
  90.     XDefaultDepthOfScreen(screen), InputOutput,
  91.     XDefaultVisualOfScreen(screen), CWEventMask | CWBackPixel, &xswa);
  92. }
  93.  
  94.  
  95. /******** Create the graphics context *********/
  96. static void doCreateGraphicsContext( )
  97. {
  98.     XGCValues xgcv;
  99.  
  100.     /* Create graphics context. */
  101.  
  102.     xgcv.background = doDefineColor(0);
  103.     xgcv.foreground = doDefineColor(1);
  104.  
  105.     gc = XCreateGC(dpy, window1, GCForeground | GCBackground, &xgcv);
  106.     gcf = XCreateGC(dpy, window1, GCForeground | GCBackground, &xgcv);
  107. }
  108. setcolor(i)
  109. {
  110.     XGCValues xgcv;
  111.     xgcv.foreground = color_table[i];
  112.     XChangeGC(dpy, gc, GCForeground , &xgcv);
  113. }
  114. setfillcolor(i)
  115. {
  116.     XGCValues xgcv;
  117.     xgcv.foreground = color_table[i];
  118.     XChangeGC(dpy, gcf, GCForeground , &xgcv);
  119. }
  120.  
  121. /******* Load the font for text writing ******/
  122. static void doLoadFont( )
  123. {
  124.     Font font;
  125.  
  126.     font = XLoadFont(dpy, FontName);
  127.     XSetFont(dpy, gc, font);
  128. }
  129.  
  130. /******* Create color ************************/
  131. static int doDefineColor(int i)
  132. {
  133.     int pixel;
  134.     char *colors[] = {
  135.     "white",
  136.     "black",
  137.     "red",
  138.     "green",
  139.     "blue",
  140.     "yellow",
  141.     "magenta",
  142.     "cyan",
  143.     "light grey",
  144.     "black"
  145.     };
  146.     XColor exact_color,screen_color;
  147.     if ((XDefaultVisualOfScreen(screen))->class == PseudoColor
  148.         ||  (XDefaultVisualOfScreen(screen))->class == DirectColor)
  149.         if (XAllocNamedColor(dpy, XDefaultColormapOfScreen(screen),
  150.             colors[i], &screen_color, &exact_color))
  151.                 return screen_color.pixel;
  152.             else
  153.             printf("Color not allocated! {%s}\n",colors[i]);
  154.      else
  155.         switch (i) {
  156.         case 1:        return XWhitePixelOfScreen(screen); break;
  157.             case 2:        return XBlackPixelOfScreen(screen); break;
  158.             default:        return XBlackPixelOfScreen(screen); break;
  159.         }
  160. }
  161.  
  162. /******** do WMHints *************/
  163. static void doWMHints( )
  164. {
  165.     XSizeHints xsh;
  166.  
  167.     /* Define the size and name of the window1 window */
  168.  
  169.     xsh.x = (XWidthOfScreen(screen)-window1W);
  170.     xsh.y = 1;
  171.     xsh.width = window1W;
  172.     xsh.height = window1H;
  173.     xsh.flags = PPosition | PSize;
  174.  
  175.     XSetNormalHints(dpy, window1, &xsh);
  176.  
  177.     XStoreName(dpy, window1, WindowName);
  178. }
  179. /******** doMapWindows ***********/
  180. static void doMapWindows( )
  181. {
  182.     set_expose();
  183.     XMapWindow(dpy, window1);
  184. }
  185. /****************** doHandleEvents ***********************/
  186. static wwinit=0;
  187. static void doHandleEvents( )
  188. {
  189.     XEvent event;
  190.  
  191.     for ( ; ; ) {
  192.     if (XPending(dpy) == 0 && wwinit!=0) return;
  193.     XNextEvent(dpy, &event);
  194.     switch (event.type) {
  195.             case Expose:        break;
  196.         case ButtonPress:         doButtonPress(&event); break;
  197.         }
  198.     }
  199. }
  200.  
  201. /***************** doShutdown ***************************/
  202. static void doButtonPress(eventP)
  203. XEvent *eventP;
  204. {
  205. /*
  206.     if (eventP->xexpose.window != window1) {
  207.            XDrawImageString(dpy, window1, gc, 75, 75, message[state], strlen(message[state]));
  208.     return;
  209.     }
  210. */
  211. }
  212.  
  213. getmaxx()
  214. {
  215.     return maxxsize;
  216. }
  217. getmaxy()
  218. {
  219.     return maxysize;
  220. }
  221. getmaxcolor()
  222. {
  223.     return 9;
  224. }
  225. /*---------------------------------------------------------------------------*/
  226.  
  227. #define DASHED_LINE 2
  228. #define SOLID_LINE 1
  229. #define pi 3.141592653
  230. #define BLACKANDWHITE 1
  231. #define false 0
  232. #define true (!false)
  233. #define dbg if ((gle_debug & 64)>0)
  234.  
  235. double savexsize,saveysize;
  236. extern int gle_debug;
  237. int gle_nspeed = 2; /* text mode = slow and fast */
  238. int incap=true;
  239. /*---------------------------------------------------------------------------*/
  240. /* The global variables for the PC screen driver */
  241. /*-----------------------------------------------*/
  242. int i,l,j,ix,iy;
  243. double f;
  244. double xsizecm,ysizecm;
  245. #define sx(v) ( (int) ((v) * d_xscale))
  246. #define sy(v) ( d_maxy - ((int) ((v) * d_yscale)))
  247. #define rx(v) ( (int) ((v) * d_xscale))
  248. #define ry(v) ( d_maxy - ((int) ((v) * d_yscale)))
  249.  
  250. double d_scale, d_xscale, d_yscale;
  251. int d_graphmode;
  252. int d_fillstyle=1,d_fillcolor;
  253. int d_lstyle,d_lwidth;
  254. int d_maxy;
  255.  
  256. d_devcmd(char *s)
  257. {}
  258. dxy(double x, double y, int *dx, int *dy)
  259. {
  260.     static double fx,fy;
  261.     g_dev(x,y,&fx,&fy);
  262.     *dx = sx(fx);
  263.     *dy = sy(fy);
  264. }
  265. rxy(double x, double y, int *dx, int *dy)
  266. {
  267.     static double fx,fy,zx,zy;
  268.     g_dev(x,y,&fx,&fy);
  269.     g_dev(0.0,0.0,&zx,&zy);
  270.     *dx = (int) ( (fx-zx) * d_xscale);
  271.     *dy = (int) ( (fy-zy) * d_yscale);
  272. }
  273. /*---------------------------------------------------------------------------*/
  274. d_dfont(char *c)
  275. {
  276.     /* only used for the DFONT driver which builds fonts */
  277. }
  278. /*---------------------------------------------------------------------------*/
  279. static char lastline[80];
  280. d_message(char *s)
  281. {
  282.     w_message(s);
  283. }
  284. /*---------------------------------------------------------------------------*/
  285. d_source(char *s)
  286. {
  287.     s=s;
  288. }
  289. /*---------------------------------------------------------------------------*/
  290. d_get_type(char *t)
  291. {
  292.     strcpy(t,"INTERACTIVE, X, DECWINDOWS, XWINDOWS");
  293. }
  294. /*---------------------------------------------------------------------------*/
  295. d_set_path(int onoff)
  296. {}
  297. /*---------------------------------------------------------------------------*/
  298. d_newpath()
  299. {
  300. }
  301. /*---------------------------------------------------------------------------*/
  302. d_open(double width, double height)
  303. {
  304.     gle_nspeed = 2; /* text mode = slow and fast */
  305.     xsizecm = 16;
  306.     ysizecm = 16;
  307.     /* Get largest rectangle we can fit on the screen */
  308.     d_scale = xsizecm / width;
  309.     f = ysizecm / height;
  310.     if (f<d_scale) d_scale = f;
  311.     d_xscale = d_scale * (getmaxx()) / xsizecm; /* Device Scale X, Device Scale y */
  312.     d_yscale = d_scale * (getmaxy()) / ysizecm;
  313.         window1W = width*d_xscale;
  314.         window1H = height*d_yscale;
  315.     d_maxy = window1H;
  316.     if (dpy==0 || savexsize != width || saveysize != height) {
  317.         if (dpy!=NULL) {
  318.             XUnmapWindow(dpy, window1);
  319.             XDestroyWindow(dpy, window1);
  320.             XCloseDisplay(dpy);
  321.         }
  322.         doInitialize( ); 
  323.         set_expose(); 
  324.         XRaiseWindow(dpy, window1); 
  325.         wait_expose();
  326.     } else {
  327.         set_expose(); 
  328.         XRaiseWindow(dpy, window1); 
  329.         wait_expose();
  330.     }
  331.         XClearWindow(dpy, window1);
  332.     XSync(dpy,False);
  333.     savexsize = width;
  334.     saveysize = height;
  335. }
  336. /*---------------------------------------------------------------------------*/
  337. d_tidyup()
  338. {
  339. }
  340. d_close()
  341. {
  342.     long emask;
  343.     XEvent ereturn;
  344.     g_flush();
  345.     lastline[0] = 0;
  346.     get_focus();
  347.     XSync(dpy,False);
  348.     fner("Picture completed, press RETURN to continue                    (Press any key)");
  349.     scr_refresh();
  350.  
  351.     /* Wait till he presses key or clicks mouse */
  352.     emask = ButtonPressMask | KeyPressMask;
  353.     XWindowEvent(dpy, window1, emask, &ereturn);
  354.  
  355.     /* (use this if event's don't work)      text_inkey(); */
  356.     XLowerWindow(dpy, window1);
  357.     /* restore input focus to terminal screen, and return */
  358.     restore_focus();XSync(dpy,True);
  359. }
  360. Window f_window;
  361. int f_return;
  362. save_focus()
  363. {
  364.     XGetInputFocus(dpy, &f_window, &f_return);
  365. }
  366. restore_focus()
  367. {
  368.     int i;
  369.     i = XSetInputFocus(dpy, f_window, f_return, CurrentTime);
  370. }
  371. get_focus()
  372. {
  373.     XSetInputFocus(dpy, window1, RevertToPointerRoot, CurrentTime);
  374. }
  375. /*---------------------------------------------------------------------------*/
  376. d_set_line_cap(int i)
  377. {
  378.     i++;
  379. }
  380. /*---------------------------------------------------------------------------*/
  381. d_set_line_join(int i)
  382. {
  383.     i++;
  384. }
  385. /*---------------------------------------------------------------------------*/
  386. d_set_line_miterlimit(double d)
  387. {
  388.     i++;
  389. }
  390. /*---------------------------------------------------------------------------*/
  391. d_set_line_width(double w)
  392. {
  393.     int xa,xb;
  394.     XGCValues xgcv;
  395.     rxy(w,w,&xa,&xb);
  396. /*    if (xa<=2) xa = 0; */
  397.         xgcv.line_width = xa;
  398.         XChangeGC(dpy, gc, GCLineWidth , &xgcv);
  399. }
  400. /*---------------------------------------------------------------------------*/
  401. d_set_line_styled(double dd)
  402. {}
  403. d_set_line_style(char *s)
  404. {
  405.     XGCValues xgcv;
  406.     static char *defline[] = {"","","12","41","14","92",
  407.     "1282","9229","4114","54"};
  408.     int i, dashoff=0;
  409.     char dashlist[64];
  410.  
  411.     if (strlen(s)==1)  s = defline[*s-'0'];
  412.     if (strcmp(s,"")==0) {
  413.         xgcv.line_style  = LineSolid;
  414.         XChangeGC(dpy, gc, GCLineStyle , &xgcv);
  415.     } else {
  416.         xgcv.line_style  = LineDoubleDash;
  417.         XChangeGC(dpy, gc, GCLineStyle , &xgcv);
  418.         for (i=0; *s!=0; s++,i++)
  419.         dashlist[i] = *s-'0' ? *s-'0' : 1;
  420.         XSetDashes(dpy, gc, dashoff, dashlist, i);
  421.     }
  422. }
  423. /*---------------------------------------------------------------------------*/
  424. d_fill()
  425. {
  426. }
  427. /*---------------------------------------------------------------------------*/
  428. d_fill_ary(int nwk,double (*wkx)[],double (*wky)[])
  429. {
  430.     int i;
  431. /*    fprintf(psfile,"%g %g moveto \n",(*wkx)[0],(*wky)[0]);
  432.     for (i=1;i<nwk;i++)
  433.         fprintf(psfile,"%g %g l \n",(*wkx)[i],(*wky)[i]);
  434. */
  435. }
  436. d_line_ary(int nwk,double (*wkx)[],double (*wky)[])
  437. {
  438.     int i;
  439.     dxy( (*wkx)[0], (*wky)[0], &ix, &iy);
  440. /*    moveto(ix,iy); */
  441.     for (i=1;i<nwk;i++) {
  442.         dxy( (*wkx)[i], (*wky)[i], &ix, &iy);
  443.     }
  444. }
  445. /*---------------------------------------------------------------------------*/
  446. d_stroke()
  447. {
  448. }
  449. /*---------------------------------------------------------------------------*/
  450. d_clip()
  451. {
  452. }
  453. /*---------------------------------------------------------------------------*/
  454. d_set_matrix(double newmat[3][3])
  455. {
  456. }
  457. /*---------------------------------------------------------------------------*/
  458. d_move(double zx,double zy)
  459. {
  460. }
  461. /*---------------------------------------------------------------------------*/
  462. d_reverse()     /* reverse the order of stuff in the current path */
  463. {
  464. }
  465. /*---------------------------------------------------------------------------*/
  466. d_closepath()
  467. {
  468.     g_line(g.closex,g.closey);
  469. }
  470. /*---------------------------------------------------------------------------*/
  471. d_line(double zx,double zy)
  472. {
  473.     static int ux,uy;
  474.     dxy(g.curx,g.cury,&ux,&uy);
  475.     dxy(zx,zy,&ix,&iy);
  476.         XDrawLine(dpy,window1,gc,ux,uy,ix,iy);
  477. }
  478. /*---------------------------------------------------------------------------*/
  479. d_clear()
  480. {
  481. }
  482. /*---------------------------------------------------------------------------*/
  483. d_flush()
  484. {
  485. }
  486. /*---------------------------------------------------------------------------*/
  487. int polar_xy(double r, double angle, double *dx, double *dy);
  488. int xy_polar(double dx,double dy,double *radius,double *angle);
  489. d_arcto(dbl x1,dbl y1,dbl x2,dbl y2,dbl rrr)
  490. {
  491.     double x0,y0,r1,a1,r2,a2,r3,a3,a4,r5,ssx,ssy,ex,ey;
  492.     double bx1,by1,bx2,by2,dist,neg;
  493.     g_get_xy(&x0,&y0);
  494.     xy_polar(x1-x0,y1-y0,&r1,&a1);
  495.     xy_polar(x2-x1,y2-y1,&r2,&a2);
  496.     neg = 1;
  497.     a4 = (180-a2+a1);
  498.     a3 = a2 + (a4/2);
  499.     if ((a4/2)>90 && (a4/2)<180 ) neg = -1;
  500.     if ((a4/2)<0 && (a4/2)>-90 ) neg = -1;
  501.     r3 = neg*rrr/(tan((pi/180)*a4/2));
  502.     dbg gprint("rrr %g a4/2 %g t=%g a2=%g a1=%g r1=%g r2=%g r3=%g \n",rrr,a4/2,tan(a4/2),a2,a1,r1,r2,r3);
  503.     polar_xy(-r3,a1,&ssx,&ssy); ssx += x1; ssy += y1;
  504.     polar_xy(r3,a2,&ex,&ey); ex += x1; ey += y1;
  505.     g_line(ssx,ssy);
  506.     dist = sqrt((ex-ssx) * (ex-ssx) + (ey-ssy)*(ey-ssy));
  507.     polar_xy(r1+ dist/2.5-r3,a1,&bx1,&by1); bx1 += x0; by1 += y0;
  508.     polar_xy(-r2+ -dist/2.5+r3,a2,&bx2,&by2); bx2 += x2; by2 += y2;
  509.     g_bezier(bx1,by1,bx2,by2,ex,ey);
  510.     g_line(x2,y2);
  511. }
  512. /*---------------------------------------------------------------------------*/
  513. d_arc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  514. {
  515.     static int ixr,iyr,icx,icy,a1,a2;
  516.     double ux,uy,z;
  517.     dxy(cx,cy,&icx,&icy);
  518.     rxy(r,r,&ixr,&iyr);
  519.     if (t1>t2) {z = t1; t1 = t2; t2 = z;}
  520.     a1 = t1*64; a2 = t2*64 - a1;
  521.         XDrawArc(dpy,window1,gc,icx-ixr,icy-iyr,ixr*2,iyr*2,a1,a2);
  522. }
  523. /*---------------------------------------------------------------------------*/
  524. d_narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  525. {
  526.     static int ixr,iyr,icx,icy,a1,a2;
  527.     double ux,uy,z;
  528.     dxy(cx,cy,&icx,&icy);
  529.     rxy(r,r,&ixr,&iyr);
  530.     if (t1>t2) {z = t1; t1 = t2; t2 = z;}
  531.     a1 = t1*64; a2 = t2*64 - a1;
  532.         XDrawArc(dpy,window1,gc,icx-ixr,icy-iyr,ixr*2,iyr*2,a1,a2);
  533. }
  534. /*---------------------------------------------------------------------------*/
  535. d_box_fill(dbl x1, dbl y1, dbl x2, dbl y2)
  536. {
  537.     static int ix1,iy1,ix2,iy2;
  538.     static int ii;
  539.     dxy(x1,y1,&ix1,&iy1);
  540.     dxy(x2,y2,&ix2,&iy2);
  541.     if (ix1>ix2) { ii = ix1; ix1 = ix2; ix2 = ii; }
  542.     if (iy1>iy2) { ii = iy1; iy1 = iy2; iy2 = ii; }
  543.         XFillRectangle(dpy,window1,gcf,ix1,iy1,ix2-ix1,iy2-iy1);
  544. }
  545. d_box_stroke(dbl x1, dbl y1, dbl x2, dbl y2)
  546. {
  547.     g_move(x1,y1);
  548.     g_line(x2,y1);
  549.     g_line(x2,y2);
  550.     g_line(x1,y2);
  551.     g_line(x1,y1);
  552. }
  553. /*---------------------------------------------------------------------------*/
  554. d_circle_stroke(double zr)
  555. {
  556.     static int ixr,iyr;
  557.     int ux,uy;
  558.     rxy(zr,zr,&ixr,&iyr);
  559.     ixr =(fabs(ixr)+fabs(iyr))/2;
  560.     dxy(g.curx,g.cury,&ux,&uy);
  561.         XDrawArc(dpy,window1,gc,ux-ixr,uy-ixr,ixr*2,ixr*2,0,64*360);
  562. }
  563. d_circle_fill(double zr)
  564. {
  565.     static int ixr,iyr;
  566.     int rr;
  567.     int ux,uy;
  568.     rxy(zr,zr,&ixr,&iyr);
  569.     rr = (fabs(ixr)+fabs(iyr))/2;
  570.     dxy(g.curx,g.cury,&ux,&uy);
  571.         XFillArc(dpy,window1,gcf,ux-rr,uy-rr,rr*2,rr*2,0,64*360);
  572. }
  573. /*---------------------------------------------------------------------------*/
  574. d_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3)
  575. {
  576.     double ax,bx,cx,ay,by,cy,dist;
  577.     double xxx,yyy,i,t,nstep,x0,y0;
  578.     g_get_xy(&x0,&y0);
  579.     dist = fabs(x3-x0) + fabs(y3-y0);
  580.     nstep = 12;
  581.     if (dist<1) nstep = 7;
  582.     if (dist<.5) nstep = 3;
  583.     if (dist<.1) {
  584.         g_line(x3,y3);
  585.         return;
  586.     }
  587.     cx = (x1-x0)*3;
  588.     bx = (x2-x1)*3-cx;
  589.     ax = x3-x0-cx-bx;
  590.     cy = (y1-y0)*3;
  591.     by = (y2-y1)*3-cy;
  592.     ay = y3-y0-cy-by;
  593.     for (i=0;i<=nstep;i++) {
  594.         t = i/nstep;
  595.         xxx = ax*pow(t,3.0) + bx*t*t + cx*t + x0;
  596.         yyy = ay*pow(t,3.0) + by*t*t + cy*t + y0;
  597.         g_line(xxx,yyy);
  598.     }
  599. }
  600. /*---------------------------------------------------------------------------*/
  601. d_set_color(long f)
  602. {
  603.     int i;
  604.     colortyp  cc;
  605.     cc.l = f;
  606.     i = 1;
  607.     if (cc.b[B_R]>1 && cc.b[B_G]>1 && cc.b[B_B]>1) i = 9;
  608.     if (cc.b[B_R]>60 && cc.b[B_G]>60 && cc.b[B_B]>60)  i = 8;
  609.     if (cc.b[B_R]>100) i = 2;
  610.     if (cc.b[B_B]>100) i = 4;
  611.     if (cc.b[B_G]>100) i = 3;
  612.     if (cc.b[B_R]>100 && cc.b[B_G]>100) i = 5;
  613.     if (cc.b[B_G]>100 && cc.b[B_B]>100) i = 7;
  614.     if (cc.b[B_R]>100 && cc.b[B_G]>100 && cc.b[B_B]>100) i = 8;
  615.     if (cc.b[B_R]>250 && cc.b[B_G]>250 && cc.b[B_B]>250) i = 0;
  616.     setcolor(i);
  617. }
  618. d_set_fill(long f)
  619. {
  620.     int i;
  621.     colortyp  cc;
  622.     cc.l = f;
  623.     i = 1;
  624.     if (cc.b[B_R]>1 && cc.b[B_G]>1 && cc.b[B_B]>1) i = 9;
  625.     if (cc.b[B_R]>60 && cc.b[B_G]>60 && cc.b[B_B]>60)  i = 8;
  626.     if (cc.b[B_R]>100) i = 2;
  627.     if (cc.b[B_B]>100) i = 4;
  628.     if (cc.b[B_G]>100) i = 3;
  629.     if (cc.b[B_R]>100 && cc.b[B_G]>100) i = 5;
  630.     if (cc.b[B_G]>100 && cc.b[B_B]>100) i = 7;
  631.     if (cc.b[B_R]>100 && cc.b[B_G]>100 && cc.b[B_B]>100) i = 8;
  632.     if (cc.b[B_R]>250 && cc.b[B_G]>250 && cc.b[B_B]>250) i = 0;
  633.     setfillcolor(i);
  634. }
  635. /*---------------------------------------------------------------------------*/
  636. d_beginclip()
  637. {
  638. }
  639. d_endclip()
  640. {
  641. }
  642. struct char_data {float wx,wy,x1,y1,x2,y2; };
  643. int font_get_chardata(struct char_data **cd, int ff, int cc);
  644. /*---------------------------------------------------------------------------*/
  645. int safnt;
  646. int simple_char(int cc);
  647. d_char(int font, int cc)
  648. {
  649.     static struct char_data cd;
  650.     static int ix1,ix2,iy1,iy2;
  651.     static int ux,uy;
  652.     char ss[2];
  653.  
  654.     ss[0] = cc;
  655.     ss[1] = 0;
  656.     if (safnt==0) safnt = pass_font("PLSR");
  657.     if (font_get_encoding(font)>2) {
  658.         my_char(font,cc);
  659.         return;
  660.     }
  661.     my_char(safnt,cc);
  662. }
  663.  
  664. /*
  665. int XDrawImageString(dpy, window1, gc, 75, 75, message[state], strlen(message[state]));
  666. */
  667.  
  668.  
  669.  
  670.  
  671.  
  672. int wait_expose()
  673. {
  674.     /* Wait till he presses key or clicks mouse */
  675.     XEvent ereturn;
  676.     long emask;
  677.  
  678. /*    for (;;) {
  679.         XNextEvent(dpy,&ereturn);
  680.         wprintf("Event %d  %d %d %d\n",ereturn.type,Expose,ButtonPress,
  681.             VisibilityNotify);
  682.         scr_refresh();
  683.     }
  684. */
  685.     /* XSync(dpy,True);     */
  686.         emask = ExposureMask;
  687.     XWindowEvent(dpy, window1, emask, &ereturn);
  688.     
  689.  
  690. }
  691. int set_expose()
  692. {
  693.     XEvent ereturn;
  694.     long emask;
  695.     
  696.     emask = ExposureMask | ButtonPressMask | KeyPressMask
  697.             | VisibilityChangeMask;
  698.     XSelectInput(dpy, window1, emask, &ereturn);
  699. }
  700.