Return to cursor.c CVS log

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

Annotation of researchv9/jerq/src/lib/sys/cursor.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: struct Mouse mouse;
        !             3: void nap();
        !             4: static short c_ul[]={
        !             5:        0xFF80, 0xFE00, 0xF800, 0xFC00,
        !             6:        0xFE00, 0xDF00, 0xCF80, 0x87C0,
        !             7:        0x83E0, 0x01F0, 0x00F8, 0x007C,
        !             8:        0x003E, 0x001F, 0x000E, 0x0004,
        !             9: };
        !            10: static short c_ll[]={
        !            11:        0x0004, 0x000E, 0x001F, 0x003E,
        !            12:        0x007C, 0x00F8, 0x01F0, 0x83E0,
        !            13:        0x87C0, 0xCF80, 0xDF00, 0xFE00,
        !            14:        0xFC00, 0xF800, 0xFE00, 0xFF80,
        !            15: };
        !            16: static short c_ur[]={
        !            17:        0x01FF, 0x007F, 0x001F, 0x003F,
        !            18:        0x007F, 0x00FB, 0x01F3, 0x03E1,
        !            19:        0x07C1, 0x0F80, 0x1F00, 0x3E00,
        !            20:        0x7C00, 0xF800, 0x7000, 0x2000,
        !            21: };
        !            22: static short c_lr[]={
        !            23:        0x2000, 0x7000, 0xF800, 0x7C00,
        !            24:        0x3E00, 0x1F00, 0x0F80, 0x07C1,
        !            25:        0x03E1, 0x01F3, 0x00FB, 0x007F,
        !            26:        0x003F, 0x001F, 0x007F, 0x01FF,
        !            27: };
        !            28: static setxy(),        flipcursor();
        !            29: struct curtab{
        !            30:        short   *map;
        !            31:        short   dx;
        !            32:        short   dy;
        !            33: }stdcurtab[4]={                /* 4 quadrants */
        !            34:        c_ur,   -16,    0,
        !            35:        c_ul,   0,      0,
        !            36:        c_lr,   -16,    -16,
        !            37:        c_ll,   0,      -16,
        !            38: }, usercurtab[4];
        !            39: struct curtab *curtabp;
        !            40: struct cursor{
        !            41:        unsigned x, y;
        !            42:        unsigned oldx, oldy;
        !            43:        char    quad, oldquad;
        !            44:        short   inhibit;
        !            45:        short   up;
        !            46: }cursor;
        !            47: static int     ud, lr;
        !            48: #define        QRL_MASK        01
        !            49: #define        QUD_MASK        02
        !            50: #define        QRIGHT          0
        !            51: #define        QLEFT           01
        !            52: #define        QUP             0
        !            53: #define        QDOWN           02
        !            54: #define        QLEFT_MARGIN    XMAX/3
        !            55: #define        QRIGHT_MARGIN   XMAX*2/3
        !            56: #define        QUP_MARGIN      YMAX/3
        !            57: #define        QDOWN_MARGIN    YMAX*2/3
        !            58: 
        !            59: newquad(x, y, quad)
        !            60:        register x, y, quad;
        !            61: {
        !            62:        ud=quad&QUD_MASK;
        !            63:        lr=quad&QRL_MASK;
        !            64:        if(x < QLEFT_MARGIN)
        !            65:                lr=QLEFT;
        !            66:        if(x > QRIGHT_MARGIN)
        !            67:                lr=QRIGHT;
        !            68:        if(y < QUP_MARGIN)
        !            69:                ud=QUP;
        !            70:        if(y > QDOWN_MARGIN)
        !            71:                ud=QDOWN;
        !            72:        return ud|lr;
        !            73: }
        !            74: cursinhibit(){
        !            75:        register sr=spl1();
        !            76:        if(cursor.inhibit++==0 && cursor.up)
        !            77:                flipcursor(cursor.x, cursor.y, cursor.quad);
        !            78:        splx(sr);
        !            79: }
        !            80: cursallow(){
        !            81:        if(cursor.inhibit>0)
        !            82:                cursor.inhibit--;
        !            83: }
        !            84: #define        MOUSEMAX        2048    /* 1/2 resolution of mouse registers */
        !            85: /*static*/ struct data {
        !            86:        int     last;
        !            87:        int     zero;
        !            88: }xdata,        ydata;
        !            89: static int
        !            90: update(var, datap, max)
        !            91:        register var, max;
        !            92:        register struct data *datap;
        !            93: {
        !            94:        register d;
        !            95:        d=var-datap->last;
        !            96:        if(d>MOUSEMAX)
        !            97:                datap->zero+=MOUSEMAX*2;
        !            98:        else if(d<-MOUSEMAX)
        !            99:                datap->zero-=MOUSEMAX*2;
        !           100:        datap->last=var;
        !           101:        d=var-datap->zero;      /* re-use of d */
        !           102:        if(d<0){
        !           103:                datap->zero=var;
        !           104:                d=0;
        !           105:        }else if(d>=max){
        !           106:                datap->zero=var-max;
        !           107:                d=max-1;
        !           108:        }
        !           109:        return d;
        !           110: }
        !           111: static
        !           112: setxy(){
        !           113:        register struct curtab *qp;
        !           114:        register x, y, quad;
        !           115:        x=  *XMOUSE & 0xfff;    /* coordinates go the wrong way, so negate */
        !           116:        y= -(*YMOUSE & 0xfff);
        !           117:        cursor.oldx=cursor.x;
        !           118:        cursor.oldy=cursor.y;
        !           119:        cursor.oldquad=cursor.quad;
        !           120:        x=update(x, &xdata, XMAX);
        !           121:        y=update(y, &ydata, YMAX);
        !           122:        quad=newquad(x, y, cursor.quad);
        !           123:        qp= &curtabp[quad];
        !           124:        if(x< -qp->dx)
        !           125:                x= -qp->dx;
        !           126:        if(x+(16+qp->dx)>=XMAX)
        !           127:                x=XMAX-(16+qp->dx)-1;
        !           128:        if(y< -qp->dy)
        !           129:                y= -qp->dy;
        !           130:        if(y+(16+qp->dy)>=YMAX)
        !           131:                y=YMAX-(16+qp->dy)-1;
        !           132:        if(x==cursor.oldx && y==cursor.oldy && cursor.up)
        !           133:                return(0);
        !           134:        cursor.x=x;
        !           135:        cursor.y=y;
        !           136:        cursor.quad=quad;
        !           137:        mouse.xy.x=x;
        !           138:        mouse.xy.y=y;
        !           139:        return(1);
        !           140: }
        !           141: cursset(p)
        !           142:        Point p;
        !           143: {
        !           144:        xdata.zero=xdata.last-p.x;
        !           145:        ydata.zero=ydata.last-p.y;
        !           146:        nap(1);
        !           147: }
        !           148: Bitmap cursbm;
        !           149: static
        !           150: flipcursor(x, y, q)
        !           151: {
        !           152:        register struct curtab *qp;
        !           153:        register s;
        !           154:        qp= &curtabp[q];
        !           155:        cursbm.base=(Word *) qp->map;
        !           156:        cursblt(&display, qp->map, Pt(x+qp->dx, y+qp->dy));
        !           157:                /* almost equal to
        !           158:                /* bitblt(&cursbm, cursbm.rect, &display,
        !           159:                /*              Pt(x+qp->dx, y+qp->dy), F_XOR);   */
        !           160:        cursor.up=1-cursor.up;
        !           161: }
        !           162: short interrupt;
        !           163: cursinit(){
        !           164:        curtabp=stdcurtab;
        !           165:        cursbm.width=1;
        !           166:        cursbm.rect.corner.x=cursbm.rect.corner.y=16;
        !           167:        cursor.inhibit = 0;
        !           168: }
        !           169: auto1(){
        !           170:        if(setxy() && cursor.inhibit==0){
        !           171:                if(cursor.up)
        !           172:                        flipcursor(cursor.oldx, cursor.oldy, cursor.oldquad);
        !           173:                flipcursor(cursor.x, cursor.y, cursor.quad);
        !           174:        }
        !           175:        interrupt++;
        !           176: }
        !           177: void nap(n){
        !           178:        if(n<=0)
        !           179:                return;
        !           180:        interrupt=0;
        !           181:        do; while(interrupt<n);
        !           182: }
        !           183: 
        !           184: /* static*/ Texture *old;
        !           185: Texture        *
        !           186: cursswitch(p)
        !           187:        register Texture *p;
        !           188: {
        !           189:        register struct curtab *ctp;
        !           190:        register Texture *t=old;
        !           191:        old=p;
        !           192:        cursinhibit();
        !           193:        if(p==0)
        !           194:                curtabp=stdcurtab;
        !           195:        else{
        !           196:                curtabp=usercurtab;
        !           197:                for(ctp=usercurtab; ctp<&usercurtab[4]; ctp++){
        !           198:                        ctp->map=(short *)p;
        !           199:                        ctp->dx=ctp->dy= -8;
        !           200:                }
        !           201:        }
        !           202:        cursallow();
        !           203:        return t;
        !           204: }

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