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     ! 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.