Return to cursor.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / libsun

Annotation of 43BSD/contrib/X/libsun/cursor.c, revision 1.1

1.1     ! root        1: #ifdef sun
        !             2: /*
        !             3:  * The Sun X drivers are a product of Sun Microsystems, Inc. and are provided
        !             4:  * for unrestricted use provided that this legend is included on all tape
        !             5:  * media and as a part of the software program in whole or part.  Users
        !             6:  * may copy or modify these drivers without charge, but are not authorized
        !             7:  * to license or distribute them to anyone else except as part of a product or
        !             8:  * program developed by the user.
        !             9:  * 
        !            10:  * THE SUN X DRIVERS ARE PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND
        !            11:  * INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A
        !            12:  * PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE
        !            13:  * PRACTICE.
        !            14:  *
        !            15:  * The Sun X Drivers are provided with no support and without any obligation
        !            16:  * on the part of Sun Microsystems, Inc. to assist in their use, correction,
        !            17:  * modification or enhancement.
        !            18:  * 
        !            19:  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
        !            20:  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THE SUN X
        !            21:  * DRIVERS OR ANY PART THEREOF.
        !            22:  * 
        !            23:  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
        !            24:  * or profits or other special, indirect and consequential damages, even if
        !            25:  * Sun has been advised of the possibility of such damages.
        !            26:  * 
        !            27:  * Sun Microsystems, Inc.
        !            28:  * 2550 Garcia Avenue
        !            29:  * Mountain View, California  94043
        !            30:  */
        !            31: 
        !            32: #ifndef        lint
        !            33: static char sccsid[] = "@(#)cursor.c 2.1 86/01/28 Copyright 1986 Sun Micro";
        !            34: #endif
        !            35: 
        !            36: /*-
        !            37:  * Copyright (c) 1986 by Sun Microsystems,  Inc.
        !            38:  */
        !            39: 
        !            40: /* cursor.c    various stuff with the mouse & cursor
        !            41:  *
        !            42:  *     StoreCursor             Creates a cursor
        !            43:  *     FreeCursor              Frees the storage taken by a cursor
        !            44:  *     LoadCursor              Loads a bitmap to use as cursor
        !            45:  *     InitMouse               Initialize the mouse
        !            46:  *     SetCursorPosition       Forces cursor to a particular position
        !            47:  *     SetMouseCharacteristics Controls speed of cursor relative to mouse
        !            48:  *
        !            49:  */
        !            50: 
        !            51: /*
        !            52:  *     ToDo:
        !            53:  *             Threshold/Acceleration
        !            54:  *             Use macros for CheckCursor()
        !            55:  */
        !            56: 
        !            57: #include "Xsun.h"
        !            58: 
        !            59: extern struct pixrect *PixRect;
        !            60: extern char *Xalloc();
        !            61: extern DEVICE *CurrentDevice;
        !            62: CURSOR *CurrentCursor;
        !            63: int CursorDisplayed;
        !            64: static struct pixrect *CursorPixrect;
        !            65: 
        !            66: CURSOR *StoreCursor (func, image, fore, back, mask, xoff, yoff)
        !            67:        BITMAP *image;
        !            68:        BITMAP *mask;
        !            69:        int func, fore, back, xoff, yoff;
        !            70: {
        !            71:     register CURSOR *cursor;
        !            72:     register CursPriv *data;
        !            73: 
        !            74:     if (!image)
        !            75:        return (NULL);
        !            76:     cursor = (CURSOR *) Xalloc(sizeof(CURSOR));
        !            77:     cursor->width = image->width;
        !            78:     cursor->height = image->height;
        !            79:     /* Only the tip need be on-screen */
        !            80:     cursor->xmin = 0;
        !            81:     cursor->ymin = 0;
        !            82:     cursor->xoff = xoff;
        !            83:     cursor->yoff = yoff;
        !            84:     cursor->xmax = PixRect->pr_size.x;
        !            85:     cursor->ymax = PixRect->pr_size.y;
        !            86:     cursor->refcnt = 1;
        !            87:     data = (CursPriv *) Xalloc(sizeof(CursPriv));
        !            88:     cursor->data = (caddr_t) data;
        !            89:     data->top = mem_point(image->width, image->height, 1, image->data);
        !            90:     data->top_bit = image;
        !            91:     image->refcnt++;
        !            92:     if (mask) {
        !            93:        data->bot = mem_point(mask->width, mask->height, 1, mask->data);
        !            94:        data->bot_bit = mask;
        !            95:        mask->refcnt++;
        !            96:     } else {
        !            97:        data->bot = NULL;
        !            98:        data->bot_bit = NULL;
        !            99:     }
        !           100:     data->sv = mem_create(cursor->width, cursor->height, PixRect->pr_depth);
        !           101:     data->fore = fore;
        !           102:     data->back = back;
        !           103:     return (cursor);
        !           104: }
        !           105: 
        !           106: FreeCursor (cursor)
        !           107:        register CURSOR *cursor;
        !           108: {
        !           109:     CursPriv   *cp = CDATA(cursor);
        !           110:     pr_destroy(cp->top);
        !           111:     if (cp->top_bit && --(cp->top_bit)->refcnt <= 0)
        !           112:        FreeBitmap(cp->top_bit);
        !           113:     if (cp->bot) {
        !           114:        pr_destroy(cp->bot);
        !           115:        if (cp->bot_bit && --(cp->bot_bit)->refcnt <= 0)
        !           116:            FreeBitmap(cp->bot_bit);
        !           117:     }
        !           118:     pr_destroy(cp->sv);
        !           119:     free((caddr_t) CDATA(cursor));
        !           120:     free((caddr_t) cursor);
        !           121: }
        !           122: 
        !           123: struct pr_prpos topbatch, botbatch;
        !           124: 
        !           125: LoadCursor (cursor)
        !           126:        register CURSOR *cursor;
        !           127: {
        !           128:     if (CursorDisplayed)
        !           129:        DisplayCursor(NULL);
        !           130:     if ((CurrentCursor = cursor) != NULL) {
        !           131:        topbatch.pr = CDATA(cursor)->top;
        !           132:        topbatch.pos.x = 0;
        !           133:        topbatch.pos.y = 0;
        !           134:        botbatch.pr = CDATA(cursor)->bot;
        !           135:        botbatch.pos.x = 0;
        !           136:        botbatch.pos.y = 0;
        !           137:        DisplayCursor(cursor);
        !           138:     }
        !           139: }
        !           140: 
        !           141: InitMouse ()
        !           142: {
        !           143: }
        !           144: 
        !           145: SetCursorPosition(pos)
        !           146:        register vsCursor *pos;
        !           147: {
        !           148:     if (pos->x != (CurrentDevice->mouse->x) || pos->y != (CurrentDevice->mouse->y)) {
        !           149:        if (CursorDisplayed)
        !           150:            DisplayCursor(NULL);
        !           151:        *(CurrentDevice->mouse) = *pos;
        !           152:        DisplayCursor(CurrentCursor);
        !           153:     }
        !           154: }
        !           155: 
        !           156: SetMouseCharacteristics (threshold, accelaration)
        !           157:        int threshold, accelaration;
        !           158: {
        !           159: }
        !           160: 
        !           161: DisplayCursor(cs)
        !           162: CURSOR *cs;
        !           163: {
        !           164:     extern struct pixrect *PixRect;
        !           165:     vsCursor   *ms = CurrentDevice->mouse;
        !           166: 
        !           167:     if (cs == NULL) {
        !           168:        if (CurrentCursor) {
        !           169:            /* take it out */
        !           170:            extern private_czmask;
        !           171:            int old_zmask = private_czmask, allmask = -1;
        !           172: 
        !           173:            SetZmask(PixRect, &allmask);
        !           174:            pr_rop(PixRect, ms->x, ms->y, CurrentCursor->width,
        !           175:                   CurrentCursor->height, PIX_SRC, CDATA(CurrentCursor)->sv, 0, 0);
        !           176:            SetZmask(PixRect, &old_zmask);
        !           177:            CursorDisplayed = 0;
        !           178:        }
        !           179:     }
        !           180:     else {
        !           181:        CursPriv   *cp = CDATA(cs);
        !           182:        /* put it in */
        !           183: 
        !           184:        pr_rop(cp->sv, 0, 0, cs->width, cs->height, PIX_SRC,
        !           185:               PixRect, ms->x, ms->y);
        !           186:        if (PixRect->pr_depth == 1) {
        !           187:            int botop = (cp->back == 1 ? PIX_SRC | PIX_DST : PIX_NOT(PIX_SRC) & PIX_DST);
        !           188:            int topop = (cp->fore == 1 ? PIX_SRC | PIX_DST : PIX_NOT(PIX_SRC) & PIX_DST);
        !           189: 
        !           190:            if (botbatch.pr)
        !           191:                pr_batchrop(PixRect, ms->x, ms->y,
        !           192:                            botop,
        !           193:                            &botbatch, 1);
        !           194:            if (topbatch.pr)
        !           195:                pr_batchrop(PixRect, ms->x, ms->y,
        !           196:                            topop,
        !           197:                            &topbatch, 1);
        !           198:        }
        !           199:        else {
        !           200:            extern private_bgcolor, private_fgcolor, private_czmask;
        !           201:            int old_zmask = private_czmask;
        !           202: 
        !           203:            private_bgcolor = -1;
        !           204:            private_czmask = -1;
        !           205:            if (botbatch.pr) {
        !           206:                private_fgcolor = cp->back;
        !           207:                pr_batchrop(PixRect, ms->x, ms->y,
        !           208:                            PIX_SRC | PIX_DST,
        !           209:                            &botbatch, 1);
        !           210:            }
        !           211:            private_fgcolor = cp->fore;
        !           212:            if (topbatch.pr)
        !           213:                pr_batchrop(PixRect, ms->x, ms->y,
        !           214:                            PIX_NOT(PIX_SRC) & PIX_DST,
        !           215:                            &topbatch, 1);
        !           216:            private_czmask = old_zmask;
        !           217:        }
        !           218:        CursorDisplayed = 1;
        !           219:     }
        !           220: }
        !           221: 
        !           222: int
        !           223: CheckCursor(x, y, w, h)
        !           224: {
        !           225:     register vsCursor *ms = CurrentDevice->mouse;
        !           226:     register CURSOR *cs = CurrentCursor;
        !           227: 
        !           228:     if (CursorDisplayed
        !           229:        && OverLap(x, y, w, h, ms->x, ms->y, cs->width, cs->height)) {
        !           230:            DisplayCursor(NULL);
        !           231:        }
        !           232: }
        !           233: 
        !           234: RestoreCursor()
        !           235: {
        !           236:     if (!CursorDisplayed)
        !           237:        DisplayCursor(CurrentCursor);
        !           238: }
        !           239: #endif sun

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