Return to frdelete.c CVS log

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

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

1.1     ! root        1: #include "frame.h"
        !             2: 
        !             3: frdelete(f, p0, p1)
        !             4:        register Frame *f;
        !             5:        Posn p0, p1;
        !             6: {
        !             7:        Point pt0, pt1, ppt0;
        !             8:        register Box *b;
        !             9:        register n0, n1, n;
        !            10:        Rectangle r;
        !            11:        int nn0;
        !            12:        if(p0>=f->nchars || p0==p1 || f->b==0)
        !            13:                return 0;
        !            14:        if(p1>f->nchars)
        !            15:                p1=f->nchars;
        !            16:        n0=findbox(f, 0, 0, p0);
        !            17:        n1=findbox(f, n0, p0, p1);
        !            18:        pt0=ptofcharnb(f, p0, n0);
        !            19:        pt1=ptofchar(f, p1);
        !            20:        if(f->p0!=p0 || f->p1!=p1)      /* likely they ARE equal */
        !            21:                selectp(f, F_XOR);      /* can do better some day */
        !            22:        selectf(f, pt0, pt1, F_CLR);
        !            23:        if(n0==f->nbox)
        !            24:                panic("off end in frdelete");
        !            25:        nn0=n0;
        !            26:        ppt0=pt0;
        !            27:        freebox(f, n0, n1-1);
        !            28:        /*
        !            29:         * Invariants:
        !            30:         *  pt0 points to beginning, pt1 points to end
        !            31:         *  n0 is box containing beginning of stuff being deleted
        !            32:         *  n1, b are box containing beginning of stuff to be kept after deletion
        !            33:         *  region between pt0 and pt1 is clear
        !            34:         */
        !            35:        b=&f->box[n1];
        !            36:        while(pt1.x!=pt0.x && n1<f->nbox){
        !            37:                cklinewrap0(f, &pt0, b);
        !            38:                cklinewrap(f, &pt1, b);
        !            39:                if(b->len>0){
        !            40:                        n=canfit(f, pt0, b);
        !            41:                        if(n==0)
        !            42:                                        panic("canfit==0");
        !            43:                        if(n!=b->len){
        !            44:                                splitbox(f, n1, n);
        !            45:                                b=&f->box[n1];
        !            46:                        }
        !            47:                        r.origin=r.corner=pt1;
        !            48:                        r.corner.x+=b->wid, r.corner.y+=f->font->height;
        !            49:                        bitblt(B, r, B, pt0, F_STORE);
        !            50:                        if(pt0.y==pt1.y)
        !            51:                                r.origin.x=r.corner.x-(pt1.x-pt0.x);
        !            52:                        rectf(B, r, F_CLR);
        !            53:                }
        !            54:                advance(f, &pt1, b);
        !            55:                pt0.x+=newwid(f, pt0, b);
        !            56:                f->box[n0++]=f->box[n1++];
        !            57:                b++;
        !            58:        }
        !            59:        if(pt1.y!=pt0.y){
        !            60:                Point pt2;
        !            61:                pt2=ptofcharptb(f, 32767, pt1, n1);
        !            62:                if(pt2.y>f->r.corner.y)
        !            63:                        panic("ptofchar in frdelete");
        !            64:                if(n1<f->nbox){
        !            65:                        int q0, q1, q2;
        !            66:                        q0=pt0.y+f->font->height, q1=pt1.y+f->font->height;
        !            67:                        q2=pt2.y+f->font->height;
        !            68:                        bitblt(B, Rect(pt1.x, pt1.y, f->r.corner.x, q1),
        !            69:                               B, pt0, F_STORE);
        !            70:                        bitblt(B, Rect(f->r.origin.x, q1, f->r.corner.x, q2),
        !            71:                               B, Pt(f->r.origin.x, q0), F_STORE);
        !            72:                        selectf(f, Pt(pt2.x, pt2.y-(pt1.y-pt0.y)), pt2, F_CLR);
        !            73:                }else
        !            74:                        selectf(f, pt0, pt2, F_CLR);
        !            75:        }
        !            76:        closebox(f, n0, n1-1);
        !            77:        if(nn0>0 && f->box[nn0-1].len>=0 && ppt0.x-f->box[nn0-1].wid>=(int)f->left){
        !            78:                --nn0;
        !            79:                ppt0.x-=f->box[nn0].wid;
        !            80:        }
        !            81:        clean(f, ppt0, nn0, n0<f->nbox-1? n0+1 : n0);
        !            82:        if(f->p1>p1)
        !            83:                f->p1-=p1-p0;
        !            84:        else if(f->p1>p0)
        !            85:                f->p1=p0;
        !            86:        if(f->p0>p1)
        !            87:                f->p0-=p1-p0;
        !            88:        else if(f->p0>p0)
        !            89:                f->p0=p0;
        !            90:        selectp(f, F_XOR);
        !            91:        f->nchars-=p1-p0;
        !            92:        if(pt0.x!=pt1.x)
        !            93:                f->lastlinefull=pt0.x==f->left;
        !            94:        pt0=ptofchar(f, f->nchars);
        !            95:        n=f->nlines;
        !            96:        f->nlines=(pt0.y-f->r.origin.y)/f->font->height+(pt0.x>f->left);
        !            97:        return n-f->nlines;
        !            98: }

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