Macintosh-SW/supermario
1
0
Fork 0
mirror of https://github.com/elliotnunn/supermario.git synced 2024-11-22 19:31:02 +00:00
Code Issues Projects Releases Wiki Activity
4b6e398c8a
supermario/base/SuperMarioProj.1994-02-09/OS/CrsrDev.a
Elliot Nunn 2e16381318 Bring in sources, and document
2019-06-29 23:17:50 +08:00

2346 lines
77 KiB
Plaintext
Raw Blame History

;———————————————————————————————————————————————————————————————————————————————————————
;
; File: CrsrDev.a
;
; Contains: This file holds the new cursor device implementation, including new mouse
; /trackball handler and the new acceleration routines for jCrsrTask.
;
; Written by: Gary Rensberger (based on Dan Venolia's Cursory API) [11/20/91]
;
; Copyright: © 1991-1993 by Apple Computer, Inc. All rights reserved.
;
; Change History (most recent first):
;
; <SM7> 5/28/93 IH Add comment about Display Mgr usage of CrsrNew.
; <SM6> 12/01/92 HY Fix a bug with uncoupled cursors(fixes MS Flight Simulator v4.0).
; Fixed a cursor flicker problem on slower machines like LC930. The
; cursor is drawn prior to calculating new positions of devices. The
; calculations were using up all the available VBL time, causing the
; flicker (cursor is drawn every other VBL, and calculations performed
; every other VBL).
; <SM5> 8/26/92 kc Roll in Horror changes.
; <H18> 7/24/92 GMR Fixed comaptibility problem with Hypercard/MacPaint Grid drawing
; mode (Atkinsons MouseMask secret).
; <H17> 7/17/92 GMR Changed the double-click translation table to match the Mouse
; CDEVs double-click times.
; <H16> 7/14/92 GMR Reset MBState to button up in CrsrDevReInit code.
; <H15> 7/13/92 djw <GED> Added code in InitCrsrDev to initialize vectors for:
; DrawCursor, EraseCursor, the @drawCursor section of the new VBL,
; and a hook for SetCrsrData. Also added default vector code for
; the above.
; <H14> 7/13/92 GMR Re-arranged the initialization routine so that our expandmem
; globals are created before InitADB, then InitADB is called.
; Update MBTicks when a button goes down, since Andy looks at it
; (shame on you!).
; <H13> 7/6/92 GMR Update doubleTime lowmem when creating a new device.
; <H12> 6/29/92 BG Changed AERROR message in the overpatching check at the bottom
; of the file to refer to the correct file being too big (you're
; welcome, Steve).
; <H11> 6/26/92 GMR <SKH> Modified CrsrDevHandleADB to handle extended device data,
; ie: more than 2 buttons and up to 16bit resolution. Changed
; CrsrNewDevice to properly init cntButtons (it was moving a word
; into cntButtons). Changed CrsrDevSetAccel to enter the debugger
; if no 'accl' resources do not exist.
; <H10> 6/10/92 GMR Fixed bug with buttonCount not being reset after waking up from
; sleep.
; <H9> 6/5/92 GMR Changed the movem's in the trap selector dispatcher to be
; movem.l.
; <H8> 6/1/92 GMR Removed the extra 'default' device created for address 3, since
; testers complained. Now, if a second mouse (or 1st mouse on
; portables) is added while the machine is running, it's
; acceleration won't be correct. Tough shit).
; <H7> 5/12/92 JC Fixed problem with CrsrDevHandleVBL trashing registers.
; <H6> 4/3/92 SWC Added overpatch padding at the end of the file.
; <H5> 3/11/92 SWC <GMR> Setup so second trackball button will behave just like the first
; one. Exported CrsrDevDispatch now that we have a trap for it.
; <H4> 3/9/92 SWC <GMR> Fixed bug in CrsrDevSetAccel where the acceleration to set
; <SM4> 7/30/92 fau Made the MOVEM instructions in CrsrDevDispatch and StdExit be a
; MOVEM.L. This fixes a bug in the Mouse cdev in Cyclone where
; the MOVEM was assembled to a MOVEM.W which sign-extends to 32
; bits when writing back to a register!.
; <SM3> 7/7/92 CSS Change name of include from ApplDeskBusPriv.a to
; AppleDeskBusPriv.a to bring in line with Reality.
; The file "ApplDeskBusPriv.a" was inadvertently
; brought in from Horror.
; <SM2> 5/29/92 KW (JC,H7) Fixed problem with CrsrDevHandleVBL trashing registers.
; <SM1> 5/2/92 kc Roll in Horror. Comments follow:
; <H6> 4/3/92 SWC Added overpatch padding at the end of the file.
; <H5> 3/11/92 SWC Setup so second trackball button will behave just like the first
; one. Exported CrsrDevDispatch now that we have a trap for it.
; <H4> 3/9/92 SWC GMR/Fixed bug in CrsrDevSetAccel where the acceleration to set
; is 0. Added more compatiblity code to jCrsrTask so the VU test
; tool will work. Setup address 3 to be a default device with 100
; dpi resolution, so if a user unplugs then plugs in a mouse, it
; will work.
; <H3> 2/17/92 SWC Used different registers in FindResource since the _GetResource
; call can trash D0-D2. Changed references to CrsrDevRec.resolution
; to a long since it's a fixed point number.
; <H2> 2/14/92 SWC Added a RomMapInsert before all resource calls so we make sure
; we at least find our resources in the ROM.
; <H1> 2/12/92 GMR First checked in.
;———————————————————————————————————————————————————————————————————————————————————————
PRINT OFF
LOAD 'StandardEqu.d'
INCLUDE 'EgretEqu.a'
INCLUDE 'IOPEqu.a'
INCLUDE 'AppleDeskBusPriv.a'
INCLUDE 'CrsrDevEqu.a'
PRINT ON
MACHINE MC68020
_FixDiv OPWORD $A84D
CrsrDev PROC
EXPORT InitCrsrDev,CrsrDevDispatch
IMPORT CrsrVBLTask
WITH CrsrDevGlobals, CrsrDevRec, CrsrDevSegment, CrsrDataRec
WITH ADBDeviceEntry, ADBVars, ExpandMemRec
_______________________________________________________________________
;
; Routine: CrsrDevDispatch (trap # $AADB)
;
; Inputs: d0.w - selector
; 4(sp) - last parameter
; 8(sp) - 2nd to last parameter
;
; Outputs: d0 - result code
;
; Destroys: a0
;
; Function: This routine is our selector based dispatcher for the exported
; CrsrDev routines. It follows toolbox conventions (e.g. parameters
; are passed in on the stack, with the function selector in D0).
;_______________________________________________________________________
CrsrDevDispatch
link a6,#0 ; parameters referenced off a6
movem.l a1-a3/d1-d3,-(sp) ; save a bunch of registers
add.w d0,d0 ; (shift so we work on 68000's)
lea @jmpTable,a0 ; point to our jump table
adda.w (a0,d0.w),a0 ; add offset to routine
jmp (a0) ; jump to selected routine
;-------------------------------
@jmpTable dc.w CrsrDevMoveTrap- @jmpTable ; Selector 0
dc.w CrsrDevMoveToTrap- @jmpTable ; 1
dc.w CrsrDevFlushTrap- @jmpTable ; 2
dc.w CrsrDevButtonsTrap- @jmpTable ; 3
dc.w CrsrDevButtonDownTrap- @jmpTable ; 4
dc.w CrsrDevButtonUpTrap- @jmpTable ; 5
dc.w CrsrDevButtonOpTrap- @jmpTable ; 6
dc.w CrsrDevSetButtonsTrap- @jmpTable ; 7
dc.w CrsrDevSetAccelTrap- @jmpTable ; 8
dc.w CrsrDevDoubleTimeTrap- @jmpTable ; 9
dc.w CrsrDevSetUnitsPerInchTrap- @jmpTable ; 10
dc.w CrsrDevNextDeviceTrap- @jmpTable ; 11
dc.w CrsrDevNewDeviceTrap- @jmpTable ; 12
dc.w CrsrDevDisposeDevTrap- @jmpTable ; 13
;-------------------------------
stdExit movem.l (sp)+,a1-a3/d1-d3 ; restore registers
unlk a6
move.l (sp)+,a0
add.w d0,sp ; dump parameters
jmp (a0)
userFrame RECORD 0,increment
saveA6 ds.l 1
returnAddr ds.l 1
paramBase equ * ; ptr to base of parameters
ENDR
WITH userFrame
;====================================================================
;
; Routine: CrsrDevMoveTrap
;
; Inputs: 8(a6).l - delta Y
; 12(a6).l - delta X
; 16(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: d1-d2,a1-a2
;
; Function: This routine accumulates given deltas for crsrDev, and
; flags that is has new data. The next time the cursor position
; is computed, dh and dv will be run through the acceleration
; algorithm and will contribute to the cursor movement.
;====================================================================
CrsrDevMoveTrap
move.l paramBase(a6),d1 ; ∆y in d1
move.l paramBase+4(a6),d0 ; ∆x in d0
move.l paramBase+8(a6),a2 ; crsrDevRec in a2
bsr CrsrDevMove ; accumulate the deltas
move.w d0,paramBase+12(a6) ; result code
moveq #12,d0 ; dump three parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevMoveToTrap
;
; Inputs: 8(a6).l - V
; 12(a6).l - H
; 16(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: d1,a1-a2
;
; Function: This routine transforms the coordinates (h,v) to screen
; space so that the next time the cursor position is computed
; it jumps to that point and any relative movement will be ignored.
;====================================================================
CrsrDevMoveToTrap
move.l paramBase+8(a6),a2 ; crsrDevRec in a2
move.l whichCursor(a2),a1 ; a1 pts to cursor globals
moveq #0,d0
move.l paramBase(a6),d0 ; get V coord
swap d0 ; convert to fixed
move.l d0,whereY(a1) ; = whereY
moveq #0,d0
move.l paramBase+4(a6),d0 ; get H coord
swap d0 ; convert to fixed
move.l d0,whereX(a1) ; = whereX
st.b isAbs(a1) ; absolute mode
clr.w paramBase+12(a6) ; result code
moveq #12,d0 ; dump three parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevFlushTrap
;
; Inputs: 8(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2
;
; Function: This routine explicitly ends the relative device move,
; flushing out the error accumulators.
;====================================================================
CrsrDevFlushTrap
move.l paramBase(a6),a2 ; crsrDevRec in a2
move.l errorX(a2),d0 ; accumulate previous errors into
add.l d0,deltaX(a2) ; our deltas
move.l errorY(a2),d0
add.l d0,deltaY(a2)
clr.l errorX(a2) ; then flush the errors
clr.l errorY(a2)
move.w #-108,denom(a2) ; ???
clr.w paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevButtonsTrap
;
; Inputs: 8(a6).w - new button states (1 = down, 0 = up)
; 10(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a2,d1-d3
;
; Function: This routine handles button debounce and event posting. If the
; mouse button bounces, we don't want it to look like a double click,
; so if we see a mouse down less than 2 VBLs after a mouse up, we will
; ignore it, and consider the mouse to still be up. We will never
; ignore a mouse up event, which could lead to menus hanging and
; continuous scrolling.
;====================================================================
CrsrDevButtonsTrap
move.w paramBase(a6),d0 ; button states in d0
move.l paramBase+2(a6),a2 ; crsrDevRec in a2
bsr CrsrDevButtons ; handle button debounce/actions
move.w d0,paramBase+6(a6) ; result code
moveq #6,d0 ; dump two parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevButtonDownTrap
;
; Inputs: 8(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a2,d1
;
; Function: Posts a button down event if this is the 1st button to go down
;====================================================================
CrsrDevButtonDownTrap
move.l paramBase(a6),a2 ; crsrDevRec in a2
bsr CrsrDevButtonDown ; handle button down actions
move.w d0,paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevButtonUpTrap
;
; Inputs: 8(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a2,d1
;
; Function: Posts a button up event if this is the last button to go up.
;====================================================================
CrsrDevButtonUpTrap
move.l paramBase(a6),a2 ; crsrDevRec in a2
bsr CrsrDevButtonUp ; handle button up actions
move.w d0,paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevButtonOpTrap
;
; Inputs: 8(a6).l - Operation specific data
; 12(a6).w - Operation code
; 14(a6).w - Button #
; 16(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2,d1-d2
;
; Function: This routine sets a new operation to be associated with the
; given button. The optional data field is set as well.
;====================================================================
CrsrDevButtonOpTrap
move.w paramBase+6(a6),d0 ; button # in d0
move.l paramBase+8(a6),a2 ; crsrDevRec in a2
move.b paramBase+5(a6),buttonOp(a2,d0.w) ; stuff the new operation code
lsl.w #2,d0
move.l paramBase(a6),buttonData(a2,d0.w) ; and the new data (if any)
clr.w paramBase+12(a6) ; result code
moveq #12,d0 ; dump four parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevSetButtonsTrap
;
; Inputs: 8(a6).w - # buttons for this device
; 10(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2
;
; Function: This routine sets the total # of buttons for the given
; device.
;====================================================================
CrsrDevSetButtonsTrap
move.l paramBase+2(a6),a2 ; crsrDevRec in a2
move.b paramBase+1(a6),cntButtons(a2) ; only use a byte of the word
clr.w paramBase+6(a6) ; result code
moveq #6,d0 ; dump two parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevSetAccelTrap
;
; Inputs: 8(a6).l - acceleration (Fixed)
; 12(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2,d1-d2
;
; Function: This routine installs the proper acceleration table for
; the specified device, based on the passed in acceleration
; value.
;====================================================================
CrsrDevSetAccelTrap
move.l paramBase(a6),d0 ; acceleration
move.l paramBase+4(a6),a2 ; crsrDevRec in a2
bsr CrsrDevSetAccel ; generate acceleration table
move.w d0,paramBase+8(a6) ; result code
moveq #8,d0 ; dump two parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevDoubleTimeTrap
;
; Inputs: 8(a6).l - duration (ticks)
; 12(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2
;
; Function: This routine changes the double-click time for crsrDev to
; the indicated value. When crsrDev is clicked, it's double-
; click time is stuffed into the low-memory global DoubleTime.
; An application responding to the mouse-down event can check
; DoubleTime to determine whether to interpret a double-click.
;====================================================================
CrsrDevDoubleTimeTrap
move.l paramBase+4(a6),a2 ; crsrDevRec in a2
move.l paramBase(a6),doubleClickTime(a2) ; stuff the new value
move.w #0,paramBase+8(a6) ; result code
moveq #8,d0 ; dump two parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevSetUnitsPerInchTrap
;
; Inputs: 8(a6).l - resolution (fixed)
; 12(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a2
;
; Function: May be called if the software knows more about the resolution
; of the device than can be found from the ADB bus, e.g. for a
; serial device. Calls CrsrDevSetAcceleration (with the current
; accel value) to recompute the acceleration tables for the device,
; so the resource file that contains the 'accl' resource should be
; open.
;====================================================================
CrsrDevSetUnitsPerInchTrap
move.l paramBase+4(a6),a2 ; crsrDevRec in a2
move.l paramBase(a6),resolution(a2) ; set new resolution for this device
move.l acceleration(a2),d0 ; get current acceleration
bsr CrsrDevSetAccel ; generate acceleration table, based on new resolution
move.w #0,paramBase+8(a6) ; result code
moveq #8,d0 ; dump two parameters on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevNextDeviceTrap
;
; Inputs: 8(a6).l - VAR ptr to CrsrDevRec
;
; Outputs: d0 - OSErr
;
; Destroys: none
;
; Function: When given NIL, returns the head of the global device list.
; When given a pointer to a cursor device reocrd, returns a
; pointer to the next one in the global device list.
;====================================================================
CrsrDevNextDeviceTrap
move.l paramBase(a6),a2 ; address of crsrDevRec ptr in a2
move.l (a2),a2 ; crsrDevRec ptr in a2
move.l a2,d0
beq.s @nil ; if NIL, special case
move.l nextCrsrDev(a2),a2 ; else, get next link
bra.s @exit
@nil movea.l ExpandMem,a2 ; get ptr to expandmem rec
movea.l emCursorGlobals(a2),a2 ; get cursory global ptr
move.l firstCrsrDev(a2),a2 ; get ptr to 1st CrsrDevRec
@exit move.l paramBase(a6),a0 ; get address of where to store crsrDevRec
move.l a2,(a0) ; return next crsrDevRec
move.w #0,paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevNewDeviceTrap
;
; Inputs: 8(a6).l - VAR pointer to CrsrDevRec
;
; Outputs: d0 - OSErr
;
; Destroys: none
;
; Function: This routine creates a new CrsrDevRec, adds it to the
; linked list of device records, and initializes it's fields.
; Note: the caller must call CrsrDevSetAcceleration after
; calling this routine.
;====================================================================
CrsrDevNewDeviceTrap
bsr CrsrDevNewDevice ; create a new cursor device
move.l paramBase(a6),a0 ; address of crsrDevRec ptr in a2
move.l a2,(a0) ; return crsrDevRec pointer
move.w d0,paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
;====================================================================
;
; Routine: CrsrDevDisposeDevTrap
;
; Inputs: 8(a6).l - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: d1-d2,a0-a1
;
; Function: This routine eliminates CrsrDevRec from the linked list
; of device records, and disposes of all storage related to
; it.
;====================================================================
CrsrDevDisposeDevTrap
move.l paramBase(a6),a2 ; crsrDevRec in a2
bsr CrsrDevDisposeDev ; create a new cursor device
move.w d0,paramBase+4(a6) ; result code
moveq #4,d0 ; dump one parameter on exit
jmp stdExit ;
ENDWITH
;_______________________________________________________________________
;
; Routine: CrsrDevHandleADB
;
; Inputs: a0 - pointer to mouse data
; a2 - pointer to CrsrDevRec for this device
; d0 - command byte
;
; Outputs: -
;
; Destroys: a0-a3/d0-d3
;
; Function: This routine is installed as the ADB service routine for all
; ADDR=03 relative devices. It decodes the ADB packet and
; passes the information to CrsrDevMove and CrsrDevButtons.
; This routine now handles old or new style packets.
;
; The packet has the following format:
; Byte# bits: 7 6 5 4 3 2 1 0
; 0 b0 y6 y5 y4 y3 y2 y1 y0
; 1 b1 x6 x5 x4 x3 x2 x1 x0
; 2 b2 y9 y8 y7 b3 x9 x8 x7 (optional) <H11>
; 3 b4 y12 y11 y10 b5 x12 x11 x10 (optional) <H11>
; 4 b6 y15 y14 y13 b7 x15 x14 x13 (optional) <H11>
;
; Where bn is button n (1 = not pressed, 0 = pressed)
; xn is bit n of the x delta information
; yn is bit n of the y delta information
;
; NOTE: The current approach for extracting the extended
; resolution information is kinda ugly. However, it is
; fast and I have been unable to construct an efficent, general,
; function for extracting the awkward 3bit fields in bytes 2 through
; n (currently n is 4). - SKH
;
;_______________________________________________________________________
CrsrDevHandleADB
move.b d0,d2 ; save command in D2.
move.l a2,d0 ; do we have globals?
beq @exit ; no, exit
lea 1(a0),a3 ; skip over length byte, free up A0
@x0to6 moveq.l #$7F,d0 ; prepare to mask button off
and.b 1(a3),d0 ; get 2nd data byte (∆ horiz)
@y0to6 moveq.l #$7F,d1 ; prepare to mask off button
and.b (a3),d1 ; get 1st data byte (∆ vert)
@byte3 cmp.b #3,(a0) ; check to see if we have 3rd byte <H11>
bge.s @x7to9 ; if so, process it. else, extend sign <H11>
@byte3extx btst #6,d0 ; check sign bit (bit 6) <H11>
beq.s @byte3exty ; <H11>
or.w #$ff80,d0 ; fake a negative, faster than ext <H11>
@byte3exty btst #6,d1 ; check sign bit (bit 6) <H11>
beq @domove ; <H11>
or.w #$ff80,d1 ; fake a negative for y <H11>
bra.s @domove ; <H11>
@x7to9 moveq.l #$7,d2 ; move mask into workspace <H11>
and.b 2(a3),d2 ; get x bits 7-9 <H11>
lsl.w #7,d2 ; move them to add to running tally <H11>
or.w d2,d0 ; <H11>
@y7to9 moveq.l #$70,d2 ; mask the bits <H11>
and.b 2(a3),d2 ; get y bits 7-9 <H11>
lsl.w #3,d2 ; move and add to tally <H11>
or.w d2,d1 ; <H11>
@byte4 cmp.b #4,(a0) ; check to see if we have a 4th byte <H11>
bge.s @x10to12 ; <H11>
@byte4extx btst #9,d0 ; check sign bit (bit 9) <H11>
beq.s @byte4exty ; <H11>
or.w #$fc00,d0 ; fake a negative for x <H11>
@byte4exty btst #9,d1 ; check sign bit (bit 9) <H11>
beq.s @domove ; <H11>
or.w #$fc00,d1 ; fake a negative for y <H11>
bra.s @domove ; <H11>
@x10to12 moveq.l #$7,d2 ; move mask into workspace <H11>
and.b 3(a3),d2 ; get x bits 10-12 <H11>
lsl.w #8,d2 ; move them to add to running tally <H11>
lsl.w #2,d2 ; do a 10 bit shift <H11>
or.w d2,d0 ; <H11>
@y10to12 moveq.l #$70,d2 ; mask the bits <H11>
and.b 3(a3),d2 ; get y bits 10-12 <H11>
lsl.w #6,d2 ; move and add to tally <H11>
or.w d2,d1 ; <H11>
@byte5 cmp.b #5,(a0) ; check to see if we have a 5th byte <H11>
bge.s @x13to15 ; <H11>
@byte5extx btst #12,d0 ; check sign bit (bit 12) <H11>
beq.s @byte5exty ; <H11>
or.w #$e000,d0 ; fake a negative for x <H11>
@byte5exty btst #12,d1 ; check sign bit (bit 12) <H11>
beq.s @domove ; <H11>
or.w #$e000,d1 ; fake a negative for y <H11>
bra.s @domove ;
@x13to15 moveq.l #$7,d2 ; move mask into workspace <H11>
and.b 4(a3),d2 ; get x bits 13-15 <H11>
lsl.w #8,d2 ; move them to add to running tally <H11>
lsl.w #5,d2 ; do a 13 bit shift <H11>
or.w d2,d0 ; <H11>
@y13to15 moveq.l #$70,d2 ; mask the bits <H11>
and.b 4(a3),d2 ; get y bits 13-15 <H11>
lsl.w #8,d2 ; move and add to tally <H11>
lsl.w #1,d2 ; do a 9 bit shift <H11>
or.w d2,d1 ; <H11>
@domove ext.l d0 ; convert our words into longs
ext.l d1 ;
bsr.s CrsrDevMove ; accumulate movement
clr.l d0 ; assume all buttons up <H11>
@btn0 clr.l d1 ; start looking at button 0 <H11>
btst.b #7,(a3)+ ; is 1st button up? <H11>
bne.s @btn1 ; yes, check 2nd button <H11>
bset d1,d0 ; no, indicate button down <H11>
@btn1 addq.b #1,d1 ; go to the next button (button 1) <H11>
btst.b #7,(a3)+ ; is 2nd button up? <H11>
bne.s @btnn ; yes, handle all button states <H11>
bset d1,d0 ; no, indicate button down <H11>
@btnn
addq.b #1,d1 ; go to the next button <H11>
cmp.b cntButtons(a2),d1 ; compare current button number to num buttons <H11>
bge.s @setBtns ; set the buttons if we are done <H11>
btst.b #7,(a3) ; check the button for the high nibble <H11>
bne.s @btnn_high ; not pressed, check high nibble <H11>
bset d1,d0 ; record the press <H11>
@btnn_high addq.b #1,d1 ; other button in low nibble <H11>
btst.b #3,(a3)+ ; the button for this nibble <H11>
bne.s @btnn ; loop again <H11>
bset d1,d0 ; record the press <H11>
bra.s @btnn ; <H11>
@setBtns bsr CrsrDevButtons ; handle our buttons
@exit
rts
;_______________________________________________________________________
;
; Routine: CrsrDevMove
;
; Inputs: d0.l - delta X
; d1.l - delta Y
; a2 - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a1,d0-d2
;
; Function: This routine accumulates given deltas for crsrDev, and
; flags that is has new data. The next time the cursor position
; is computed, dh and dv will be run through the acceleration
; algorithm and will contribute to the cursor movement.
;_______________________________________________________________________
tempParams RECORD 0,decrement
tempY ds.l 1 ; delta Y
tempX ds.l 1 ; delta X
tempSize EQU * ; size of our param block
ENDR
CrsrDevMove
WITH tempParams
link a6,#tempSize ; create temp area
tst.l d0 ; and X movement?
bne.s @cont ; yes, continue
tst.l d1 ; and Y movement?
beq @exit ; no, just exit
@cont move.l d0,tempX(a6) ; save delta X
move.l d1,tempY(a6) ; save delta Y
swap d0 ; word2Fix
clr.w d0
move.l d0,-(sp) ; convert delta X to Fixed (push on stack)
swap d1 ; word2Fix
clr.w d1
move.l d1,-(sp) ; convert delta Y to Fixed (push on stack)
tst.b newData(a2) ; was the previous poll after last VBL?
bne.s @accum ; yes, handle separately
move.l (sp)+,deltaY(a2) ; else, save it away
move.l (sp)+,deltaX(a2) ;
st.b newData(a2) ; indicate we have new data
bra.s @checkDir ; and see if direction changed
@accum move.l (sp)+,d0
add.l d0,errorY(a2) ; accumulate error y
move.l (sp)+,d0
add.l d0,errorX(a2) ; accumulate error x
move.w spread(a2),d0 ; adjust the length of the double-sample time
sub.w denom(a2),d0 ; this spread = old spread - denom
cmpi.w #30,d0
bge.s @spread ; skip if new spread >= 30
add.w d0,spread(a2) ; if new spread < 30 then
addq.w #1,spread(a2)
lsr.w spread(a2) ; spread := (spread + old spread + 1) / 2
@spread moveq #8,d0 ; else, spread out error over next several VBL's
move.w spread(a2),denom(a2)
cmp.w denom(a2),d0 ; clip demon to 0-8
bge.s @checkDir ;
move.w d0,denom(a2)
@checkDir move.l tempY(a6),d0 ; any dy?
beq.s @chkXchg ; no, check X
move.l errorY(a2),d1
eor.l d1,d0 ; yes, did it's direction change?
bpl.s @chkXchg ; no, check X
add.l d1,deltaY(a2) ; direction changed, adjust delta
clr.l errorY(a2) ; and stomp the error
@chkXchg move.l tempX(a6),d0 ; any dx?
beq.s @exit ; no, exit
move.l errorX(a2),d1
eor.l d1,d0 ; yes, did it's direction change?
bpl.s @exit ; no, exit
add.l d1,deltaX(a2) ; direction changed, adjust delta
clr.l errorX(a2) ; and stomp the error
@exit unlk a6
moveq #0,d0 ; result code
rts
ENDWITH
;_______________________________________________________________________
;
; Routine: CrsrDevButtons
;
; Inputs: d0.b - new button states (1 = down, 0 = up)
; a2 - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a1,d1-d3
;
; Function: This routine handles button debounce and event posting. If the
; mouse button bounces, we don't want it to look like a double click, so if we
; see a mouse down less than 2 VBLs after a mouse up, we will ignore it, and
; consider the mouse to still be up. We will never ignore a mouse up event,
; which could lead to menus hanging and continuous scrolling.
;_______________________________________________________________________
CrsrDevButtons
move.b d0,d1 ; get current button(s) state in d1
moveq #8-1,d3 ; init our button counter...
@loop btst.l d3,d1 ; check next current button state
beq.s @nowUp ; branch if up
@nowDwn btst.b d3,buttons(a2) ; down now, was it down before?
bne.s @nextButton ; yes, do nothing, handle next button
move.l Ticks,d0
move.w d3,d2 ;
lsl.w #2,d2 ;
sub.l buttonTicks(a2,d2.w),d0 ;
add.l d0,RndSeed ; randomize our seed
subq.l #2,d0
bmi.s @nextButton ; exit if went down too quickly (bounce)
bset.b d3,buttons(a2) ; mark that we're really down...
bra.s @dispatch ; and handle the down event
@nowUp btst.b d3,buttons(a2) ; was it up before?
beq.s @nextButton ; yes, do nothing, handle next button
move.w d3,d2 ;
lsl.w #2,d2 ;
move.l Ticks,buttonTicks(a2,d2.w) ; time-stamp the button-up event
bclr.b d3,buttons(a2) ; mark that we're up
* bra.s @dispatch ; and handle the down event
@dispatch move.b buttonOp(a2,d3.w),d0 ; get the button operation in d0
ext.w d0
add.w d0,d0 ; button op * 2 (need to run on 68000)
lea @jmpTable,a0
adda.w (a0,d0.w),a0 ; base + offset = rtn address
jsr (a0) ; handle button (d3 = button#, a2 = CrsrDevRec)
; • routine must preserve d1 •
@nextButton dbra d3,@loop
moveq #0,d0 ; result code
rts ; we're done
;---------------------------------------------------------
@jmpTable dc.w doNop - @jmpTable ;
dc.w doSingle - @jmpTable ;
dc.w doDouble - @jmpTable ;
dc.w doClickLock - @jmpTable ;
dc.w d0CharStroke - @jmpTable ;
dc.w doAppleScript - @jmpTable ;
dc.w doCustom - @jmpTable ;
doNop rts
;---------------------------------------------------------
doSingle
btst.b d3,buttons(a2) ; are we down?
beq.s @up ; no, skip
bsr.s CrsrDevButtonDown ; yes, handle button down
bra.s @done
@up bsr CrsrDevButtonUp ; yes, handle button up
@done rts
;---------------------------------------------------------
doDouble
btst.b d3,buttons(a2) ; are we down?
beq.s @up ; no, skip
bsr.s CrsrDevButtonDown ; yes, generate 2 clicks
bsr.s CrsrDevButtonUp ;
bsr.s CrsrDevButtonDown ;
bra.s @done
@up bsr.s CrsrDevButtonUp ; and finally button up
@done rts
;---------------------------------------------------------
doClickLock
tst.b buttonData(a2,d3.w) ; is this the 1st time?
bne.s @secondHit ; no, skip
btst.b d3,buttons(a2) ; are we down?
beq.s @firstUp ; no, skip
bsr.s CrsrDevButtonDown ; yes, generate button down event
bra.s @done
@firstUp st.b buttonData(a2,d3.w) ; first up, mark it
bra.s @done
@secondHit btst.b d3,buttons(a2) ; are we up (2nd time)?
bne.s @done ; no, do nothing...
bsr.s CrsrDevButtonUp ; yes, post up event
clr.b buttonData(a2,d3.w) ; mark that we're really up
@done rts
;---------------------------------------------------------
d0CharStroke
rts
;---------------------------------------------------------
doAppleScript
rts
;---------------------------------------------------------
doCustom
pea buttonData(a2) ; push our custom routine address
rts ; and call it.
;_______________________________________________________________________
;
; Routine: CrsrDevButtonDown
;
; Inputs: a2 - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a1,d0
;
; Function: Posts a button down event if this is the 1st button to go down
;_______________________________________________________________________
CrsrDevButtonDown
move.l whichCursor(a2),a1 ; get ptr to target cursor data
movea.l ExpandMem,a0 ; get ptr to expandmem rec
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr
move.l firstCrsrData(a0),a0 ; a0 points to main cursor data record
cmpa.l a0,a1 ; is this the main cursor?
bne.s @count ; no, just count other cursor's button
move.l doubleClickTime(a2),doubleTime ; set our double-click time
tst.b buttonCount(a1) ; is this the first button to go down?
bne.s @count ; no, no need to post another event…
tst.b MBState ; yes, was mouse up before (should be)?
bpl.s @count ; no, just count the down event
clr.b MBState ; now say the button is down...
moveq #0,d0 ; no message for PostEvent
move.w #mButDwnEvt,a0 ; Get event number
_PostEvent ; post the mouse down event
@count move.l Ticks,MBTicks ; update MBTicks for compatibility <H14>
addq.b #1,buttonCount(a1) ; count the button down
moveq #0,d0 ; result code
rts
;_______________________________________________________________________
;
; Routine: CrsrDevButtonUp
;
; Inputs: a2 - pointer to CrsrDevRec for this device
;
; Outputs: d0 - OSErr
;
; Destroys: a0-a1,d0
;
; Function: Posts a button up event if this is the last button to go up.
;_______________________________________________________________________
CrsrDevButtonUp
move.l whichCursor(a2),a1 ; get ptr to target cursor data
movea.l ExpandMem,a0 ; get ptr to expandmem rec
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr
move.l firstCrsrData(a0),a0 ; a0 points to main cursor data record
subq.b #1,buttonCount(a1) ; count the button up
bpl.s @chkMain ;
clr.b buttonCount(a1) ; clip at 0 (no negatives allowed)
@chkMain cmpa.l a0,a1 ; is this the main cursor?
bne.s @exit ; no, just exit
tst.b buttonCount(a1) ; is this the last button to go up?
bne.s @exit ; no, no need to post another event…
tst.b MBState ; yes, was mouse down before (should be)?
bmi.s @exit ; no, exit
bset.b #7,MBState ; now say the button is up...
moveq #0,d0 ; no message for PostEvent
move.w #mButUpEvt,a0 ; Get event number
_PostEvent ; post the mouse up event
@exit moveq #0,d0 ; result code
rts
;_______________________________________________________________________
;
; Routine: CrsrDevSetAccel
;
; Inputs: a2 - pointer to CrsrDevRec for device we want to set
; d0 - acceleration to set (0-1, fixed point)
;
; Outputs: d0 - OSErr
;
; Destroys: d0-d1,a0-a1
;
; Function: This routine installs the proper acceleration table for
; the specified device, based on the passed in acceleration
; value.
;_______________________________________________________________________
CrsrDevSetAccel
move.l d0,acceleration(a2) ; save new acceleration
movem.l d2-d7/a3-a4,-(sp) ; save a bunch of registers
move.l accelPoints(a2),d0 ; get ptr to old table
beq.s @cont
move.l d0,a0 ; if one existed,
_DisposPtr ; get rid of it
@cont move.w #mapTrue,RomMapInsert ; map ROM into resource chain <H2>
clr.w -(sp) ; room for function result
move.l #'accl',-(sp) ; we're looking for acceleration resources
_CountResources ; how many are there in the current resource file?
move.w (sp)+,d3 ; keep count in d3
beq.s @noaccl ; can't find any accl resources! <H11>
move.l devID(a2),d4 ; first try finding an 'accl' that matches our device ID<H3>
beq.s @tryClass ; if field NULL, use devClass
bsr FindResource ; did we find one?
beq.s @foundIt ; yes, skip below
@tryClass move.b devClass(a2),d4 ; try finding an 'accl' that matches our device class <H3>
ext.w d4 ; <H3>
ext.l d4 ; <H3>
bsr FindResource ; did we find one?
beq.s @foundIt ; yes, skip below
moveq #0,d4 ; otherwise, just load the flat ramp <H3>
bsr FindResource ; did we find one?
beq.s @foundIt
@noaccl _debugger ; •• break if we didn't find one (we should never get here!)
;----------------------------------------------
; first find the two tables which enclose the desired acceleration
;----------------------------------------------
@foundIt move.l acceleration(a2),d3 ; get new acceleration in d3
move.w (a0)+,d2 ; get # of acceleration tables in resource
move.l a0,a1 ; keep ptr to 'low' accel table in a1
@searchHi cmp.l (a0),d3 ; compare this acceleration to desired acceleration
ble.s @foundHi ; we found a table that is higher than us, done...
@nextEntry move.l a0,a1 ; update ptr to 'low' accel table in a1
addq.l #4,a0 ; skip past the acceleration
move.w (a0)+,d0 ; get # of points for this table
asl.w #3,d0 ; * 8 bytes for each entry
adda.w d0,a0 ; point to next table
bra.s @searchHi ; and try next acceleration
@foundHi move.l a0,a3 ; a3 = ptr to 'high' entry
cmpa.l a1,a3 ; are both tables same (matched 1st table) <H4>
bne.s @calcScale ; no, compute scale factor
addq.w #4,a1 ; bump past acceleration
addq.w #4,a3 ; in both tables
moveq #1,d7 ; yes, scale factor = 1
swap d7 ;
bra.s @scaleTable
@calcScale clr.l -(sp) ; room for function result
sub.l (a1),d3
move.l d3,-(sp) ; push (desired accel - low accel)
move.l (a3)+,d0
sub.l (a1)+,d0
move.l d0,-(sp) ; push (high accel - low accel)
_FixDiv ; divide to get our interpolation factor
move.l (sp)+,d7 ; d7 = scale factor
;----------------------------------------------
; now scale the lower resource table to the desired acceleration.
; The resulting table is pushed on the stack as it is created.
; d7 = scale factor
;
; uses d3,d4 to hold last dumped x1,y1
;----------------------------------------------
@scaleTable move.l sp,a4 ; keep ptr to stack buffer top
moveq #0,d3 ; init our 'prev' point 1
moveq #0,d4
clr.l -(sp) ; init x1
clr.l -(sp) ; init y1
move.w (a1)+,d5 ; d5 = # of points in lower table
move.w (a3)+,d6 ; d6 = # of points in upper table
cmpa.l a1,a3 ; did we find an exact match? <H4>
bne.s @scaleLoop ; yes, say no points left in one of the tables <H4>
moveq #0,d5 ; <H4>
@scaleLoop tst.w d5 ; any points left on lower line?
beq.s @lowLine ; no, then interpolate onto lower line
tst.w d6 ; any points left on upper line?
beq.s @highLine ; no, then interpolate onto upper line
move.l (a1),d0 ; see if next x point on lower accel table is
cmp.l (a3),d0 ; greater then next x point on higher accel table
bgt.s @lowLine ; yes, then use 2 points from lower table
;-----------
@highLine move.l (a3),-(sp) ; push x2 from upper curve
move.l 4(a3),-(sp) ; push y2 " "
move.l (a1),-(sp) ; push x3 from lower curve
move.l 4(a1),-(sp) ; push y3 " "
subq.w #1,d5 ; count the point
ble.s @doneLow ; if no more, we need to keep re-using last point
addq.w #8,a1 ; else, more points, point to next one
bra.s @int1
@doneLow moveq #0,d5 ; indicate no more points on lower line
@int1 bset #31,d7 ; indicate y3 is on lower curve
bsr Interpolate ; find new x' y'
bra.s @setPoint1 ; and set next point 1
;-----------
@lowLine move.l (a1),-(sp) ; push x2 from lower curve
move.l 4(a1),-(sp) ; push y2 " "
move.l (a3),-(sp) ; push x3 from upper curve
move.l 4(a3),-(sp) ; push y3 " "
subq.w #1,d6 ; count the point
ble.s @doneHigh ; if no more, we need to keep re-using last point
addq.w #8,a3 ; else, more points, point to next one
bra.s @int2
@doneHigh moveq #0,d6 ; indicate no more points on upper line
@int2 bsr Interpolate ; find new x' y'
;-----------
@setPoint1 tst.w d5 ; are we at end?
beq.s @restorePrevPt1 ; yes, restore previous pt1
tst.w d6 ; are we at end of upper line?
beq.s @restorePrevPt1 ; yes, restore previous pt1
move.l (a1),d0
cmp.l (a3),d0 ; is next point on upper curve before next point on low curve?
ble.s @swapLines ; no, skip below
@sameLine addq.w #8,sp ; dump last x3,y3 point
move.l 12(sp),4(sp) ; yes, old x1 becomes new x1
move.l 8(sp),(sp) ; old y1 becomes new y1
bra.s @nextPoint
@restorePrevPt1
addq.w #8,sp ; dump last x3,y3 point
move.l d3,4(sp) ; yes, previous x1 becomes new x1
move.l d4,(sp) ; previous y1 becomes new y1
bra.s @nextPoint
;-----------
@swapLines move.l (sp)+,4(sp) ; old y3 becomes new y1 data point
move.l (sp)+,4(sp) ; old x3 becomes new x1 data point
@nextPoint move.l 12(sp),d3 ; save last x1,y1 in case needed later
move.l 8(sp),d4
move.l d1,12(sp) ; set new x',y' data point on top of old x1,y1 point
move.l d2,8(sp) ;
move.w d5,d0 ; any more points in lower
or.w d6,d0 ; or upper table?
bne @scaleLoop ; yes, ok to continue
;------------------
addq.w #8,sp ; dump last x1,y1 point
move.l a4,d0 ; find out how big our computed buffer
sub.l sp,d0 ; is
lsr.l #3,d0 ; / 8 to find how many points
mulu #CrsrDevSegSize,d0 ; * size of each point
_NewPtr ,Sys,Clear ; allocate space for new table
move.l a0,accelPoints(a2) ; save ptr to table
;----------------------------------------------
; finally compute the table of accelPoints, based on the scaled accel resource
;----------------------------------------------
move.l a0,a3 ; keep working ptr to new table in a3
move.l a4,a1 ; ptr to top of table in a4 (grows toward low mem)
moveq #0,d1 ; init x1
moveq #0,d2 ; init y1
clr.l -(sp) ; first, calculate a couple of scaling constants
move.l resolution(a2),-(sp) ; device res
move.l #(frameRate<<16),-(sp) ; / frame rate
_FixDiv
move.l (sp)+,d6 ; = scale factor for device speed
clr.l -(sp)
move.l whichCursor(a2),a0
move.l CrsrDataRec.screenRes(a0),-(sp) ; screen res
move.l #(frameRate<<16),-(sp) ; / frame rate
_FixDiv
move.l (sp)+,d7 ; = scale factor for cursor speed
@loop clr.l -(sp) ; room for fixMul result
move.l -(a1),-(sp) ; get device speed for next point
move.l d6,-(sp) ;
_FixMul ; dev speed * [devRes / frameRate]
move.l (sp)+,d3 ; = x2
move.l d3,devUnits(a3) ; •• set max device speed for this segment
clr.l -(sp) ; room for fixMul result
move.l -(a1),-(sp) ; get cursor speed for next point
move.l d7,-(sp) ;
_FixMul ; y2 = cursor speed * [crsrRes / frameRate]
move.l (sp)+,d4 ;
clr.l -(sp) ; room for function result
move.l d4,d0
sub.l d2,d0 ; y2-y1
move.l d0,-(sp)
move.l d3,d0
sub.l d1,d0 ; x2-x1
move.l d0,-(sp)
_FixDiv ; calculate the slope
move.l (sp)+,slope(a3) ; •• set slope in table
clr.l -(sp)
move.l slope(a3),-(sp)
move.l d3,-(sp)
_FixMul ; slope * X
move.l d4,d0
sub.l (sp)+,d0 ; Y - slope * X = intercept
move.l d0,intercept(a3) ; •• set intercept
adda.w #CrsrDevSegSize,a3 ; bump to next segment
move.l d3,d1 ; old x2,y2 becomes new x1,y1
move.l d4,d2
cmpa.l a1,sp ; are we done?
blt.s @loop ; no, continue
move.l a4,sp ; dump buffer from stack
move.l #$7FFFFFFF,-12(a3) ; set last 'highest device speed' to max
movem.l (sp)+,d2-d7/a3-a4 ; restore registers
moveq #0,d0 ; result code
rts
;------------------------------------------------
;
; Routine: FindResource
;
; Inputs: d3 - # of 'accl' resources to search
; d4 - 'accl' resource tag we're looking for
;
; Outputs: a0 - ptr to 'accl' resource (past tag) if we found it
; ccr.Z - set if we matched
;
; Destroys: a0,d0,d1,d2,d5
;
; Function: This routine scans 'accl' resources, searching
; for one with a tag matching d1.
;------------------------------------------------
FindResource
move.w d3,d5 ; init our index <H3>
@loop move.w #mapTrue,RomMapInsert ; map ROM into resource chain <H2>
clr.l -(sp) ; room for function result
move.l #'accl',-(sp) ; we're looking for acceleration resources
move.w d5,-(sp) ; push current index <H3>
_GetIndResource ; get next 'accl' resource
move.l (sp)+,d0 ; did we get this one? <H3>
beq.s @NotFound ; -> no, try the next one <H3>
move.l d0,a0 ; handle in a0 <H3>
move.l (a0),a0 ; ptr in a0
cmp.l (a0)+,d4 ; does tag match our selector?
beq.s @exit ; yes, exit (with res ptr in a0)
@NotFound subq.w #1,d5 ; no, bump to next resource <H3>
bne.s @loop ; keep searching... <H3>
moveq #1,d0 ; set BNE if not found <H3>
@exit rts ; exit with Z-Flag set on match
;------------------------------------------------
;
; Routine: Interpolate
;
; Inputs: 18(sp) - x1
; 14(sp) - y1
; 10(sp) - x2
; 0C(sp) - y2
; 08(sp) - x3
; 04(sp) - y3
; d7 - scale, bit 31 set if 3rd point on lower accel curve.
;
; Outputs: d1 - x'
; d2 - y'
; d7.31 - reset
;
; Destroys: a0,d0-d1
;
; Function: This routine interpolates to find a point on the line [x1,y1] [x2,y2] which
; is intersected by the line [x3,y3] [x3,y"]. The resulting y' is calculated
; by interpolating between y3 and y", towards the higher acceleration curve.
;------------------------------------------------
stackFrame RECORD 0,increment
saveA6 ds.l 1
retAddr ds.l 1
y3 ds.l 1
x3 ds.l 1
y2 ds.l 1
x2 ds.l 1
y1 ds.l 1
x1 ds.l 1
ENDR
Interpolate
WITH stackFrame
link a6,#0 ; set our frame ptr
clr.l -(sp) ; room for function result
move.l y2(a6),d0 ; get y2
sub.l y1(a6),d0 ; y2 - y1
move.l d0,-(sp)
move.l x2(a6),d0 ; x2 - x1
sub.l x1(a6),d0
move.l d0,-(sp)
_FixDiv ; calculate slope, leave on stack
clr.l -(sp) ; room for function result
move.l 4(sp),-(sp) ; push copy of slope
move.l x1(a6),-(sp) ; push x1
_FixMul ; slope * x1
move.l y1(a6),d1
sub.l (sp)+,d1 ; d1 = intercept = y1 - (slope * x1)
move.l (sp),-(sp) ; push slope, leave room for function result
move.l x3(a6),-(sp) ; push x3
_FixMul
add.l (sp)+,d1 ; y" = slope * x3 + intercept
clr.l -(sp) ; room for function result
move.l y3(a6),d0
sub.l d1,d0
move.l d0,-(sp) ; push (y3 - y")
move.l d7,-(sp) ; push scale
bclr.b #7,(sp) ; make sure flag is off
_FixMul
bclr #31,d7 ; check if y3 is on lower curve
bne.s @lower ; yes, branch
@upper move.l (sp)+,d2 ; yes, interpolate upward
add.l d1,d2 ; y' = scale(y3-y") + y"
bra.s @exit
@lower move.l y3(a6),d2 ; interpolate downward,
sub.l (sp)+,d2 ; y' = y3 - scale(y3-y")
@exit move.l x3(a6),d1 ; return x'
unlk a6
rts
ENDWITH
;_______________________________________________________________________
;
; Routine: CrsrDevHandleVBL
;
; Inputs: -
;
; Outputs: -
;
; Destroys: d0 <H7>
;
; Function: This routine moves the cursor on the screen. It handles error
; distribution and delta acceleration for all the devices, then
; redraws the cursor.
;_______________________________________________________________________
EXPORT CrsrDevHandleVBL
CrsrDevHandleVBL
movem.l a0-a4/d1-d5,-(sp) ; save a bunch of registers <H7>
movea.l ExpandMem,a3 ; get ptr to expandmem rec
movea.l emCursorGlobals(a3),a3 ; get cursory global ptr
move.l firstCrsrDev(a3),d0 ; get ptr to 1st CrsrDevRec
beq @exit ; if not even 1 device, just exit
move.l d0,a2 ; ptr in a2
tst.b CrsrNew ; has anyone touched the old cursor
beq.s @drawCheck ; globals (compatibility - Display Mgr sets this <IH> ) ? <SM6>
clr.b CrsrNew ; yes, ok, we're handling it now
move.l firstCrsrData(a3),a4 ; get ptr to only CrsrDataRec in a4
tst.b isAbs(a4) ; are we in relative mode?
bne.s @drawCheck ; no, skip <SM6>
move.l MTemp,d0 ; does RawMouse <H4>
cmp.l RawMouse,d0 ; = MTemp? <H4>
bne.s @delta ; no, then they're doing deltas <H4>
@abs move.w d0,whereX(a4) ; yes, then just set our whereXY global to theirs
clr.w whereX+2(a4)
swap d0
move.w d0,whereY(a4)
clr.w whereY+2(a4)
bra.s @drawCheck ; <SM6>
@delta move.w Mouse+h,d0 ; add in their movement to ours
sub.w where+h(a4),d0 ; Mouse.h - crsrData->where.h
add.w MTemp+h,d0 ;
sub.w RawMouse+h,d0 ; + MTemp.h - RawMouse.h
swap d0 ; Word2fix
clr.w d0 ;
add.l d0,whereX(a4) ; update our global x position
move.w Mouse+v,d0 ; yes, add in their movement to ours
sub.w where+v(a4),d0 ; Mouse.v - crsrData->where.v
add.w MTemp+v,d0 ;
sub.w RawMouse+v,d0 ; + MTemp.v - RawMouse.v
swap d0 ; Word2fix
clr.w d0 ;
add.l d0,whereY(a4) ; update our global y position
; <SM6>begin
; See if it is time to draw the cursor.
;
@drawCheck ;
IF LC930 THEN
bclr.b #SkipDraw,CrsrDevFlags(a3) ; if this is the first CRSR VBL don't draw, do the calculations only
bne.s @accumLoop ; will draw on the next VBL
;==================================
@flushCrsrs
movem.l d0/a0-a4,-(sp) ; save registers used by CursorDraw Routines
move.l firstCrsrData(a3),a4 ; get ptr to first CrsrDataRec
@flushLoop clr.b isAbs(a4)
move.w whereX(a4),where+h(a4) ; update our h coordinate
move.w whereY(a4),where+v(a4) ; update our h coordinate
move.l nextCrsrData(a4),a4
move.l a4,d0
bne.s @flushLoop ; and clear flush next cursor (if any)
;-----------------
@drawCursor movea.l DrawCrsrVBLVector(a3),a0 ; call the DrawCursor vector <H15>
jsr (a0) ; <H15>
movem.l (sp)+,d0/a0-a4 ; restore registers trashed by CursorDraw routine
ENDIF ; <SM6>end
;------------------------------------------------------
; Now add and accelerate deltas for all cursor devices
; and combine into our only cursor data record.
;------------------------------------------------------
@accumLoop move.l whichCursor(a2),a4 ; get ptr to this devices CrsrDataRec in a4
tst.b isAbs(a4) ; are we in absolute mode?
beq.s @relative ; no, skip
clr.l deltaX(a2) ; yes, absolute cursor,
clr.l deltaY(a2) ; flush relative info for this device
clr.l errorX(a2) ;
clr.l errorY(a2) ;
move.w #-104,denom(a2)
clr.b newData(a2)
bra @nextDev ; and continue
;----------------
@relative tst.b newData(a2) ; relative cursor, do we have new data?
beq.s @noNewData ; no, skip
clr.b newData(a2) ; we're handling the new stuff now…
tst.w denom(a2) ; any errors?
ble.s @noError ; no, skip
clr.l -(sp) ; make room for fixDiv result
move.l errorX(a2),-(sp) ; 1st param for fixDiv
moveq #0,d0
move.w denom(a2),d0
swap d0 ; Word2Fix
move.l d0,-(sp) ; 2nd param for fixDiv
_FixDiv
move.l (sp)+,d3 ; dx = FixDiv(errorX,denom)
clr.l -(sp) ; make room for fixDiv result
move.l errorY(a2),-(sp) ; 1st param for fixDiv
moveq #0,d0
move.w denom(a2),d0
swap d0 ; Word2Fix
move.l d0,-(sp) ; 2nd param for fixDiv
_FixDiv
move.l (sp)+,d4 ; dy = FixDiv(errorY,denom)
sub.l d3,errorX(a2)
sub.l d4,errorY(a2)
bra.s @addDeltas
@noError clr.l d3
clr.l d4
@addDeltas add.l deltaX(a2),d3 ; add in the deltas
add.l deltaY(a2),d4
cmpi.w #-100,denom(a2) ; setup for next time
ble.s @findMag
subq.w #1,denom(a2)
bra.s @findMag
@noNewData move.l errorX(a2),d3 ; no new samples since last VBL,
move.l errorY(a2),d4 ; take all the error
clr.l errorX(a2)
clr.l errorY(a2)
move.w #-102,denom(a2)
;-----------------
@findMag move.l d3,d0 ; get dx
bpl.s @absDy ; ok if positive
neg.l d0 ; else, make positive
@absDy move.l d4,d1 ; get dy
bpl.s @chkMag ; ok if positive
neg.l d1 ; else, make positive
@chkMag cmp.l d1,d0
bgt.s @doY
lsr.l #1,d0
bra.s @setMag
@doY lsr.l #1,d1
@setMag add.l d0,d1 ; d1 = magnitude
beq.s @nextDev ; no magnitude, check next device
move.l accelPoints(a2),a1 ; a1 points to acceleration table
clr.w d0
@search cmp.l devUnits(a1,d0.w),d1 ; find entry in the table
ble.s @foundIt ; that matches our magnitude
add.w #CrsrDevSegSize,d0 ; not close yet, bump to next one
bra.s @search
;-----------------
@foundIt move.l intercept(a1,d0.w),-(sp) ; push intercept for later add
clr.l -(sp) ; room for function result
move.l slope(a1,d0.w),-(sp) ; push slope
move.l d1,-(sp) ; push mag
_FixMul
move.l (sp)+,d0
add.l (sp)+,d0 ; scale = intercept + slope*mag
clr.l -(sp) ; room for function result
move.l d0,-(sp) ; push scale
move.l d1,-(sp) ; magnitude
_FixDiv ; scale = scale / mag
clr.l -(sp) ; room for function result
move.l 4(sp),-(sp) ; push a copy of scale
move.l d3,-(sp) ; push dx
_FixMul
move.l (sp)+,d0
add.l d0,whereX(a4) ; accumulate the accelerated move
move.l (sp),-(sp) ; push scale, leave room for function result
move.l d4,-(sp) ; push dy
_FixMul
move.l (sp)+,d0
add.l d0,whereY(a4) ; accumulate the accelerated move
@nextDev move.l nextCrsrDev(a2),a2 ; get next device ptr
move.l a2,d0 ; done all devices?
bne @accumLoop ; no, continue looping
IF NOT LC930 THEN ; <SM6>
;==================================
@flushCrsrs move.l firstCrsrData(a3),a4 ; get ptr to first CrsrDataRec
@flushLoop clr.b isAbs(a4)
move.w whereX(a4),where+h(a4) ; update our h coordinate
move.w whereY(a4),where+v(a4) ; update our h coordinate
move.l nextCrsrData(a4),a4
move.l a4,d0
bne.s @flushLoop ; and clear flush next cursor (if any)
;-----------------
@drawCursor movea.l DrawCrsrVBLVector(a3),a0 ; call the DrawCursor vector <H15>
jsr (a0) ; <H15>
ENDIF ; <SM6>
@exit movem.l (sp)+,a0-a4/d1-d5 ; restore a bunch of registers <H7>
rts
;_______________________________________________________________________ <H15>
;
; Routine: DrawCursor
;
; Inputs: a3 - ptr to CrsrDevGlobals
;
; Outputs:
;
; Destroys: d0,a0,a4
;
; Function: This routine is the default ROM routine called through
; the DrawCrsrVBLVector. The vector is initialized by
; InitCrsrDev. (Pulled from the in-line VBL code).
;_______________________________________________________________________
DrawCursor movea.l firstCrsrData(a3),a4 ; get ptr to main CrsrDataRec <H15>
move.l where(a4),d0 ; get new mouse coords
cmp.l Mouse,d0 ; has cursor moved?
beq.s @exit ; no… exit
tst.b CrsrCouple ; is cursor coupled to mouse?
bne.s @coupled ; yes, continue <SM6>
move.l d0,MTemp ; no, just update lowmem MTemp <SM6>
bra.s @exit ; and exit without drawing cursor <SM6>
@coupled tst.b CrsrBusy ; is it locked? <SM6>
bne.s @exit ; yes… exit
lea CrsrPin,a0 ; it's ok to update cursor, get bounding rect
BSR.L CrsrVBLTask ; pin and draw the cursor
move.l Mouse,d0 ; has cursor been pinned?
cmp.l where(a4),d0 ;
beq.s @exit ; no… exit
move.l d0,where(a4) ; reflect pinned location
move.l MouseMask,d1 ; <H18>
not.l d1
tst.w d1 ; are we gridding in x direction?
beq.s @updateX ; no, force update
move.w whereX(a4),d0 ; yes, see if we clipped at screen bounds <H18>
sub.w Mouse+h,d0
bpl.s @xok
neg.w d0
@xok cmp.w d1,d0 ; compare our error to grid delta
ble.s @chkGridv ; <, so don't update our running x position
@updateX move.w RawMouse+h,whereX(a4) ; stamp our new running x position
clr.w whereX+2(a4)
@chkGridv swap d1 ; <H18>
tst.w d1 ; are we gridding in y direction?
beq.s @updateY ; no, force update
move.w whereY(a4),d0 ; yes, see if we clipped at screen bounds <H18>
sub.w Mouse+v,d0
bpl.s @yok
neg.w d0
@yok cmp.w d1,d0 ; compare our error to grid delta
ble.s @exit ; <, so don't update our running y position
@updateY move.w RawMouse+v,whereY(a4) ; stamp our new running x position
clr.w whereY+2(a4) ; loose the fraction
@exit rts
;_______________________________________________________________________
;
; Routine: CrsrDevNewDevice
;
; Inputs: ...
;
; Outputs: a2 - pointer to CrsrDevRec for device we initialized
; d0 - OSErr
;
; Destroys: d1-d2,a0-a1
;
; Function: This routine creates a new CrsrDevRec, adds it to the
; linked list of device records, and initializes it's fields.
; Note: the caller must call CrsrDevSetAcceleration after
; calling this routine.
;_______________________________________________________________________
CrsrDevNewDevice
move.l #CrsrDevSize,d0
_NewPtr ,Sys,Clear ; non-explicitly set fields will default to zeros
bne.s @error ; no memory, error exit
move.l a0,a2 ; keep ptr in a0
movea.l ExpandMem,a0 ; get ptr to expandmem rec
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr
move.l firstCrsrDev(a0),nextCrsrDev(a2) ; link into our chain
move.l a2,firstCrsrDev(a0) ; " "
move.l firstCrsrData(a0),whichCursor(a2) ; init the cursor data ptr
move.b #classMouse,devClass(a2) ; we're a mouse type device
move.b #1,cntButtons(a2) ; and have 1 button <H11>
move.b #btnSingleClick,buttonOp+0(a2) ; standard single-click operation
move.l #(72<<16),resolution(a2) ; standard screen resolution
subq #4,sp
move.l sp,a0
move.l #$00020008,d0
_ReadXPram ; read mouse PRAM
move.l (sp)+,d1 ; get PRAM setting for double-click time
move.l d1,d0
rol.l #5+2,d0
andi.w #$1C,d0
lea @accelToFixed,a0
move.l (a0,d0.w),acceleration(a2) ; convert to fixed, and set our acceleration
moveq #8+4,d0
rol.l d0,d1 ; get PRAM setting for double-click time
andi.w #$0F,d1
lea @clickToFixed,a0
moveq #0,d0
move.b (a0,d1.w),d0
move.l d0,doubleClickTime(a2) ; set our double-click time
move.l d0,doubleTime ; update lowmem as well... <H13>
move.w #-101,denom(a2)
move.w #4,spread(a2)
moveq #0,d0 ; result code
rts
@error moveq #-1,d0 ; error exit
rts
@accelToFixed
dc.l $00000000 ; 0
dc.l $00002000 ; 1
dc.l $00005000 ; 2
dc.l $00008000 ; 3
dc.l $0000B000 ; 4
dc.l $0000E000 ; 5
dc.l $00010000 ; 6
dc.l $00010000 ; 7
@clickToFixed
dc.b $0C ; 0
dc.b $0C ; 1
dc.b $0C ; 2
dc.b $0C ; 3
dc.b $10 ; 4
dc.b $14 ; 5 fast
dc.b $17 ; 6
dc.b $1B ; 7
dc.b $20 ; 8 medium
dc.b $23 ; 9
dc.b $26 ; a
dc.b $2C ; b
dc.b $30 ; c slow
dc.b $34 ; d
dc.b $38 ; e
dc.b $3C ; f
;_______________________________________________________________________
;
; Routine: CrsrDevDisposeDev
;
; Inputs: a2 - pointer to CrsrDevRec for device we want to remove
;
; Outputs: d0 - OSErr
;
; Destroys: d0-d2,a0-a1
;
; Function: This routine eliminates CrsrDevRec from the linked list
; of device records, and disposes of all storage related to
; it.
;_______________________________________________________________________
CrsrDevDisposeDev
movea.l ExpandMem,a0 ; get ptr to expandmem rec
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr
move.l firstCrsrDev(a0),a1 ; d1 points to main cursor data record
moveq #0,d1 ; prev := NIL
@loop cmpa.l a1,a2 ; is this the linked list element we want?
beq.s @gotIt ; yes, handle it
move.l a1,d1 ; no, prev := next
move.l nextCrsrDev(a1),d0 ; get next->nextCrsrDev
beq.s @exit ; exit if NIL (we never found it)
move.l d0,a1 ; next := next->nextCrsrDev
bra.s @loop
@gotIt move.l nextCrsrDev(a1),a1 ; next := next->nextCrsrDev
tst.l d1 ; was it the first one?
beq.s @firstOne ; yes, handle special case
move.l d1,a2
move.l a1,nextCrsrDev(a2) ; else, delete our element from middle of list
bra.s @dispose
@firstOne move.l a1,firstCrsrDev(a0)
@dispose move.l accelPoints(a2),d0
beq.s @ridRecord ; get rid of storage within CrsrDevRec
move.l d0,a0
_DisposPtr
@ridRecord move.l a2,a0
_DisposPtr ; get rid of CrsrDevRec itself
@exit moveq #0,d0 ; result code
rts
;_______________________________________________________________________
;
; Routine: CrsrDevReInit
;
; Inputs: d0 - 0 = pre-init, 1=post-init
;
; Outputs: d0 - 0 = pre-init, 1=post-init
;
; Destroys: a0-a3/d1-d3
;
; Function: This routine handles pre and post ADB ReInit processing.
; Before reinit, it trashes all the crsrDevRecs that are
; hanging off the ADB chain. After the re-init, it restores
; all the devices. Devices that can enter Handler XX, like PGE,
; are polled for information from register 01, which is used
; to fill in the CrsrDevRec. Other devices are used in the
; appropriate defaults.
;_______________________________________________________________________
ADBParamBlk RECORD 0,decrement
iDataAddr ds.l 1 ; ADB device data ptr
iCRAddr ds.l 1 ; ADB device completion rtn
iOrigAddr ds.b 1 ; ADB original address
iDeviceTy ds.b 1 ; ADB device type
iPBlock EQU iDeviceTy ; the start of our GetInfo param block
iSPBlock EQU iCRAddr ; the start of our SetInfo param block
adbPBSize EQU * ; size of our param block
ENDR
EXPORT CrsrDevReInit
CrsrDevReInit ; <H14>
WITH ADBParamBlk
movem.l d0-d3/a0-a3,-(sp)
link a6,#adbPBSize ; Make a stack frame for our param block
bne.s @PostInit ; Skip if post-processing
;---------------------
; pre-init processing
;---------------------
_CountADBs ; Get the number of ADB devices
move.w d0,d2 ; Save in D2
beq @exit ; Skip if none
@killLoop lea iPBlock(a6),a0 ; a0 is parameter block
move.w d2,d0
_GetIndADB ; Get a device entry
bmi.s @nextRec1 ; Skip if not valid
cmpi.b #mouseAddr,iOrigAddr(a6); mouse?
bne.s @nextRec1 ; Skip if not
move.l iDataAddr(a6),a2 ; Save the data address pointer
clr.l iDataAddr(a6) ; Clear it out, so the keyboard won't trash memory
lea iSPBlock(a6),a0 ; a0 ptr to our short param block
_SetADBInfo ; d0 already contains the ADB Address
bsr.s CrsrDevDisposeDev ; eliminate it from our globals also
@nextRec1 subq.w #1,d2
bgt.s @killLoop
movea.l ExpandMem,a0 ; get ptr to expandmem rec
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr
clr.l firstCrsrDev(a0) ; clear out initial dev ptr
bra @exit
;---------------------
; post-init processing
;---------------------
@PostInit bset.b #7,MBState ; set current mouse button state to UP <H16>
clr.l MBTicks ; reset timestamp for mouse button <H16>
_CountADBs ; Get the number of ADB devices
move.w d0,d2 ; Save in D2
sub.w #10,sp ; allocate ADBOp reply buffer on stack for later
beq @postCheck ; Skip if no devices
@instLoop
lea iPBlock(a6),a0 ; a0 is parameter block
move.w d2,d0
_GetIndADB ; Get a device entry
move.w d0,d3 ; save ADB address
bmi @nextRec2 ; Skip if not valid
cmpi.b #mouseAddr,iOrigAddr(a6); mouse?
bne @nextRec2 ; Skip if not
bsr CrsrDevNewDevice ; create and chain in a new cursor record
; a2 points to crsrDevRec
move.b d3,d0 ; address in d0
lsl.b #4,d0 ; upper 4 bits
ori.b #%1111,d0 ; talk R3 command
move.l sp,a0 ; reply buffer ptr in a0
bsr syncADBTalk ; send command synchronously, reply in a0.
tst.b (a0) ; any data?
beq @nextRec2 ; no, skip (should not happen)
move.b #extDevHand,2(a0) ; yes, try to set to allow mouse extension
move.b d3,d0 ; address in d0
lsl.b #4,d0 ; upper 4 bits
ori.b #%1011,d0 ; Listen R3 command
bsr syncADBListen ; send command synchronously.
move.b d3,d0 ; now see if we switched be doing a talk R3 again
lsl.b #4,d0 ; addr in upper 4 bits
ori.b #%1111,d0 ; talk R3 command
move.l sp,a0 ; reply buffer ptr in a0
bsr syncADBTalk ; send command synchronously, reply in a0.
tst.b (a0) ; any data?
beq @nextRec2 ; no, skip (should not happen)
cmpi.b #extDevHand,2(a0) ; did we switch?
bne.s @preExisting ; no, doesn't
;--------------------------------
; We got an extended type device...
;--------------------------------
move.b d3,d0 ; now get the extended data from R1
lsl.b #4,d0 ; addr in upper 4 bits
ori.b #%1101,d0 ; talk R1 command
bsr syncADBTalk ; send command synchronously, reply in a0.
cmpi.b #8,(a0) ; did we get 8 bytes back?
bne.s @preExisting ; no, try handler 2 (maybe 1)
move.b 1(a0),devID+0(a2) ; copy the device ID (optimize later)
move.b 2(a0),devID+1(a2) ; "
move.b 3(a0),devID+2(a2) ; "
move.b 4(a0),devID+3(a2) ; "
move.b 5(a0),resolution+0(a2) ; Copy the resolution
move.b 6(a0),resolution+1(a2) ; "
clr.w resolution+2(a2) ; clear out the fraction part
move.b 7(a0),devClass(a2) ; Copy the device class
move.b 8(a0),cntButtons(a2) ; Copy the number of buttons
move.b #btnSingleClick,buttonOp+1(a2) ; single-click operation for 2nd button <H5>
bra.s @setInfo ; and setup globals/completion rtn for this device
;--------------------------------
; We got a pre-existing type device...
;--------------------------------
@preExisting
move.b #2,2(a0) ; yes, try to set to handler 2
move.b d3,d0 ; address in d0
lsl.b #4,d0 ; upper 4 bits
ori.b #%1011,d0 ; Listen R3 command
bsr syncADBListen ; send command synchronously.
move.b d3,d0 ; now see if we switched be doing a talk R3 again
lsl.b #4,d0 ; addr in upper 4 bits
ori.b #%1111,d0 ; talk R3 command
move.l sp,a0 ; reply buffer ptr in a0
bsr syncADBTalk ; send command synchronously, reply in a0.
tst.b (a0) ; any data?
beq.s @nextRec2 ; no, skip (should not happen)
cmpi.b #2,2(a0) ; did we switch to 2?
bne.s @brainDead ; no, must be stupid 4th party device
;-----------------------------------------
; We switched to 2, so adjust some paramters
;-----------------------------------------
move.l #'@200',devID(a2) ; set the device ID
move.w #200,resolution(a2) ; set the resolution
bra.s @setInfo
;-----------------------------------------
; We didn't switch to 2, so set back to 1 (is this necessary Dan?)
;-----------------------------------------
@brainDead move.b #1,2(a0) ; yes, try to set to handler 1
move.b d3,d0 ; address in d0
lsl.b #4,d0 ; upper 4 bits
ori.b #%1011,d0 ; Listen R3 command
bsr syncADBListen ; send command synchronously.
;--------------------------------
@setInfo move.l acceleration(a2),d0 ; d0 = acceleration for this device
bsr CrsrDevSetAccel ; set up the acceleration tables
lea CrsrDevHandleADB,a0
move.l a0,iCRAddr(a6) ; set our handler
move.l a2,iDataAddr(a6) ; set up the data area
lea iSPBlock(a6),a0 ; a0 ptr to our short param block
move.w d3,d0 ; d0 = ADB address
_SetADBInfo ; install the new info
@nextRec2 subq.w #1,d2
bgt @instLoop ; continue looping though all devices
bmi.s @postExit ; done when we've been through here twice (once to set default)
;---------------------
@postCheck move.b #mouseAddr,d3
moveq #numFDBAdr,d0 ; Number of table entries
move.l ADBBase,a3 ; get ADB globals in a3
move.l a3,a1 ; copy in a1
bra.s @chkMatch ;
@searchLoop adda.w #FRecSize,a1 ; Get to next record
@chkMatch cmp.b FDBAddr(a1),d3 ; Is this the right one?
beq.s @postExit ; If so, we're done
tst.b FDBAddr(a1) ; Is it 0?
dbeq d0,@searchLoop ; Loop until it is found or no more.
move.b #1,FDBDevTy(a1) ; assume handler 1
move.b d3,FDBOAddr(a1) ; set original address as 3
move.b d3,FDBAddr(a1) ; set FDB address as 3
bset.b d3,DevMap+1(a3) ; remember to poll it
bsr CrsrDevNewDevice ; else, create and chain in a default cursor record
bra.s @setInfo ; and set it it ADB unit table
@postExit add.w #10,sp ; • dump our ADBOp buffer
movea.l ExpandMem,a0 ; get ptr to expandmem rec <H10>
movea.l emCursorGlobals(a0),a0 ; get cursory global ptr <H10>
move.l firstCrsrData(a0),a0 ; get the cursor data ptr <H10>
clr.b buttonCount(a0) ; init button down count <H10>
;---------------------
@exit unlk a6 ; dump the adbInfo param block
movem.l (sp)+,d0-d3/a0-a3
rts
;_______________________________________________________________________
;
; Routine: syncADBTalk
;
; Inputs: d0 - address/command byte
; a0 - ptr to receive buffer
;
; Outputs: a0 - pts to pascal talk string
;
; Destroys: a1,d0
;
; Function: This routine makes a synchronous ADBOp call, and returns
; any data in the buffer pointed to by a0.
;_______________________________________________________________________
syncADBTalk
move.l a0,-(sp) ; save ptr to our buffer
clr.w -(sp) ; our 'sync' flag
move.l sp,a1 ; keep pointer to globals for later
move.l sp,-(sp) ; push pointer to globals
pea syncComp ; push pointer to our completion routine
move.l a0,-(sp) ; push pointer to our reply buffer
move.l sp,a0
_ADBOp
@spin tst.b (a1) ; have we completed?
beq.s @spin ; no, keep waiting
lea 14(sp),sp ; dump locals
move.l (sp)+,a0 ; restore a0
rts
;_______________________________________________________________________
;
; Routine: syncADBListen
;
; Inputs: d0 - address/command byte
; a0 - ptr to transmit buffer
;
; Outputs: a0 - pts to pascal talk string
;
; Destroys: a0-a1,d0
;
; Function: This routine makes a synchronous ADBOp call, and returns
; any data in the buffer pointed to by a0.
;_______________________________________________________________________
syncADBListen
clr.w -(sp) ; our 'sync' flag
move.l sp,a1 ; keep pointer to data area for later
move.l sp,-(sp) ; push pointer to data area
pea syncComp ; push our completion address
move.l a0,-(sp) ; push ptr to data to send
move.l sp,a0
_ADBOp
@spin tst.b (a1) ; have we completed?
beq.s @spin ; no, keep waiting
lea 14(sp),sp ; dump locals
rts
;_______________________________________________________________________
;
; Routine: syncComp
;
; Inputs: d0 - ADB command byte
; a0 - ptr to data (pascal string)
; a2 - ptr to data area
;
; Outputs: -
;
; Destroys: a0-a3,d0-d3
;
; Function: This is our ADB completion routine. It simply copies any
; data to our receive buffer in our data area, then sets our
; complete flag.
;_______________________________________________________________________
syncComp st.b (a2) ; set our complete flag
rts
;_______________________________________________________________________
;
; Routine: InitCrsrDev
;
; Inputs: -
;
; Outputs: -
;
; Destroys: a0-a1/d0
;
; Function: This routine allocates and initializes globals for the
; CursorDevice routines, keeping a pointer to them in ExpandMem.
;_______________________________________________________________________
InitCrsrDev
moveq #CrsrGlobSize,d0
_NewPtr ,Sys,Clear ; allocate storage for our globals
movea.l ExpandMem,a1 ; get ptr to expandmem rec
exg a0,a1
move.l a1,emCursorGlobals(a0) ; set cursory global ptr
lea SetCrsrDelCore,a0 ; addr of default ROM handler <H15>
move.l a0,SetCrsrDelayVector(a1) ; install into vector <H15>
lea DrawCursor,a0 ; addr of default ROM handler <H15>
move.l a0,DrawCrsrVBLVector(a1) ; install into vector <H15>
moveq #CrsrDataSize,d0 ; size of our (only) cursor data record
_NewPtr ,Sys,Clear ; allocate it's globals
move.l a0,firstCrsrData(a1) ; set ptr to main cursor data in our globals
moveq #$10,d0
swap d0
move.l d0,whereX(a0) ; init cursor position
move.l d0,whereY(a0)
moveq #72,d0 ; init default screen resolution to 72 dpi
swap d0 ; word2Fix
move.l d0,screenRes(a0)
lea vDrawCursor,a0 ; vector low level drawing routines
move.l a0,DrawCrsrVector
lea vEraseCursor,a0
move.l a0,EraseCrsrVector
IF LC930 THEN
bset.b #SkipDraw,CrsrDevFlags(a1) ; Do not draw the fisrt VBL just do the position calculations <SM6>
ENDIF
rts ; <H14>
;______________________________________________________________________________ <H15>
;
; Routine: SetCrsrDelay
;
; Inputs: a1 contains the ptr to the cursor gDevice being setup
;
; Outputs: -
;
; Destroys: a0,d0
;
; Function: This routine sets the screenDelay value in the CrsrDataRec
; to an appropriate delay value based on the screen type.
; This delay value is used by the cursor VBL as a minimum
; delay between subsequent cursor blits.
;______________________________________________________________________________
EXPORT SetCrsrDelay ; <H15>
SetCrsrDelay
movea.l ExpandMem,a0
cmpa.l #-1,a0 ;has ExpandMem been initialized?
beq.s @skipIt ; if not, then don't call b/c vector is not there
movea.l emCursorGlobals(a0),a0
move.l SetCrsrDelayVector(a0),d0 ;vector to the code that does the real work
beq.s @skipIt ;make sure the value has been initialized
movea.l d0,a0
jsr (a0) ; must preserve a1
@skipIt
IF padForOverpatch THEN
move.l CRSRPTR,A0 ;get handle to cursor data [padding]
MOVE.L (A0),A0 ;get pointer to cursor data
ENDIF
rts
;______________________________________________________________________________ <H15>
;
; Routine: SetCrsrDelCore
;
; Inputs: a1 contains the ptr to the cursor gDevice being setup
;
; Outputs: -
;
; Destroys: a0,d0
;
; Function: This routine sets the screenDelay value in the CrsrDataRec
; to an appropriate delay value based on the screen type.
; This delay value is used by the cursor VBL as a minimum
; delay between subsequent cursor blits.
;______________________________________________________________________________
SetCrsrDelCore
rts ; just a hook for now
;_____________________________________________________________________________________________ <H15>
; VDrawCursor - default DrawCursor routine
;
; The low level cursor routine DrawCursor, is now called through the expandmem vector
; emDrawCursorVector. This is the default routine which is set into the vector by
; the routine InitCrsrVects.
;
EXPORT VDrawCursor
IMPORT BLITCURSOR ;from ccrsrcore.a
VDrawCursor
MOVE.B #1,CRSRBUSY ;MARK CHANGE IN PROGRESS
TST CRSRSTATE
BMI.S DoneSho ;QUIT IF STILL HIDDEN
CLR CRSRSTATE ;DON'T LET CRSRSTATE GET > 0
TST.B CRSRVIS ;IS CURSOR ALREADY VISIBLE?
BNE.S DoneSho ;YES, DON'T TRY TO REDRAW
TST.B CrsrObscure ;Skip if obscured
BNE.S DoneSho
BSR.L BLITCURSOR ;Do the real work: put pixels up
DoneSho CLR.B CRSRBUSY ;CHANGE COMPLETE
RTS
;______________________________________________________________________________________________ <H15>
; VEraseCursor - default EraseCursor routine
;
; The low level cursor routine EraseCursor, is now called through the expandmem vector
; emEraseCursorVector. This is the default routine which is set into the vector by
; the routine InitCrsrVects.
;
EXPORT VEraseCursor
IMPORT UNBLITCURSOR ;from ccrsrcore.a
VEraseCursor
MOVE.B #1,CRSRBUSY ;MARK CHANGE IN PROGRESS
TST.B CRSRVIS ;IS CURSOR VISIBLE?
BEQ.S DoneHid ;NO, DON'T TRY TO REMOVE IT
BSR.L UNBLITCURSOR ;Zap Pixels
DoneHid CLR.B CRSRBUSY ;CHANGE COMPLETE
RTS
END
Reference in New Issue View Git Blame Copy Permalink