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

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.