Return to frameop.c CVS log

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

Annotation of researchv10dc/630/src/frameop.c, revision 1.1.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.