Return to jp.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / Jpic

Annotation of researchv9/jtools/src/Jpic/jp.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     jp - interpret pic on jerq
        !             3:  */
        !             4: 
        !             5: #include <jerq.h>
        !             6: #define        YFUDGE  5       /* move chars down this much */
        !             7: extern POINT current;
        !             8: char   input[10000];
        !             9: char   *ip = input;
        !            10: POINT  mpos;
        !            11: POINT  scanpoint();
        !            12: 
        !            13: main(argc, argv)
        !            14: char *argv[];
        !            15: {
        !            16:        jinit();
        !            17:        sysinit();
        !            18:        spl0();
        !            19:        jBonW();        /* black on white */
        !            20:        getpic();
        !            21:        printpic();
        !            22:        for (;;) {
        !            23:                if (button1()) {
        !            24:                        jclear();
        !            25:                        printpic();
        !            26:                } else if (button23()) {
        !            27:                        jclear();
        !            28:                        getpic();
        !            29:                        printpic();
        !            30:                }
        !            31:        }
        !            32: }
        !            33: 
        !            34: getpic()
        !            35: {
        !            36:        char temp[10];
        !            37:        register char *start, *ip;
        !            38:        static POINT pos = {20,20};
        !            39: 
        !            40:        ip = input;
        !            41:        do {
        !            42:                start = ip;
        !            43:                while ((*ip++ = jgetchar()) != '\n')
        !            44:                        ;
        !            45:        } while (*start != 'S');
        !            46:        *ip++ = 0;
        !            47:        sprintf(temp, "%d", ip-input);
        !            48:        jmoveto(pos);
        !            49:        jstring(temp);
        !            50: }
        !            51: 
        !            52: printpic()
        !            53: {
        !            54:        register int c;
        !            55:        int i, n;
        !            56:        POINT pos, pos1, pos2;
        !            57:        char s[100];
        !            58: 
        !            59:        mpos = mouse.xy;
        !            60:        cursinhibit();
        !            61:        for (ip = input; *ip; ) {
        !            62:                switch (*ip++) {
        !            63:                case ' ':
        !            64:                case '\n':
        !            65:                case '\t':
        !            66:                        break;
        !            67:                case 'm':
        !            68:                        pos = scanpoint();
        !            69:                        jmoveto(add(pos, mpos));
        !            70:                        break;
        !            71:                case 'e':
        !            72:                        pos = scanpoint();
        !            73:                        scanint();
        !            74:                        scanint();
        !            75:                        break;
        !            76:                case 'c':
        !            77:                        pos = scanpoint();
        !            78:                        jcircle(add(pos, mpos), scanint(), F_STORE);
        !            79:                        break;
        !            80:                case 'a':
        !            81:                        pos = add(scanpoint(), mpos);
        !            82:                        pos2 = add(scanpoint(), mpos);
        !            83:                        pos1 = add(scanpoint(), mpos);
        !            84:                        jarc(pos, pos1, pos2, F_STORE);
        !            85:                        break;
        !            86:                case 'l':
        !            87:                        pos = scanpoint();
        !            88:                        jmoveto(add(pos, mpos));
        !            89:                        pos = scanpoint();
        !            90:                        jlineto(add(pos, mpos), F_STORE);
        !            91:                        break;
        !            92:                case 'b':
        !            93:                        pos1 = add(scanpoint(), mpos);
        !            94:                        pos2 = add(scanpoint(), mpos);
        !            95:                        jmoveto(pos1);
        !            96:                        pos.x = pos2.x;
        !            97:                        pos.y = pos1.y;
        !            98:                        jlineto(pos, F_STORE);
        !            99:                        jlineto(pos2, F_STORE);
        !           100:                        pos.x = pos1.x;
        !           101:                        pos.y = pos2.y;
        !           102:                        jlineto(pos, F_STORE);
        !           103:                        jlineto(pos1, F_STORE);
        !           104:                        break;
        !           105:                case 't':
        !           106:                        pos = scanpoint();
        !           107:                        while ((c = *ip++) == ' ')
        !           108:                                ;       /* find type */
        !           109:                        for (i = 0; (s[i++] = *ip++) != '\n'; )
        !           110:                                ;
        !           111:                        s[i] = 0;
        !           112:                        pos.y += YFUDGE;
        !           113:                        n = strwidth(s);
        !           114:                        switch (c) {
        !           115:                        case 'C':
        !           116:                                pos.x -= n/2;
        !           117:                                break;
        !           118:                        case 'L':
        !           119:                                break;
        !           120:                        case 'R':
        !           121:                                pos.x -= n;
        !           122:                                break;
        !           123:                        }
        !           124:                        jmoveto(add(pos, mpos));
        !           125:                        jstring(s);
        !           126:                        break;
        !           127:                case '~':       /* spline, expressed in delta's */
        !           128:                        dospline();
        !           129:                        break;
        !           130:                default:
        !           131:                        while (*ip++ != '\n')
        !           132:                                ;
        !           133:                        break;
        !           134:                }
        !           135:        }
        !           136:        cursallow();
        !           137: }
        !           138: 
        !           139: dospline()
        !           140: {
        !           141:        long w, t1, t2, t3;
        !           142:        int x[50], y[50];
        !           143:        int i, j, xp, yp, n;
        !           144:        long scale = 1000;
        !           145:        int steps = 10;
        !           146:        POINT p;
        !           147: 
        !           148:        n = scanint();
        !           149:        for (i = 1; i <= n; i++) {
        !           150:                x[i] = scanint();
        !           151:                y[i] = scanint();
        !           152:        }
        !           153:        x[0] = x[1]; y[0] = y[1];
        !           154:        x[n+1] = x[n]; y[n+1] = y[n];
        !           155:        p.x = x[0]; p.y = y[0];
        !           156:        jmoveto(add(p, mpos));
        !           157: 
        !           158:        for (i = 0; i < n; i++) {
        !           159:                for (j = 0; j < steps; j++) {
        !           160:                        w = scale * j / steps;
        !           161:                        t1 = w * w / (2 * scale);
        !           162:                        w = w - scale/2;
        !           163:                        t2 = 3*scale/4 - w * w / scale;
        !           164:                        w = w - scale/2;
        !           165:                        t3 = w * w / (2*scale);
        !           166:                        p.x = (t1*x[i+2] + t2*x[i+1] + t3*x[i] + scale/2) / scale;
        !           167:                        p.y = (t1*y[i+2] + t2*y[i+1] + t3*y[i] + scale/2) / scale;
        !           168:                        jlineto(add(p, mpos), F_STORE);
        !           169:                }
        !           170:        }
        !           171: }
        !           172: 
        !           173: jclear()
        !           174: {
        !           175:        cursinhibit();
        !           176:        jrectf(screenmap.rect, F_CLR);
        !           177:        cursallow();
        !           178: }
        !           179: 
        !           180: POINT
        !           181: scanpoint()
        !           182: {
        !           183:        POINT p;
        !           184: 
        !           185:        p.x = scanint();
        !           186:        p.y = scanint();
        !           187:        return p;
        !           188: }
        !           189: 
        !           190: scanint()
        !           191: {
        !           192:        register int n, c;
        !           193: 
        !           194:        while ((c = *ip++) == ' ' || c == '\t')
        !           195:                ;
        !           196:        n = 0;
        !           197:        do {
        !           198:                n = 10 * n + c - '0';
        !           199:        } while ((c = *ip++) >= '0' && c <= '9');
        !           200:        return(n);
        !           201: }

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