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