Return to print.c CVS log

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

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

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       "pic.h"
        !             3: #include       "y.tab.h"
        !             4: print()
        !             5: {
        !             6:        struct obj *p;
        !             7:        int i, j, m;
        !             8:        coord x0, y0, x1, y1, ox, oy, dx, dy;
        !             9: 
        !            10:        for (i = 0; i < nobj; i++) {
        !            11:                p = objlist[i];
        !            12:                ox = p->o_x;
        !            13:                oy = p->o_y;
        !            14:                x1 = p->o_val[0];
        !            15:                y1 = p->o_val[1];
        !            16:                m = p->o_mode;
        !            17:                switch (p->o_type) {
        !            18:                case TROFF:
        !            19:                        troff(text[p->o_nt1].t_val);
        !            20:                        break;
        !            21:                case BOX:
        !            22:                case BLOCK:
        !            23:                        move(ox, oy);
        !            24:                        dotext(p);      /* if there are any text strings */
        !            25:                        x0 = ox - (x1+1) / 2;
        !            26:                        y0 = oy - (y1+1) / 2;
        !            27:                        x1 = ox + x1 / 2;
        !            28:                        y1 = oy + y1 / 2;
        !            29:                        if (p->o_attr & INVIS || p->o_type == BLOCK)
        !            30:                                ;       /* nothing at all */
        !            31:                        else
        !            32:                                box(x0, y0, x1, y1, p->o_dotdash, p->o_ddval);
        !            33:                        if (ishor(m))
        !            34:                                move(isright(m) ? x1 : x0, oy); /* right side */
        !            35:                        else
        !            36:                                move(ox, isdown(m) ? y0 : y1);  /* bottom */
        !            37:                        break;
        !            38:                case BLOCKEND:
        !            39:                        break;
        !            40:                        x0 = ox - (x1+1) / 2;
        !            41:                        y0 = oy - (y1+1) / 2;
        !            42:                        x1 = ox + x1 / 2;
        !            43:                        y1 = oy + y1 / 2;
        !            44:                        if (ishor(m))
        !            45:                                move(isright(m) ? x1 : x0, oy); /* right side */
        !            46:                        else
        !            47:                                move(ox, isdown(m) ? y0 : y1);  /* bottom */
        !            48:                        break;
        !            49:                case CIRCLE:
        !            50:                        move(ox, oy);
        !            51:                        dotext(p);
        !            52:                        if ((p->o_attr & INVIS) == 0)
        !            53:                                circle(ox, oy, x1);
        !            54:                        if (ishor(m))
        !            55:                                move(ox + isright(m) ? x1 : -x1, oy);
        !            56:                        else
        !            57:                                move(ox, oy + isup(m) ? x1 : -x1);
        !            58:                        break;
        !            59:                case ELLIPSE:
        !            60:                        move(ox, oy);
        !            61:                        dotext(p);
        !            62:                        if ((p->o_attr & INVIS) == 0)
        !            63:                                ellipse(ox, oy, x1, y1);
        !            64:                        if (ishor(m))
        !            65:                                move(ox + isright(m) ? x1 : -x1, oy);
        !            66:                        else
        !            67:                                move(ox, oy - isdown(m) ? y1 : -y1);
        !            68:                        break;
        !            69:                case ARC:
        !            70:                        move(ox, oy);
        !            71:                        dotext(p);
        !            72:                        if (p->o_attr & HEAD1)
        !            73:                                arrow(x1 - (y1 - oy), y1 + (x1 - ox),
        !            74:                                      x1, y1, p->o_val[4], p->o_val[5]);
        !            75:                         if (p->o_attr & INVIS)
        !            76:                                 /* probably wrong when it's cw */
        !            77:                                 move(x1, y1);
        !            78:                         else
        !            79:                                arc(ox, oy, x1, y1, p->o_val[2], p->o_val[3]);
        !            80:                        if (p->o_attr & HEAD2)
        !            81:                                arrow(p->o_val[2] + p->o_val[3] - oy, p->o_val[3] - (p->o_val[2] - ox),
        !            82:                                      p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5]);
        !            83:                        if (p->o_attr & CW_ARC)
        !            84:                                move(x1, y1);   /* because drawn backwards */
        !            85:                        break;
        !            86:                case LINE:
        !            87:                case ARROW:
        !            88:                case SPLINE:
        !            89:                        move((ox + x1)/2, (oy + y1)/2); /* center */
        !            90:                        dotext(p);
        !            91:                         if (p->o_attr & INVIS)
        !            92:                                 move(x1, y1);
        !            93:                        else if (p->o_type == SPLINE)
        !            94:                                spline(ox, oy, p->o_val[4], &p->o_val[5], p->o_attr);
        !            95:                        else if (p->o_type == LINE || p->o_type == ARROW)
        !            96:                                line(ox, oy, p->o_val[4], &p->o_val[5],
        !            97:                                        p->o_attr, p->o_dotdash, p->o_ddval);
        !            98:                        break;
        !            99:                case MOVE:
        !           100:                        move(ox, oy);
        !           101:                        dotext(p);
        !           102:                        break;
        !           103:                case TEXT:
        !           104:                        move(ox, oy);
        !           105:                        label(x1, y1, 0);
        !           106:                        free(x1);
        !           107:                        break;
        !           108:                }
        !           109:        }
        !           110: }
        !           111: 
        !           112: dotline(x0, y0, x1, y1, ddtype, ddval) /* dotted line */
        !           113: coord x0, y0, x1, y1;
        !           114: int ddtype;
        !           115: int ddval;
        !           116: {
        !           117:        static int prevval = SCALE/20;  /* 20 per inch by default */
        !           118:        int i, numdots;
        !           119:        double a, b, sqrt(), dx, dy;
        !           120: 
        !           121:        if (ddval == 0)
        !           122:                ddval = prevval;
        !           123:        prevval = ddval;
        !           124:        /* don't save dot/dash value */
        !           125:        dx = x1 - x0;
        !           126:        dy = y1 - y0;
        !           127:        if (ddtype == DOT) {
        !           128:                numdots = sqrt(dx*dx + dy*dy) / prevval + 0.5;
        !           129:                for (i = 0; i <= numdots; i++) {
        !           130:                        a = (float) i / (float) numdots;
        !           131:                        move(x0 + (int)(a * dx), y0 + (int)(a * dy));
        !           132:                        dot();
        !           133:                }
        !           134:        } else if (ddtype == DASH) {
        !           135:                double d, dashsize, spacesize;
        !           136:                d = sqrt(dx*dx + dy*dy) + 0.5;
        !           137:                if (d <= 2 * prevval) {
        !           138:                        line(x0, y0, x1, y1);
        !           139:                        return;
        !           140:                }
        !           141:                numdots = d / (2 * prevval - 1) + 1;    /* ceiling */
        !           142:                dashsize = prevval;
        !           143:                spacesize = (d - numdots * dashsize) / (numdots - 1);
        !           144:                for (i = 0; i < numdots-1; i++) {
        !           145:                        a = i * (dashsize + spacesize) / d;
        !           146:                        b = a + dashsize / d;
        !           147:                        line(x0 + (int)(a*dx), y0 + (int)(a*dy), x0 + (int)(b*dx), y0 + (int)(b*dy));
        !           148:                        a = b;
        !           149:                        b = a + spacesize / d;
        !           150:                        move(x0 + (int)(a*dx), y0 + (int)(a*dy));
        !           151:                }
        !           152:                line(x0 + (int)(b * dx), y0 + (int)(b * dy), x1, y1);
        !           153:        }
        !           154:        prevval = SCALE/20;
        !           155: }
        !           156: 
        !           157: dotbox(x0, y0, x1, y1, ddtype, ddval)  /* dotted or dashed box */
        !           158: coord x0, y0, x1, y1;
        !           159: int ddtype;
        !           160: int ddval;
        !           161: {
        !           162:        dotline(x0, y0, x1, y0, ddtype, ddval);
        !           163:        dotline(x1, y0, x1, y1, ddtype, ddval);
        !           164:        dotline(x1, y1, x0, y1, ddtype, ddval);
        !           165:        dotline(x0, y1, x0, y0, ddtype, ddval);
        !           166: }
        !           167: 
        !           168: dotext(p)      /* print text strings of p in proper vertical spacing */
        !           169: struct obj *p;
        !           170: {
        !           171:        int i, nhalf;
        !           172: 
        !           173:        nhalf = p->o_nt2 - p->o_nt1 - 1;
        !           174:        for (i = p->o_nt1; i < p->o_nt2; i++) {
        !           175:                label(text[i].t_val, text[i].t_type, nhalf);
        !           176:                nhalf -= 2;
        !           177:        }
        !           178: }

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