Return to frameop.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / mux / term / frame

Annotation of researchv9/jerq/src/mux/term/frame/frameop.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 <font.h>
        !             6: #include "frame.h"
        !             7: 
        !             8: Point endpoint;
        !             9: nexttab(t, x)
        !            10:        Frame *t;
        !            11: {
        !            12:        int eightspaces=P->defaultfont->info[' '].width<<3;
        !            13:        register xx=x-t->rect.origin.x;
        !            14:        return(xx-(xx%eightspaces)+eightspaces+t->rect.origin.x);
        !            15: }
        !            16: void opshow();
        !            17: int complete;
        !            18: frameop(t, op, pt, cp, n)
        !            19:        register Frame *t;
        !            20:        register void (*op)();
        !            21:        Point pt;
        !            22:        register unsigned char *cp;
        !            23:        register n;
        !            24: {
        !            25:        register i, j;
        !            26:        Point startpt;
        !            27:        register unsigned char *startcp;
        !            28:        complete=0;
        !            29:        endpoint=pt;
        !            30:        i=0;    /* Not in for(;;) because of \t's */
        !            31:     Top_of_loop:
        !            32:        endpoint=pt;
        !            33:        for(j=0,startpt=pt,startcp=cp; ; i++,j++,cp++){
        !            34:     Continue:
        !            35:                if(i>=n)
        !            36:                        break;
        !            37:                if(*cp=='\n'){
        !            38:                        i++, j++, cp++;
        !            39:            Emit_newline:
        !            40:                        pt.x=t->rect.corner.x;
        !            41:                        endpoint=pt;
        !            42:                        /* must do this even if j==0 */
        !            43:                        (*op)(t, startpt, pt, startcp, j);
        !            44:                        j=0;
        !            45:                        startpt.x=t->rect.origin.x;
        !            46:                        startpt.y+=newlnsz;
        !            47:                        if(startpt.y >= t->rect.corner.y)       /* off screen */
        !            48:                                return;
        !            49:                        pt=startpt;
        !            50:                        startcp=cp;
        !            51:                        goto Continue;
        !            52:                }else if(*cp == '\t'){
        !            53:                        if(j > 0){
        !            54:                                /* Emit what's saved up */
        !            55:                                (*op)(t, startpt, pt, startcp, j);
        !            56:                                goto Top_of_loop;
        !            57:                        }
        !            58:                        if((pt.x=nexttab(t, pt.x)) > t->rect.corner.x)
        !            59:                                goto Emit_newline;
        !            60:                        (*op)(t, startpt, pt, cp++, 1);
        !            61:                        i++;
        !            62:                        goto Top_of_loop;
        !            63:                }else if(*cp!='\r' && *cp<=P->defaultfont->n)
        !            64:                        if((pt.x+=cwidth(*cp)) > t->rect.corner.x)
        !            65:                                goto Emit_newline;
        !            66:        }
        !            67:        if(startpt.y < t->rect.corner.y){
        !            68:                endpoint=pt;
        !            69:                (*op)(t, startpt, pt, startcp, j);
        !            70:                complete=1;
        !            71:        }
        !            72: }
        !            73: char genbuf[100];
        !            74: void
        !            75: opdraw(t, p, q, cp, n)
        !            76:        Frame *t;
        !            77:        Point p, q;
        !            78:        register unsigned char *cp;
        !            79:        register n;
        !            80: {
        !            81:        register char *gp=genbuf;
        !            82:        while(n--){
        !            83:                if(*cp!='\n' && *cp!='\t' && *cp!='\r')
        !            84:                        *gp++=*cp;
        !            85:                cp++;
        !            86:        }
        !            87:        *gp=0;
        !            88:        p.x++;
        !            89:        string(P->defaultfont, genbuf, D, p, F_XOR);
        !            90: }
        !            91: draw(t, p, s, n)
        !            92:        Frame *t;
        !            93:        Point p;
        !            94:        char *s;
        !            95:        int n;
        !            96: {
        !            97:        frameop(t, opdraw, p, s, n);
        !            98: }
        !            99: 
        !           100: int    F_rectf;
        !           101: /*ARGSUSED*/
        !           102: void
        !           103: oprectf(t, p, q, str, n)
        !           104:        register Frame *t;
        !           105:        Point p, q;
        !           106:        char *str;
        !           107:        short n;
        !           108: {
        !           109:        Urectf(D, Rpt(p, Pt(q.x, q.y+newlnsz)), F_rectf);
        !           110: }
        !           111: 
        !           112: /*ARGSUSED*/
        !           113: void
        !           114: opclear(t, p, q, str, n)
        !           115:        register Frame *t;
        !           116:        Point p, q;
        !           117:        char *str;
        !           118:        short n;
        !           119: {
        !           120:        clear(Rpt(p, Pt(q.x, q.y+newlnsz)), 1);
        !           121: }
        !           122: 
        !           123: selectf(t, f)
        !           124:        register Frame *t;
        !           125: {
        !           126:        F_rectf=f;
        !           127:        frameop(t, oprectf, ptofchar(t, t->s1), t->str.s+t->s1, t->s2-t->s1);
        !           128: }
        !           129: void
        !           130: opnull()
        !           131: {}
        !           132: rXOR(r)        /* a space-saving routine */
        !           133:        Rectangle r;
        !           134: {
        !           135:        lrectf(D, r, F_XOR);
        !           136: }
        !           137: Rectf(r, f)
        !           138:        Rectangle r;
        !           139:        Code f;
        !           140: {
        !           141:        lrectf(D, r, f);
        !           142: }

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