Return to subr.c CVS log

Up to [CSRG BSD Unix] / 42BSD / usr.lib / libplot / t300s

Annotation of 42BSD/usr.lib/libplot/t300s/subr.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)subr.c     4.1 (Berkeley) 6/27/83";
        !             3: #endif
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include "con.h"
        !             7: abval(q)
        !             8: {
        !             9:        return (q>=0 ? q : -q);
        !            10: }
        !            11: 
        !            12: xconv (xp)
        !            13: {
        !            14:        /* x position input is -2047 to +2047, output must be 0 to PAGSIZ*HORZRES */
        !            15:        xp += 2048;
        !            16:        /* the computation is newx = xp*(PAGSIZ*HORZRES)/4096 */
        !            17:        return (xoffset + xp /xscale);
        !            18: }
        !            19: 
        !            20: yconv (yp)
        !            21: {
        !            22:        /* see description of xconv */
        !            23:        yp += 2048;
        !            24:        return (yp / yscale);
        !            25: }
        !            26: 
        !            27: inplot()
        !            28: {
        !            29:        stty(OUTF, &PTTY);
        !            30:        spew(ESC);
        !            31:        spew (INPLOT);
        !            32: }
        !            33: 
        !            34: outplot()
        !            35: {
        !            36:        spew(ESC);
        !            37:        spew(ACK);
        !            38:        spew(ESC);
        !            39:        spew(ACK);
        !            40:        fflush(stdout);
        !            41:        stty (OUTF, &ITTY);
        !            42: }
        !            43: 
        !            44: spew(ch)
        !            45: {
        !            46:        putc(ch, stdout);
        !            47: }
        !            48: 
        !            49: tobotleft ()
        !            50: {
        !            51:        move(-2048,-2048);
        !            52: }
        !            53: reset()
        !            54: {
        !            55:        outplot();
        !            56:        exit();
        !            57: }
        !            58: 
        !            59: float
        !            60: dist2 (x1, y1, x2, y2)
        !            61: {
        !            62:        float t,v;
        !            63:        t = x2-x1;
        !            64:        v = y1-y2;
        !            65:        return (t*t+v*v);
        !            66: }
        !            67: 
        !            68: swap (pa, pb)
        !            69: int *pa, *pb;
        !            70: {
        !            71:        int t;
        !            72:        t = *pa;
        !            73:        *pa = *pb;
        !            74:        *pb = t;
        !            75: }
        !            76: 
        !            77: #define DOUBLE 010
        !            78: #define ADDR 0100
        !            79: #define COM 060
        !            80: #define MAXX 070
        !            81: #define MAXY 07
        !            82: extern xnow,ynow;
        !            83: #define SPACES 7
        !            84: movep(ix,iy){
        !            85:        int dx,dy,remx,remy,pts,i;
        !            86:        int xd,yd;
        !            87:        int addr,command;
        !            88:        char c;
        !            89:        if(xnow == ix && ynow == iy)return;
        !            90:        inplot();
        !            91:        dx = ix-xnow;
        !            92:        dy = iy-ynow;
        !            93:        command = COM|PENUP|((dx<0)<<1)|(dy<0);
        !            94:        dx = abval(dx);
        !            95:        dy = abval(dy);
        !            96:        xd = dx/(SPACES*2);
        !            97:        yd = dy/(SPACES*2);
        !            98:        pts = xd<yd?xd:yd;
        !            99:        if((i=pts)>0){
        !           100:                c=command|DOUBLE;
        !           101:                addr=ADDR;
        !           102:                if(xd>0)addr|=MAXX;
        !           103:                if(yd>0)addr|=MAXY;
        !           104:                spew(c);
        !           105:                while(i--){
        !           106:                        spew(addr);
        !           107:                }
        !           108:        }
        !           109:        if(xd!=yd){
        !           110:                if(xd>pts){
        !           111:                        i=xd-pts;
        !           112:                        addr=ADDR|MAXX;
        !           113:                }
        !           114:                else{
        !           115:                        i=yd-pts;
        !           116:                        addr=ADDR|MAXY;
        !           117:                }
        !           118:                c=command|DOUBLE;
        !           119:                spew(c);
        !           120:                while(i--){
        !           121:                        spew(addr);
        !           122:                }
        !           123:        }
        !           124:        remx=dx-xd*SPACES*2;
        !           125:        remy=dy-yd*SPACES*2;
        !           126:        addr=ADDR;
        !           127:        i = 0;
        !           128:        if(remx>7){
        !           129:                i=1;
        !           130:                addr|=MAXX;
        !           131:                remx -= 7;
        !           132:        }
        !           133:        if(remy>7){
        !           134:                i=1;
        !           135:                addr|=MAXY;
        !           136:                remy -= 7;
        !           137:        }
        !           138:        while(i--){
        !           139:                spew(command);
        !           140:                spew(addr);
        !           141:        }
        !           142:        if(remx>0||remy>0){
        !           143:                spew(command);
        !           144:                spew(ADDR|remx<<3|remy);
        !           145:        }
        !           146:        xnow=ix;
        !           147:        ynow=iy;
        !           148:        outplot();
        !           149:        return;
        !           150: }
        !           151: xsc(xi){
        !           152:        int xa;
        !           153:        xa = (xi - obotx) * scalex + botx;
        !           154:        return(xa);
        !           155: }
        !           156: ysc(yi){
        !           157:        int ya;
        !           158:        ya = (yi - oboty) *scaley +boty;
        !           159:        return(ya);
        !           160: }

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