Annotation of researchv9/jtools/src/sunlib/bitblt.c, revision 1.1

1.1     ! root        1: /* bitblt routines */
        !             2: #include "jerq.h"
        !             3: 
        !             4: void
        !             5: bitblt (sb, r, db, p, f)
        !             6: Bitmap *sb, *db;
        !             7: Rectangle r;   /* in source bitmap */
        !             8: Point p;       /* in dest bitmap */
        !             9: Code f;
        !            10: {
        !            11:        int wd = r.corner.x - r.origin.x;
        !            12:        int ht = r.corner.y - r.origin.y;
        !            13: 
        !            14:        if(sb->flag & BI_OFFSCREEN)
        !            15:                r.origin = sub(r.origin, sb->rect.origin);
        !            16:        if(db->flag & BI_OFFSCREEN)
        !            17:                p = sub(p, db->rect.origin);
        !            18: #ifdef X11
        !            19:        XSetFunction(dpy, gc, f);
        !            20:        XCopyArea(dpy, sb->dr, db->dr, gc, r.origin.x, r.origin.y,
        !            21:                wd, ht, p.x, p.y);
        !            22: #endif X11
        !            23: #ifdef SUNTOOLS
        !            24:        if(sb->flag & BI_OFFSCREEN){
        !            25:                if(db->flag & BI_OFFSCREEN)     /* pr to pr */
        !            26:                        pr_rop((Pixrect *)db->dr, p.x, p.y, wd, ht, f,
        !            27:                                (Pixrect *)sb->dr, r.origin.x, r.origin.y);
        !            28:                else                            /* pr to pw */
        !            29:                        pw_write((Pixwin *)db->dr, p.x, p.y, wd, ht, f,
        !            30:                                (Pixrect *)sb->dr, r.origin.x, r.origin.y);
        !            31:        }
        !            32:        else{
        !            33:                if(db->flag & BI_OFFSCREEN)     /* pw to pr */
        !            34:                        pw_read((Pixrect *)db->dr, p.x, p.y, wd, ht, f,
        !            35:                                (Pixwin *)sb->dr, r.origin.x, r.origin.y);
        !            36:                else                            /* pw to pw */
        !            37:                        pw_copy((Pixwin *)db->dr, p.x, p.y, wd, ht, f,
        !            38:                                (Pixwin *)sb->dr, r.origin.x, r.origin.y);
        !            39:        }
        !            40: #endif SUNTOOLS
        !            41: }
        !            42: 
        !            43: void
        !            44: point (b, p, f)
        !            45: Bitmap *b;
        !            46: Point p;
        !            47: Code f;
        !            48: {
        !            49:        int i;
        !            50: 
        !            51:        if(b->flag & BI_OFFSCREEN)
        !            52:                p = sub(p, b->rect.origin);
        !            53: #ifdef X11
        !            54:        XSetFunction(dpy, gc, f);
        !            55:        XDrawPoint(dpy, b->dr, gc, p.x, p.y);
        !            56: #endif X11
        !            57: #ifdef SUNTOOLS
        !            58:        switch(f){
        !            59:        case F_STORE:
        !            60:        case F_OR:
        !            61:                if(b->flag & BI_OFFSCREEN)
        !            62:                        pr_put((Pixrect *)b->dr, p.x, p.y, 1);
        !            63:                else
        !            64:                        pw_put((Pixwin *)b->dr, p.x, p.y, 1);
        !            65:                break;
        !            66:        case F_CLR:
        !            67:                if(b->flag & BI_OFFSCREEN)
        !            68:                        pr_put((Pixrect *)b->dr, p.x, p.y, 0);
        !            69:                else
        !            70:                        pw_put((Pixwin *)b->dr, p.x, p.y, 0);
        !            71:                break;
        !            72:        case F_XOR:
        !            73:                if(b->flag & BI_OFFSCREEN) {
        !            74:                        i = pr_get((Pixrect *)b->dr,p.x,p.y);
        !            75:                        pr_put((Pixrect *)b->dr, p.x, p.y, !i);
        !            76:                } else {
        !            77:                        i = pw_get((Pixwin *)b->dr,p.x,p.y);
        !            78:                        pw_put((Pixwin *)b->dr, p.x, p.y, !i);
        !            79:                }
        !            80:                break;
        !            81:        }
        !            82: #endif SUNTOOLS
        !            83: }
        !            84: 
        !            85: void
        !            86: rectf (b, r, f)
        !            87: Bitmap *b;
        !            88: Rectangle r;
        !            89: Code f;
        !            90: {
        !            91:        Point diff;
        !            92: 
        !            93:        diff = sub(r.corner, r.origin);
        !            94:        if(b->flag & BI_OFFSCREEN)
        !            95:                r.origin = sub(r.origin, b->rect.origin);
        !            96: #ifdef X11
        !            97:        XSetFunction(dpy, gc, f);
        !            98:        XFillRectangle(dpy, b->dr, gc,r.origin.x,r.origin.y,diff.x,diff.y);
        !            99: #endif X11
        !           100: #ifdef SUNTOOLS
        !           101:        switch(f){
        !           102:        case F_STORE:
        !           103:        case F_OR:
        !           104:                f = PIX_NOT(PIX_SRC);
        !           105:                break;
        !           106:        case F_CLR:
        !           107:                f = PIX_SRC;
        !           108:                break;
        !           109:        case F_XOR:
        !           110:                f = PIX_NOT(PIX_SRC) ^ PIX_DST;
        !           111:                break;
        !           112:        }
        !           113:        if(b->flag & BI_OFFSCREEN)
        !           114:                pr_rop((Pixrect *)b->dr, r.origin.x, r.origin.y,
        !           115:                        diff.x, diff.y, f, 0, 0, 0);
        !           116:        else
        !           117:                pw_write((Pixwin *)b->dr, r.origin.x, r.origin.y,
        !           118:                        diff.x, diff.y, f, 0, 0, 0);
        !           119: #endif SUNTOOLS
        !           120: }
        !           121: 
        !           122: screenswap (bp, rect, screenrect)
        !           123: register Bitmap *bp;
        !           124: Rectangle rect;
        !           125: Rectangle screenrect;
        !           126: {
        !           127:        bitblt(&display, screenrect, bp, rect.origin, F_XOR);
        !           128:        bitblt(bp, rect, &display, screenrect.origin, F_XOR);
        !           129:        bitblt(&display, screenrect, bp, rect.origin, F_XOR);
        !           130: }
        !           131: 
        !           132: void
        !           133: segment (b, p, q, f)
        !           134: Bitmap *b;
        !           135: Point p, q;
        !           136: Code f;
        !           137: {
        !           138:        int i;
        !           139: 
        !           140:        if(b->flag & BI_OFFSCREEN){
        !           141:                p = sub(p, b->rect.origin);
        !           142:                q = sub(q, b->rect.origin);
        !           143:        }
        !           144: #ifdef X11
        !           145:        XSetFunction(dpy, gc, f);
        !           146:        XDrawLine(dpy, b->dr, gc, p.x, p.y, q.x, q.y);
        !           147: #endif X11
        !           148: #ifdef SUNTOOLS
        !           149:        /*      Blit compatability - don't set the last pixel   */
        !           150:        if(b->flag & BI_OFFSCREEN){
        !           151:                i = pr_get((Pixrect *)b->dr,q.x,q.y);
        !           152:                pr_vector((Pixrect *)b->dr, p.x, p.y, q.x, q.y, f, 1);
        !           153:                pr_put((Pixrect *)b->dr, q.x, q.y, i);
        !           154:        }
        !           155:        else{
        !           156:                i = pw_get((Pixwin *)b->dr,q.x,q.y);
        !           157:                pw_vector((Pixwin *)b->dr, p.x, p.y, q.x, q.y, f, 1);
        !           158:                pw_put((Pixwin *)b->dr, q.x, q.y, i);
        !           159:        }
        !           160: #endif SUNTOOLS
        !           161: }
        !           162: 
        !           163: void
        !           164: texture (b, r, tile, f)
        !           165: Bitmap *b;
        !           166: Rectangle r;
        !           167: Texture *tile;
        !           168: Code f;
        !           169: {
        !           170: #ifdef SUNTOOLS
        !           171:        extern struct pixrectops mem_ops;
        !           172:        static struct mpr_data d = 
        !           173:                {mpr_linebytes(16,1), (short *)0, {0, 0}, 0, 0};
        !           174:        static struct pixrect textrect = {&mem_ops, 16, 16, 1, (caddr_t)&d};
        !           175: #endif SUNTOOLS
        !           176:        Point diff;
        !           177: 
        !           178:        diff = sub(r.cor, r.org);
        !           179:        if (b->flag & BI_OFFSCREEN)
        !           180:                r.org = sub(r.org, b->rect.org);
        !           181: #ifdef X11
        !           182:        XSetFunction(dpy, gc, f);
        !           183:        XSetFillStyle(dpy, gc, FillTiled);
        !           184:        XSetTile(dpy, gc, *tile);
        !           185:        XFillRectangle(dpy, b->dr, gc, r.org.x, r.org.y, diff.x, diff.y);
        !           186:        XSetFillStyle(dpy, gc, FillSolid);
        !           187: #endif X11
        !           188: #ifdef SUNTOOLS
        !           189:        d.md_image = *tile;
        !           190:        if(b->flag & BI_OFFSCREEN)
        !           191:                pr_replrop((Pixrect *)b->dr, r.origin.x, r.origin.y,
        !           192:                        diff.x, diff.y, f, &textrect, r.origin.x, r.origin.y);
        !           193:        else
        !           194:                pw_replrop((Pixwin *)b->dr, r.origin.x, r.origin.y,
        !           195:                        diff.x, diff.y, f, &textrect, r.origin.x, r.origin.y);
        !           196: #endif SUNTOOLS
        !           197: }
        !           198: 
        !           199: void
        !           200: texture32 (b, r, tile, c)
        !           201: Bitmap *b;
        !           202: Rectangle r;
        !           203: Texture32 *tile;
        !           204: Code c;
        !           205: {
        !           206: #ifdef SUNTOOLS
        !           207:        extern struct pixrectops mem_ops;
        !           208:        static struct mpr_data d = 
        !           209:                {mpr_linebytes(32,1), (short *)0, {0, 0}, 0, 0};
        !           210:        static struct pixrect textrect32 =
        !           211:                {&mem_ops, 32, 32, 1, (caddr_t)&d};
        !           212: #endif SUNTOOLS
        !           213:        Point diff;
        !           214: 
        !           215:        diff = sub(r.cor, r.org);
        !           216:        if (b->flag & BI_OFFSCREEN)
        !           217:                r.org = sub(r.org, b->rect.org);
        !           218: #ifdef X11
        !           219:        XSetFunction(dpy, gc, c);
        !           220:        XSetFillStyle(dpy, gc, FillTiled);
        !           221:        XSetTile(dpy, gc, *tile);
        !           222:        XFillRectangle(dpy, b->dr, gc, r.org.x, r.org.y, diff.x, diff.y);
        !           223:        XSetFillStyle(dpy, gc, FillSolid);
        !           224: #endif X11
        !           225: #ifdef SUNTOOLS
        !           226:        d.md_image = (short *)*tile;
        !           227:        if(b->flag & BI_OFFSCREEN)
        !           228:                pr_replrop((Pixrect *)b->dr, r.origin.x, r.origin.y,
        !           229:                   diff.x, diff.y, c, &textrect32, r.origin.x, r.origin.y);
        !           230:        else
        !           231:                pw_replrop((Pixwin *)b->dr, r.origin.x, r.origin.y,
        !           232:                   diff.x, diff.y, c, &textrect32, r.origin.x, r.origin.y);
        !           233: #endif SUNTOOLS
        !           234: }

unix.superglobalmegacorp.com

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