Return to garc.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / xgedit

Annotation of 43BSD/contrib/X/xgedit/garc.c, revision 1.1.1.1

1.1       root        1: #include <X/mit-copyright.h>
                      2: 
                      3: /* Copyright    Massachusetts Institute of Technology    1984, 1985    */
                      4: 
                      5: #include "gedit.h"
                      6: 
                      7: #ifndef lint
                      8: static char *rcsid_garc_c = "$Header: garc.c,v 10.5 86/02/01 16:18:41 tony Rel $";
                      9: #endif lint
                     10: 
                     11: /* arc drawing routines */
                     12: 
                     13: double sqrt(),atan2(),sin(),cos();
                     14: char *malloc();
                     15: 
                     16: /* construct a line object */
                     17: gptr mline(x1,y1,x2,y2,next)
                     18:   gptr next;
                     19:   {    register gptr p;
                     20: 
                     21:        if ((p = (gptr)malloc(sizeof(struct segment))) == NULL) {
                     22:          msg("out of room!");
                     23:          return(next);
                     24:        }
                     25:        p->s.type = SEGMENT;
                     26:        p->s.next = next;
                     27:        p->s.parent = NULL;
                     28:        p->s.x1 = x1;
                     29:        p->s.y1 = y1;
                     30:        p->s.x2 = x2;
                     31:        p->s.y2 = y2;
                     32:        p->s.angle = 0;
                     33:        p->s.cache = NULL;
                     34:        return(p);
                     35: }
                     36: 
                     37: /* rounds the double x off to an integer */
                     38: int round(x)
                     39:  double x;
                     40:   {    register int i;
                     41:        if (x >= 0.0) i = x+0.5; else i = x-0.5;
                     42:        return(i);
                     43:   }
                     44: 
                     45: /* compute center from arc end point and radius */
                     46: circcent(ang,fx,fy,tx,ty,xcp,ycp,rp)
                     47:  int ang,fx,fy,tx,ty,*xcp,*ycp;
                     48:  double *rp;
                     49:   {    double xx,yy,ss,dd,x1,y1;
                     50: 
                     51:        xx = tx - fx; yy = ty - fy;
                     52:        dd = sqrt(xx*xx + yy*yy);       /* length of chord */
                     53:        if (dd == 0) { *xcp = fx; *ycp = fy; *rp = 0; return; }
                     54: 
                     55:        /* radius of arc */
                     56:        *rp = dd / (2.0 * sin(3.141592653 * ang / 2048.0));
                     57: 
                     58:        /* length of perpendicular to chord */
                     59:        ss = sqrt((*rp)*(*rp) - dd*dd/4.0);
                     60: 
                     61:        if (ang > 1024) ss = -ss;
                     62:        x1 = (tx + fx) / 2.0;   /* compute center point of chord */
                     63:        y1 = (ty + fy) / 2.0;
                     64:        x1 -= yy*ss/dd;         /* now compute center of circle */
                     65:        y1 += xx*ss/dd;
                     66: 
                     67:        *xcp = round(x1); *ycp = round(y1);
                     68: }
                     69: 
                     70: /* calculate new arc list */
                     71: newalist(p,xa,ya,xb,yb)
                     72:   register struct segment *p;
                     73:   {    double xx,yy,aa,bb;
                     74:        double ainc,r;
                     75:        int ix,iy,xc,yc;
                     76:        int wherex,wherey;
                     77: 
                     78:        if (p->cache != NULL) {
                     79:          rmalist(p->cache);
                     80:          p->cache = NULL;
                     81:        }
                     82: 
                     83:        if (p->angle == 0) return;
                     84:        circcent(p->angle,xa,ya,xb,yb,&xc,&yc,&r);
                     85: 
                     86:        if (r < 2.0) {
                     87:          p->cache = mline(xa-1,ya-1,xa+1,ya-1,p->cache);
                     88:          p->cache = mline(xa-1,ya,xa+1,ya,p->cache);
                     89:          p->cache = mline(xa-1,ya+1,xa+1,ya+1,p->cache);
                     90:          return;
                     91:        }
                     92: 
                     93:        xx = xa-xc; yy = ya-yc;
                     94:        aa = atan2(yy,xx);
                     95:        xx = xb-xc; yy = yb-yc;
                     96:        bb = atan2(yy,xx);
                     97: 
                     98:        /* put aa and bb into proper relationship */
                     99: /*     if (p->angle <= 1024) {
                    100: */       if (aa > bb) bb += 2*3.141592653;
                    101: /*     } else {
                    102:          if (bb > aa) aa += 2*3.141592653;
                    103:        }
                    104: */
                    105:        /* usually 32 lines/arc, but use enough to ensure that there would
                    106:         * be at least 100 segments for a full circle.
                    107:         */
                    108:        ainc = (bb - aa)/32.0;
                    109:        if (ainc > 0.628) ainc = 0.628;
                    110:        else if (ainc < -0.628) ainc = -0.628;
                    111: 
                    112:        wherex = xa; wherey = ya;
                    113:        while (1) {
                    114:          ix = xc + r*cos(aa);
                    115:          iy = yc + r*sin(aa);
                    116:          p->cache = mline(wherex,wherey,ix,iy,p->cache);
                    117:          wherex = ix; wherey = iy;
                    118:          aa += ainc;
                    119:          if ((ainc<0 && aa<=bb) || (ainc>=0 && aa>=bb)) break;
                    120:        };
                    121:        p->cache = mline(wherex,wherey,xb,yb,p->cache);
                    122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.