Return to util.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / sam / term

Annotation of researchv9/jerq/src/sam/term/util.c, revision 1.1.1.1

1.1       root        1: #include "frame.h"
                      2: 
                      3: canfit(f, pt, b)
                      4:        register Frame *f;
                      5:        register Box *b;
                      6:        Point pt;
                      7: {
                      8:        register left=f->r.corner.x-pt.x;
                      9:        register uchar *p;
                     10:        if(b->len<0)
                     11:                return b->minwid<=left;
                     12:        if(left>=b->wid)
                     13:                return b->len;
                     14:        for(p=b->ptr; *p; p++)
                     15:                if((left-=(int)f->font->info[*p].width)<0) /* (int) for 3cc bug */
                     16:                        return p-b->ptr;
                     17:        panic("canfit can't");
                     18:        return 0;       /* for cyntax */
                     19: }
                     20: cklinewrap(f, p, b)
                     21:        register Frame *f;
                     22:        register Point *p;
                     23:        register Box *b;
                     24: {
                     25:        if((b->len<0? b->minwid : b->wid)>f->r.corner.x-p->x)
                     26:                p->x=f->left, p->y+=f->font->height;
                     27: }
                     28: cklinewrap0(f, p, b)
                     29:        register Frame *f;
                     30:        register Point *p;
                     31:        register Box *b;
                     32: {
                     33:        if(canfit(f, *p, b)==0)
                     34:                p->x=f->left, p->y+=f->font->height;
                     35: }
                     36: advance(f, p, b)
                     37:        register Frame *f;
                     38:        register Point *p;
                     39:        register Box *b;
                     40: {
                     41:        if(b->len<0 && b->bc=='\n')
                     42:                p->x=f->left, p->y+=f->font->height;
                     43:        else
                     44:                p->x+=b->wid;
                     45: }
                     46: newwid(f, pt, b)
                     47:        register Frame *f;
                     48:        Point pt;
                     49:        Box *b;
                     50: {
                     51:        register c=f->r.corner.x;
                     52:        register x=pt.x;
                     53:        if(b->len>=0)
                     54:                return b->wid;
                     55:        if(b->bc=='\t'){
                     56:                if(x+b->minwid>c)
                     57:                        x=pt.x=f->left;
                     58:                x+=f->maxtab;
                     59:                x-=(x-f->left)%f->maxtab;
                     60:                if(x-pt.x<b->minwid)
                     61:                        x=pt.x+b->minwid;
                     62:                b->wid=x-pt.x;
                     63:        }
                     64:        return b->wid;
                     65: }
                     66: clean(f, pt, n0, n1)   /* look for mergeable boxes */
                     67:        register Frame *f;
                     68:        Point pt;
                     69: {
                     70:        register nb;
                     71:        register Box *b;
                     72:        register c=f->r.corner.x;
                     73:        for(nb=n0; nb<n1-1; nb++){
                     74:                b=&f->box[nb];
                     75:                cklinewrap(f, &pt, b);
                     76:                while(b[0].len>=0 && nb<n1-1 && b[1].len>=0 &&
                     77:                       pt.x+b[0].wid+b[1].wid<c){
                     78:                                mergebox(f, nb);
                     79:                                n1--;
                     80:                }
                     81:                advance(f, &pt, b);
                     82:        }
                     83: }

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