Return to button.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / blitblt

Annotation of researchv9/jtools/src/blitblt/button.c, revision 1.1

1.1     ! root        1: #include "jerq.h"
        !             2: 
        !             3: #define        UP      0
        !             4: #define        DOWN    1
        !             5: 
        !             6: static short boxcurs_bits[] = {
        !             7:        0x43FF, 0xE001, 0x7001, 0x3801, 0x1D01, 0x0F01, 0x8701, 0x8F01,
        !             8:        0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0xFFFF,
        !             9: };
        !            10: static Cursor boxcurs;
        !            11: static int firstime = 1;
        !            12: 
        !            13: Rectangle
        !            14: getrect (n)
        !            15: int n;
        !            16: {
        !            17:        return getrectb(8>>n, 1);
        !            18: }
        !            19: 
        !            20: Rectangle
        !            21: getrectb (n, block)
        !            22: int n, block;
        !            23: {
        !            24:        Rectangle r, canon();
        !            25:        Point p1, p2;
        !            26:        Cursor *prev;
        !            27:        
        !            28:        if (firstime) {
        !            29:                boxcurs = ToCursor(boxcurs_bits, boxcurs_bits, 8, 8);
        !            30:                firstime = 0;
        !            31:        }
        !            32:        prev = cursswitch(&boxcurs);
        !            33:        Jscreengrab();
        !            34:        if(block){
        !            35:                buttons(UP);
        !            36:                buttons(DOWN);
        !            37:        }
        !            38:        if(!(mouse.buttons&n)){
        !            39:                r.origin.x=r.origin.y=r.corner.x=r.corner.y=0;
        !            40:                buttons(UP);
        !            41:                goto Return;
        !            42:        }
        !            43:        p1 = add(mouse.xy, Joffset);
        !            44:        p2 = p1;
        !            45:        r = canon(p1, p2);
        !            46:        outline(r);
        !            47:        for(; mouse.buttons&n; nap(2)){
        !            48:                outline(r);
        !            49:                p2 = add(mouse.xy, Joffset);
        !            50:                r = canon(p1, p2);
        !            51:                outline(r);
        !            52:        }
        !            53:        outline(r);     /* undraw for the last time */
        !            54:     Return:
        !            55:        Jscreenrelease();
        !            56:        cursswitch(prev);
        !            57:        return r;
        !            58: }
        !            59: 
        !            60: buttons (updown)
        !            61: {
        !            62:        while((button123()!=0) != updown)
        !            63:                nap(2);
        !            64: }
        !            65: 
        !            66: Rectangle
        !            67: canon (p1, p2)
        !            68: Point p1, p2;
        !            69: {
        !            70:        Rectangle r;
        !            71:        r.origin.x = min(p1.x, p2.x);
        !            72:        r.origin.y = min(p1.y, p2.y);
        !            73:        r.corner.x = max(p1.x, p2.x);
        !            74:        r.corner.y = max(p1.y, p2.y);
        !            75:        return(r);
        !            76: }
        !            77: 
        !            78: static outline(r)
        !            79: Rectangle  r;
        !            80: {
        !            81:        segment(&Jfscreen, r.org, Pt(r.cor.x, r.org.y), F_XOR);
        !            82:        segment(&Jfscreen, Pt(r.cor.x, r.org.y), r.cor, F_XOR);
        !            83:        segment(&Jfscreen, r.cor, Pt(r.org.x, r.cor.y), F_XOR);
        !            84:        segment(&Jfscreen, Pt(r.org.x, r.cor.y), r.org, F_XOR);
        !            85: }
        !            86: 
        !            87: Cursor *
        !            88: cursswitch (cp)
        !            89: Cursor *cp;
        !            90: {
        !            91:        Cursor *rc;
        !            92: #ifdef SUNTOOLS
        !            93:        extern struct pixrectops mem_ops;
        !            94:        static struct mpr_data d = 
        !            95:                {mpr_linebytes(16,1), (short *)0, {0, 0}, 0, 0};
        !            96:        static struct pixrect curs = {&mem_ops, 16, 16, 1, (caddr_t)&d};
        !            97:        static struct cursor cursor = {7, 7, F_XOR, &curs};
        !            98: #endif SUNTOOLS
        !            99: 
        !           100:        if (cp == (Cursor *)0)
        !           101:                cp = &normalcursor;
        !           102: #ifdef X11
        !           103:        XDefineCursor(dpy, display.dr, *cp);
        !           104: #endif X11
        !           105: #ifdef SUNTOOLS
        !           106:        cursor.cur_xhot = cp->hotx;
        !           107:        cursor.cur_yhot = cp->hoty;
        !           108:        d.md_image = cp->bits;
        !           109:        win_setcursor(displayfd, &cursor);
        !           110: #endif SUNTOOLS
        !           111:        rc = P->cursor;
        !           112:        P->cursor = cp;
        !           113:        return rc;
        !           114: }
        !           115: 
        !           116: cursset (p)
        !           117: Point p;
        !           118: {
        !           119: #ifdef X11
        !           120:        XWarpPointer(dpy, display.dr, display.dr, mouse.xy.x, mouse.xy.y,
        !           121:                display.rect.corner.x, display.rect.corner.y, p.x, p.y);
        !           122: #endif X11
        !           123: #ifdef SUNTOOLS
        !           124:        win_setmouseposition(displayfd, p.x, p.y);
        !           125: #endif SUNTOOLS
        !           126:        mouse.xy.x = p.x;
        !           127:        mouse.xy.y = p.y;
        !           128: }

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