Return to newframe.c CVS log

Up to [Research Unix] / researchv10dc / 630 / src

Annotation of researchv10dc/630/src/newframe.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: #include <layer.h>
        !             3: #include <queue.h>
        !             4: #include <jerqproc.h>
        !             5: #include "frame.h"
        !             6: 
        !             7: Rectangle Null /* ={0,0,0,0} */;
        !             8: Frame *
        !             9: fralloc(r, m)
        !            10:        Rectangle r;
        !            11: {
        !            12:        register Frame *t=(Frame *)Ualloc(sizeof(Frame));
        !            13:        if(t){
        !            14:                strzero(&t->str);
        !            15:                t->margin=m;
        !            16:                frsetrects(t, r);
        !            17:        }
        !            18:        return t;
        !            19: }
        !            20: frsetrects(f, r)
        !            21:        register Frame *f;
        !            22:        Rectangle r;
        !            23: {
        !            24:        f->totalrect=r;
        !            25:        f->rect=inset(r, f->margin);
        !            26:        f->rect.corner.y-=(f->rect.corner.y-f->rect.origin.y)%newlnsz;
        !            27:        f->scrollrect=f->rect;
        !            28:        f->scrollrect.origin.x+=2;
        !            29:        f->scrollrect.corner.x=f->scrollrect.origin.x+SCROLLWIDTH;
        !            30:        f->rect.origin.x+=3*SCROLLWIDTH/2;
        !            31:        f->nlines=(f->rect.corner.y-f->rect.origin.y)/newlnsz;
        !            32:        if(f->nlines>MAXLINES) f->nlines=MAXLINES;
        !            33:        setcpl(f, 0, f->nlines-1);
        !            34: }
        !            35: frinit(t)
        !            36:        register Frame *t;
        !            37: {
        !            38:        clear(t->totalrect, 1);
        !            39:        border(P->layer, t->totalrect, t->margin, F_OR);
        !            40:        strzero(&t->str);
        !            41:        t->s1=t->s2=0;
        !            42:        setcpl(t, 0, t->nlines-1);
        !            43: }
        !            44: frfree(f)
        !            45:        register Frame *f;
        !            46: {
        !            47:        if(f==0 || f->str.s==0)
        !            48:                return;
        !            49:        gcfree(f->str.s);
        !            50:        free(f);
        !            51: }
        !            52: drawframe(f)
        !            53:        register Frame *f;
        !            54: {
        !            55:        int compl;
        !            56:        clear(P->layer->rect, 1);
        !            57:        border(P->layer, P->layer->rect, f->margin, F_OR);
        !            58:        drawscrollbar(f);
        !            59:        draw(f, f->rect.origin, f->str.s, f->str.n);
        !            60:        compl=complete;
        !            61:        selectf(f, F_XOR);
        !            62:        complete=compl;
        !            63: }
        !            64: closeframe(t)
        !            65:        register Frame *t;
        !            66: {
        !            67:        if(t==0 || t->str.s==0)
        !            68:                return;
        !            69:        gcfree(t->str.s);
        !            70:        t->str.s=0;
        !            71:        t->str.n=t->str.size=0;
        !            72:        t->totalrect=Null;
        !            73:        t->rect=Null;
        !            74:        t->scrollrect=Null;
        !            75:        t->str.s=0;     /* Mark it available */
        !            76: }
        !            77: setsel(t, n)
        !            78:        register Frame *t;
        !            79:        register n;
        !            80: {
        !            81:        t->s1=t->s2=n;
        !            82: }

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