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     ! 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.