Return to frameop.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / sux

Annotation of researchv9/jtools/src/sux/frameop.c, revision 1.1

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

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