Return to ptofchar.c CVS log

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

Annotation of researchv9/jerq/src/sam/term/ptofchar.c, revision 1.1

1.1     ! root        1: #include "frame.h"
        !             2: 
        !             3: Point
        !             4: ptofcharptb(f, p, pt, bn)
        !             5:        register Frame *f;
        !             6:        Posn p;
        !             7:        Point pt;
        !             8:        register bn;
        !             9: {
        !            10:        register uchar *s;
        !            11:        register Box *b;
        !            12:        register l;
        !            13:        for(b=&f->box[bn]; bn<f->nbox; bn++,b++){
        !            14:                cklinewrap(f, &pt, b);
        !            15:                if(p<(l=LEN(b))){
        !            16:                        if(b->len>0)
        !            17:                                for(s=b->ptr; p>0; s++, p--){
        !            18:                                        pt.x+=f->font->info[*s].width;
        !            19:                                        if(*s==0 || pt.x>f->r.corner.x)
        !            20:                                                panic("ptofchar");
        !            21:                                }
        !            22:                        break;
        !            23:                }
        !            24:                p-=l;
        !            25:                advance(f, &pt, b);
        !            26:        }
        !            27:        return pt;
        !            28: }
        !            29: Point
        !            30: ptofchar(f, p)
        !            31:        Frame *f;
        !            32:        Posn p;
        !            33: {
        !            34:        return ptofcharptb(f, p, Pt(f->left, f->r.origin.y), 0);
        !            35: }
        !            36: Point
        !            37: ptofcharnb(f, p, nb)   /* doesn't do final advance to next line */
        !            38:        Frame *f;
        !            39:        Posn p;
        !            40: {
        !            41:        Point pt;
        !            42:        int nbox;
        !            43:        nbox=f->nbox;
        !            44:        f->nbox=nb;
        !            45:        pt=ptofcharptb(f, p, Pt(f->left, f->r.origin.y), 0);
        !            46:        f->nbox=nbox;
        !            47:        return pt;
        !            48: }
        !            49: Point
        !            50: grid(f, p)
        !            51:        register Frame *f;
        !            52:        Point p;
        !            53: {
        !            54:        p.y-=f->r.origin.y;
        !            55:        p.y-=p.y%f->font->height;
        !            56:        p.y+=f->r.origin.y;
        !            57:        if(p.x>f->r.corner.x)
        !            58:                p.x=f->r.corner.x;
        !            59:        return p;
        !            60: }
        !            61: Posn
        !            62: charofpt(f, pt)
        !            63:        register Frame *f;
        !            64:        Point pt;
        !            65: {
        !            66:        Point qt;
        !            67:        register bn;
        !            68:        register uchar *s;
        !            69:        register Box *b;
        !            70:        Posn p;
        !            71:        pt=grid(f, pt);
        !            72:        qt.x=f->left, qt.y=f->r.origin.y;
        !            73:        for(b=f->box,bn=0,p=0; bn<f->nbox && qt.y<pt.y; bn++,b++){
        !            74:                cklinewrap(f, &qt, b);
        !            75:                if(qt.y>=pt.y)
        !            76:                        break;
        !            77:                advance(f, &qt, b);
        !            78:                p+=LEN(b);
        !            79:        }
        !            80:        for(; bn<f->nbox && qt.x<=pt.x; bn++,b++){
        !            81:                cklinewrap(f, &qt, b);
        !            82:                if(qt.y>pt.y)
        !            83:                        break;
        !            84:                if(qt.x+b->wid>pt.x){
        !            85:                        if(b->len<0)
        !            86:                                advance(f, &qt, b);
        !            87:                        else for(s=b->ptr; (qt.x+=f->font->info[*s++].width)<=pt.x; p++)
        !            88:                                if(*s==0)
        !            89:                                        panic("end of string in charofpt");
        !            90:                }else{
        !            91:                        p+=abs(b->len);
        !            92:                        advance(f, &qt, b);
        !            93:                }
        !            94:        }
        !            95:        return p;
        !            96: }

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