Return to cursor.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libvs100

Annotation of 43BSDTahoe/new/X/libvs100/cursor.c, revision 1.1

1.1     ! root        1: /* $Header: cursor.c,v 10.3 86/02/01 15:46:34 tony Rel $ */
        !             2: /* cursor.c    various stuff with the mouse & cursor
        !             3:  *
        !             4:  *     StoreCursor             Creates a cursor
        !             5:  *     FreeCursor              Frees the storage taken by a cursor
        !             6:  *     LoadCursor              Loads a bitmap to use as cursor
        !             7:  *     InitMouse               Initialize the mouse
        !             8:  *     SetCursorPosition       Forces cursor to a particular position
        !             9:  *     SetMouseCharacteristics Controls speed of cursor relative to mouse
        !            10:  *
        !            11:  */
        !            12: 
        !            13: /****************************************************************************
        !            14:  *                                                                         *
        !            15:  *  Copyright (c) 1983, 1984 by                                                    *
        !            16:  *  DIGITAL EQUIPMENT CORPORATION, Maynard, Massachusetts.                 *
        !            17:  *  All rights reserved.                                                   *
        !            18:  *                                                                         *
        !            19:  *  This software is furnished on an as-is basis and may be used and copied *
        !            20:  *  only with inclusion of the above copyright notice. This software or any *
        !            21:  *  other copies thereof may be provided or otherwise made available to     *
        !            22:  *  others only for non-commercial purposes.  No title to or ownership of   *
        !            23:  *  the software is hereby transferred.                                            *
        !            24:  *                                                                         *
        !            25:  *  The information in this software is  subject to change without notice   *
        !            26:  *  and  should  not  be  construed as  a commitment by DIGITAL EQUIPMENT   *
        !            27:  *  CORPORATION.                                                           *
        !            28:  *                                                                         *
        !            29:  *  DIGITAL assumes no responsibility for the use  or  reliability of its   *
        !            30:  *  software on equipment which is not supplied by DIGITAL.                *
        !            31:  *                                                                         *
        !            32:  *                                                                         *
        !            33:  ****************************************************************************/
        !            34: 
        !            35: #include "vs100.h"
        !            36: #include "vsioctl.h"
        !            37: 
        !            38: extern vsIoAddr *VSAddr;
        !            39: extern BitMap screen;
        !            40: extern char FBMap[];
        !            41: 
        !            42: char *Xalloc(), *AllocateSpace();
        !            43: 
        !            44: CURSOR *StoreCursor (func, image, fore, back, mask, xoff, yoff)
        !            45:        register BITMAP *image, *mask;
        !            46:        int func, fore, back, xoff, yoff;
        !            47: {
        !            48:        register CURSOR *cursor;
        !            49:        register CursPriv *data;
        !            50: 
        !            51:        cursor = (CURSOR *) Xalloc (sizeof (CURSOR));
        !            52:        cursor->width = image->width;
        !            53:        cursor->height = image->height;
        !            54:        cursor->xoff = xoff;
        !            55:        cursor->yoff = yoff;
        !            56:        cursor->xmin = xoff;
        !            57:        cursor->ymin = yoff;
        !            58:        cursor->xmax = screen.bm_width - (image->width - xoff);
        !            59:        cursor->ymax = screen.bm_height - (image->height - yoff);
        !            60:        cursor->refcnt = 1;
        !            61:        data = (CursPriv *) Xalloc (sizeof (CursPriv));
        !            62:        data->image = image;
        !            63:        image->refcnt++;
        !            64:        if (data->mask = mask)
        !            65:            mask->refcnt++;
        !            66:        if (fore & 1)
        !            67:            func += 0x20;
        !            68:        if (back & 1)
        !            69:            func += 0x10;
        !            70:        data->map = FBMap[func];
        !            71:        cursor->data = (caddr_t) data;
        !            72:        return (cursor);
        !            73: }
        !            74: 
        !            75: FreeCursor (cursor)
        !            76:        register CURSOR *cursor;
        !            77: {
        !            78:        register CursPriv *data;
        !            79:        register BITMAP *bm;
        !            80: 
        !            81:        data = CDATA(cursor);
        !            82:        if ((bm = data->image) && --bm->refcnt == 0)
        !            83:            FreeBitmap (bm);
        !            84:        if ((bm = data->mask) && --bm->refcnt == 0)
        !            85:            FreeBitmap (bm);
        !            86:        free ((caddr_t) cursor);
        !            87: }
        !            88: 
        !            89: LoadCursor (cursor)
        !            90:        register CURSOR *cursor;
        !            91: {
        !            92:        register CursPriv *data;
        !            93:        register BITMAP *bm;
        !            94:        register LoadCursorPacket *lcp;
        !            95: 
        !            96:        lcp = (LoadCursorPacket *) AllocateSpace (sizeof (LoadCursorPacket));
        !            97:        if (lcp == NULL) return;
        !            98: #define h ((PacketHeader *) lcp->lcp_head)
        !            99: #define src ((SubBitmap *) lcp->lcp_source.image)
        !           100: #define msk ((SubBitmap *) lcp->lcp_sourceMask)
        !           101: #define pat ((Halftone *) lcp->lcp_source.pattern)
        !           102: #define        size ((Extent *) lcp->lcp_maskSize)
        !           103: 
        !           104:        data = CDATA(cursor);
        !           105:        h->ph_cursorMod.m_source = 1;
        !           106:        h->ph_cursorMod.m_map = MAPTYPE(data->map);
        !           107:        h->ph_opcode = LOAD_CURSOR;
        !           108:        *(long *) h->ph_next = NULL;
        !           109: 
        !           110:        bm = data->image;
        !           111:        *(caddr_t *) src->sb_address = BDATA(bm)->vsPtr;
        !           112:        src->sb_height = bm->height;
        !           113:        src->sb_width = bm->width;
        !           114:        src->sb_bitsPerPixel = 1;
        !           115:        src->sb_x = src->sb_y = 0;
        !           116:        size->e_height = bm->height;
        !           117:        size->e_width = bm->width;
        !           118: 
        !           119:        if (bm = data->mask) {
        !           120:            h->ph_cursorMod.m_mask = 1;
        !           121:            *(caddr_t *) msk->sb_address = BDATA(bm)->vsPtr;
        !           122:            msk->sb_height = bm->height;
        !           123:            msk->sb_width = bm->width;
        !           124:            msk->sb_bitsPerPixel = 1;
        !           125:            msk->sb_x = msk->sb_y = 0;
        !           126:        } else
        !           127:            h->ph_cursorMod.m_mask = 0;
        !           128:        *(short *) lcp->lcp_map.literal = MAPLIT(data->map);
        !           129: 
        !           130:        lcp->lcp_blink = 0;
        !           131:        lcp->lcp_tip_x = cursor->xoff;
        !           132:        lcp->lcp_tip_y = cursor->yoff;
        !           133:        lcp->lcp_center_x = cursor->xoff;
        !           134:        lcp->lcp_center_y = cursor->yoff;
        !           135: 
        !           136:        WritePacket ((caddr_t) lcp);
        !           137: #undef h
        !           138: #undef src
        !           139: #undef msk
        !           140: #undef pat
        !           141: #undef size
        !           142: }
        !           143: 
        !           144: InitMouse ()
        !           145: {
        !           146:        register AttachCursorPacket *acp;
        !           147:        register SetPointingDeviceReportingPacket *spdp;
        !           148: 
        !           149:        acp = (AttachCursorPacket *) AllocateSpace (sizeof (AttachCursorPacket));
        !           150:        if (acp == NULL) return;
        !           151: #define h ((PacketHeader *) acp->acp_head)
        !           152: 
        !           153:        h->ph_modifier.emptymod = 0;
        !           154:        h->ph_opcode = ATTACH_CURSOR;
        !           155:        *(long *) h->ph_next = NULL;
        !           156: 
        !           157:        acp->acp_device = 1;
        !           158: 
        !           159:        WritePacket ((caddr_t) acp);
        !           160: #undef h
        !           161: 
        !           162:        spdp = (SetPointingDeviceReportingPacket *) AllocateSpace (sizeof (SetPointingDeviceReportingPacket));
        !           163:        if (spdp == NULL) return;
        !           164: #define h ((PacketHeader *) spdp->spdp_head)
        !           165: 
        !           166:        h->ph_modifier.emptymod = 0;
        !           167:        h->ph_opcode = SET_POINTING_DEVICE_REPORTING;
        !           168:        *(long *) h->ph_next = NULL;
        !           169: 
        !           170:        spdp->spdp_enable = 1;
        !           171: 
        !           172:        WritePacket ((caddr_t) spdp);
        !           173: #undef h
        !           174: }
        !           175: 
        !           176: SetCursorPosition(pos)
        !           177:        register vsCursor *pos;
        !           178: {
        !           179:        register SetCursorPositionPacket *scp;
        !           180: 
        !           181:        scp = (SetCursorPositionPacket *) AllocateSpace (sizeof (SetCursorPositionPacket));
        !           182:        if (scp == NULL) return;
        !           183: #define h ((PacketHeader *) scp->scp_head)
        !           184: #define loc ((Point *) scp->scp_position)
        !           185: 
        !           186:        h->ph_modifier.emptymod = 0;
        !           187:        h->ph_opcode = SET_CURSOR_POSITION;
        !           188:        *(long *) h->ph_next = NULL;
        !           189: 
        !           190:        loc->p_x = pos->x;
        !           191:        loc->p_y = pos->y;
        !           192: 
        !           193:        WritePacket ((caddr_t) scp);
        !           194:        VSAddr->mouse = *pos;
        !           195: #undef h
        !           196: #undef loc
        !           197: }
        !           198: 
        !           199: SetMouseCharacteristics (threshold, acceleration)
        !           200:        int threshold, acceleration;
        !           201: {
        !           202:        register SetMouseCharacteristicsPacket *smp;
        !           203: 
        !           204:        smp = (SetMouseCharacteristicsPacket *) AllocateSpace (sizeof (SetMouseCharacteristicsPacket));
        !           205:        if (smp == NULL) return;
        !           206: #define h ((PacketHeader *) smp->smc_head)
        !           207: 
        !           208:        h->ph_mouseMod.m_tracking = 1;
        !           209:        h->ph_opcode = SET_MOUSE_CHARACTERISTICS;
        !           210:        *(long *) h->ph_next = NULL;
        !           211: 
        !           212:        smp->smc_scale = acceleration;
        !           213:        smp->smc_threshold = threshold;
        !           214: 
        !           215:        WritePacket ((caddr_t) smp);
        !           216: #undef h
        !           217: }

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