Return to frame.c CVS log

Up to [Research Unix] / researchv9 / cmd / grap

Annotation of researchv9/cmd/grap/frame.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "grap.h"
                      3: #include "y.tab.h"
                      4: 
                      5: double frame_ht;       /* default frame height */
                      6: double frame_wid;      /* and width */
                      7: 
                      8: int    nsides  = 0;            /* how many sides given on this frame */
                      9: char   *sides[] = {
                     10:                "\tline from Frame.nw to Frame.ne",
                     11:                "\tline from Frame.sw to Frame.se",
                     12:                "\tline from Frame.sw to Frame.nw",
                     13:                "\tline from Frame.se to Frame.ne"
                     14: };
                     15: char   *newsides[4] = { 0, 0, 0, 0 };  /* filled in later */
                     16: 
                     17: frame()                /* pump out frame definition, reset for next */
                     18: {
                     19:        int i;
                     20: 
                     21:        fprintf(tfd, "\tframeht = %g\n", frame_ht);
                     22:        fprintf(tfd, "\tframewid = %g\n", frame_wid);
                     23:        fprintf(tfd, "Frame:\tbox ht frameht wid framewid with .sw at 0,0 ");
                     24:        if (nsides == 0)
                     25:                fprintf(tfd, "\n");
                     26:        else {
                     27:                fprintf(tfd, "invis\n");
                     28:                for (i = 0; i < 4; i++) {
                     29:                        if (newsides[i]) {
                     30:                                fprintf(tfd, "%s\n", newsides[i]);
                     31:                                free(newsides[i]);
                     32:                                newsides[i] = 0;
                     33:                        } else
                     34:                                fprintf(tfd, "%s\n", sides[i]);
                     35:                }
                     36:                nsides = 0;
                     37:        }
                     38: }
                     39: 
                     40: frameht(f)     /* set height of frame */
                     41:        double f;
                     42: {
                     43:        frame_ht = f;
                     44: }
                     45: 
                     46: framewid(f)    /* set width of frame */
                     47:        double f;
                     48: {
                     49:        frame_wid = f;
                     50: }
                     51: 
                     52: frameside(type, desc)  /* create and remember sides */
                     53:        int type;
                     54:        Attr *desc;
                     55: {
                     56:        int n;
                     57:        char buf[100];
                     58: 
                     59:        nsides++;
                     60:        switch (type) {
                     61:        case 0:         /* no side specified; kludge up all */
                     62:                frameside(TOP, desc);
                     63:                frameside(BOT, desc);
                     64:                frameside(LEFT, desc);
                     65:                frameside(RIGHT, desc);
                     66:                return;
                     67:        case TOP:       n = 0; break;
                     68:        case BOT:       n = 1; break;
                     69:        case LEFT:      n = 2; break;
                     70:        case RIGHT:     n = 3; break;
                     71:        }
                     72:        sprintf(buf, "%s %s", sides[n], desc_str(desc));
                     73:        newsides[n] = tostring(buf);
                     74: }

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