Return to downback.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / layer

Annotation of researchv9/jerq/src/lib/layer/downback.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Move a layer to the back of the screen
                      3:  */
                      4: #include <jerq.h>
                      5: #include "layer.h"
                      6: 
                      7: static void
                      8: LLdownback(l, r, b, f, o)
                      9: Layer *l, *o;
                     10: Rectangle r;
                     11: Bitmap *b;
                     12: char *f;
                     13: {
                     14:        if (o) {
                     15:                o->nonevis = 0;
                     16:                o->someobs = 2; /* so we know to update it */
                     17:                l->someobs = 1;
                     18:                bitblt(l, r, l->obs, r.origin, F_STORE);
                     19:                bitblt(o->obs, r, o, r.origin, F_STORE);
                     20:        } else
                     21:                l->nonevis = 0;
                     22: }
                     23: 
                     24: static void
                     25: Ldownback(l, r, b, f, o)
                     26: Layer *l, *o;
                     27: Rectangle r;
                     28: Bitmap *b;
                     29: char *f;
                     30: {
                     31:        if (l==o)
                     32:                mRlayerop(l, LLdownback, r, f, l->back);
                     33:        else
                     34:                l->someobs = 1;
                     35: }
                     36: 
                     37: downback(lp)
                     38:        register Layer *lp;
                     39: {
                     40:        register Layer *l, *visl;
                     41: 
                     42:        if(lp==0 || lp->back==0)
                     43:                return;         /* Why continue? */
                     44:        /*
                     45:         * Move bits of lp to back
                     46:         */
                     47:        cursinhibit();
                     48:        if (!lp->nonevis) {
                     49:                lp->nonevis = 1; /* if any stays on screen, this gets unset */
                     50:                if (lp->someobs) {
                     51:                        lp->someobs = 0; /* hack to make layerop work out */
                     52:                        layerop(lp, Ldownback, lp->rect);
                     53:                } else
                     54:                        mRlayerop(lp, LLdownback, lp->rect, (char *)0, lp->back);
                     55:        }
                     56:        cursallow();
                     57:        /*
                     58:         * Put lp at back
                     59:         */
                     60:        if(lback!=lp){
                     61:                if(lfront==lp)
                     62:                        lfront=lp->back;
                     63:                if(lp->front)
                     64:                        lp->front->back=lp->back;
                     65:                lp->back->front=lp->front;
                     66:                lback->back=lp;
                     67:                lp->front=lback;
                     68:                lp->back=0;
                     69:                lback=lp;
                     70:        }
                     71:        /*
                     72:         * We may have made some of the rectangles behind lp fully
                     73:         * visible, which is flagged by someobs==2.
                     74:         */
                     75:        for (visl=lfront; visl; visl=visl->back) {
                     76:                if (visl->someobs == 2) {
                     77:                        visl->someobs = 0;
                     78:                        for (l=lfront; l!=visl; l=l->back)
                     79:                                if (rectXrect(visl->rect, l->rect)) {
                     80:                                        visl->someobs = 1;
                     81:                                        break;
                     82:                                }
                     83:                }
                     84:        }
                     85: }

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