mirror of
https://github.com/elliotnunn/mac-rom.git
synced 2024-12-22 23:29:27 +00:00
4325cdcc78
Resource forks are included only for .rsrc files. These are DeRezzed into their data fork. 'ckid' resources, from the Projector VCS, are not included. The Tools directory, containing mostly junk, is also excluded.
1508 lines
47 KiB
Plaintext
1508 lines
47 KiB
Plaintext
;
|
|
; File: PromptForUser.a
|
|
;
|
|
; Copyright: © 1986-1992 by Apple Computer, Inc. All rights reserved.
|
|
;
|
|
; Change History (most recent first):
|
|
;
|
|
; <SM9> 11/3/92 SWC Fixed the change comment in <SM8>.
|
|
; <SM8> 11/3/92 SWC Changed ATalkEqu.a->AppleTalk.a.
|
|
; <24> 6/29/92 DTY For ROM and System builds, access IKeyScriptDone through
|
|
; ExpandMem.
|
|
; <23> 6/25/92 AC When entering passwords, change KeyScript to Roman if RomanOnly
|
|
; bit in resource is set. Re-sync selection with actual password
|
|
; when entire password gets selected after you've mistyped it.
|
|
; (This corrects bugs with two-byte passwords.)
|
|
; <22> 6/9/92 JSM Nuke systemCentersWindow conditional, itÕs always true.
|
|
; Integrate changes from SuperMario: In ROM builds or in TheFuture
|
|
; for System builds, use emPPCPromptForUserGlobals instead of
|
|
; pGlobals.
|
|
; <21> 4/2/92 FM #1020547 The password filter used to hardcode the bullet '¥'
|
|
; character which isn't internationally friendly. Now I set up the
|
|
; bullet character using the itl4 table. The routines to lookup
|
|
; the character are now in PromptForUser.c and were written by
|
|
; Kevin MacDonell
|
|
; <20> 2/11/91 EMT VC,82495: Fix bug that prevents backspacing after 8 characters
|
|
; have been typed, Arrow keys now function properly in password,
|
|
; Function keys are now ignored.
|
|
; <19> 1/14/91 EMT <VC> Fix more bugs in PromptForUser
|
|
; <18> 1/4/91 EMT <VC> Fixed bug that caused some items be be partially drawn when
|
|
; they are supposed to be hidden. Also found and fixed cursor bug.
|
|
; Wrote new efficeint routine MySetCursor.
|
|
; <17> 12/13/90 EMT <JSM> Support 0 Length String to mean DefaultPrompt in
|
|
; StartSecureSession
|
|
; <16> 8/23/90 VC Fixed the handling of "Command-G" in the filter proc. (It was
|
|
; checking the wrong bit for whether trhe guest is disbaled.)
|
|
; <15> 8/21/90 VC Disabled "Command-G" when guest is disabled.
|
|
; <14> 8/18/90 dba get rid of centering, because Window Mgr. does it now; also, I
|
|
; noticed a lot of stuff (at least two things) that is not
|
|
; internationally friendly, and I marked it with ***; this code
|
|
; desperately needs code review
|
|
; <13> 8/14/90 VC Added the handling of Command-G and Command-R.
|
|
; <12> 8/9/90 S Changed cmdKey to cmdKeyMask (the cmdKey in SYSEQU.A seemd to
|
|
; be wrong)
|
|
; <11> 8/9/90 VC Implemented the "Command-." option to cancel.
|
|
; <10> 5/27/90 JSM Use DCB.B again, now that LinkPatch supports it.
|
|
; <9> 5/15/90 VC In CopyPassword, set the string to NIL when the typed password
|
|
; is Nil.
|
|
; <8> 5/9/90 JSM Don't use DCB.B for pGlobals until LinkPatch supports it.
|
|
; <7> 4/26/90 VC Select the proper field after the Callback routine returns.
|
|
; <6> 3/26/90 S Fixed the crash of the dialog when guset is selected after a
|
|
; connection attemped is failed.
|
|
; <5> 3/20/90 S Fix the bug in StartSecureSession to return proper flag when
|
|
; guest is selected.
|
|
; <4> 2/27/90 S Fix Guest Selection Bug.
|
|
; <3> 1/30/90 S Condional Compile for Init and Patch resource IDs.
|
|
; 1/22/90 CVC 1.2 Combine PromptAndStart with PromptForUser
|
|
; <1.1> 11/28/89 CVC Added PromptAndStart call.
|
|
; 11/22/89 CVC 1.1 Added PromptAndStart
|
|
; <1.0> 10/12/89 CVC Adding Access Control for the first time.
|
|
; 10/11/89 RH 1.0d2 Save registers in the promptForUser routine
|
|
; 9/18/89 RH 1.0d1 Added glue code
|
|
; 9/15/89 RH 1.0d1 More fixes and changes to displaying code
|
|
; 9/6/89 RH 1.0d1 Made changes in the PromptForUser routine to fix bugs when
|
|
; entering a password
|
|
; 9/3/89 RH 1.0d1 New Today
|
|
;
|
|
|
|
TITLE 'Prompt For User'
|
|
|
|
; Utility login window routine that can be called by any app to
|
|
; bring up a 'standard' dialog that prompts for user name and password.
|
|
;
|
|
; Ruth Hennigar (code stolen from AppleShare Workstation)
|
|
|
|
BLANKS ON
|
|
STRING ASIS
|
|
|
|
LOAD 'StandardEqu.d'
|
|
INCLUDE 'AppleTalk.a'
|
|
INCLUDE 'PromptForUserEqu.a'
|
|
PRINT ON
|
|
PRINT NOGEN
|
|
|
|
if &trim(&type('INIT')) = 'UNDEFINED' then
|
|
pswdStrStart EQU -16409 ; password text string resource ID start
|
|
PrmtDlogID EQU -16409 ; dialog resource ID
|
|
|
|
else
|
|
pswdStrStart EQU -930 ; password text string resource ID start (Init)
|
|
PrmtDlogID EQU -930 ; dialog resource ID
|
|
|
|
endif
|
|
|
|
PWDRmolyR equ 'GNRL' ; Password Roman Only Resource
|
|
PWDRmolyID equ -16490 ; Password Roman Only Resource ID
|
|
|
|
|
|
PrmtFUser PROC EXPORT
|
|
EXPORT PromptForUser
|
|
IMPORT GetPasswordBullet
|
|
;________________________________________________________________________________
|
|
;
|
|
; Routine: PromptForUser
|
|
;
|
|
; Function: Glue code that calls the PromptUser routine that brings up a
|
|
; dialog that asks for userName and Password
|
|
;
|
|
; Pascal interface:
|
|
; Function PromptForUser (PromptStr: ^STR;
|
|
; IconHdl: Handle;
|
|
; UserName: ^Str[32]
|
|
; Password: ^Str[8];
|
|
; SelectedItem: INTEGER; {5=userName, 7=password}
|
|
; GuestOk: BOOLEAN;
|
|
; VAR loginMethod: INTEGER {1=guest, 2=Cleartext pswd, 3=RandNum Exchange pswd}
|
|
; int (*callBack)();
|
|
; startPb: PPCStartParam)
|
|
;
|
|
; : INTEGER;
|
|
;________________________________________________________________________________
|
|
;
|
|
;
|
|
PromptForUser
|
|
LINK A6,#0 ; Set up A6 -> stack
|
|
MOVEM.L D2-D5/A2-A5,-(SP) ; save some registers
|
|
|
|
; At this point, the stack looks as follows:
|
|
;
|
|
; (A6) --> Old A6
|
|
; 4(A6) --> Return address
|
|
; 8(A6) --> Start PB
|
|
; 12(A6) --> callBack proc
|
|
; 16(A6) --> login method
|
|
; 20(A6) --> guestOK
|
|
; 22(A6) --> selected item
|
|
; 24(A6) --> password
|
|
; 28(A6) --> username
|
|
; 32(A6) --> icon handle
|
|
; 36(A6) --> prompt string
|
|
; 40(A6) --> Return value
|
|
;
|
|
MOVE.L 8(A6),D5 ; Copy PB into D5
|
|
MOVE.L 12(A6),D4 ; Copy callBack proc into D4
|
|
MOVE.L 16(A6),A4 ; A4 -> address of login method
|
|
MOVE.W (A4),D1 ; Copy login method into D1
|
|
MOVE.B 20(A6),D3 ; Copy guest ok? into D3
|
|
MOVE.W 22(A6),D2 ; Copy selected item into D2
|
|
MOVE.L 24(A6),A3 ; Copy password address into A3
|
|
MOVE.L 28(A6),A2 ; Copy user name address into A2
|
|
MOVE.L 32(A6),A0 ; Copy icon handle into A0
|
|
MOVE.L 36(A6),A1 ; Copy prompt string into A1
|
|
BSR.S PromptUser ; call routine
|
|
MOVE.W D0,40(A6) ; Return final result
|
|
MOVE.L 16(A6),A0 ; A0 -> address of login method
|
|
MOVE.W D1,(A0) ; return method selected
|
|
|
|
MOVEM.L (SP)+,D2-D5/A2-A5 ; restore registers
|
|
UNLK A6 ; Pop off the call frame
|
|
MOVE.L (SP)+,A0 ; Save the return address
|
|
ADDA.W #32,SP ; Pop off the incoming arguments
|
|
JMP (A0) ; And call it a day.
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: PromptUser
|
|
;
|
|
; This routine brings up the 'same' window as the Chooser's file server
|
|
; device package. It's purpose is to allow the user to enter his/her
|
|
; password and UAM (if this makes sense).
|
|
;
|
|
; Note that since this dialog is just like the device pkg's, we use the
|
|
; same DLOG and DITL resource.
|
|
;
|
|
; Entry: D1 = login method (2=Cleartext pswd, 3=RandNum Exchange pswd)
|
|
; D2 = selected item (user name=5 or password=7)
|
|
; D3 = guest login okay? (0=no, 1=yes) (byte)
|
|
; A0 -> icon handle
|
|
; A1 -> prompting string
|
|
; A2 -> user name string (optional)
|
|
; A3 -> password string (optional)
|
|
; D4 -> CallBack proc
|
|
; D5 -> Start PB
|
|
; Exit: D0 = negative if error or Cancel occurred
|
|
; D1 = login method (1=Guest, 2=Cleartext pswd, 3=RandNum Exchange pswd)
|
|
; A2 -> user name string (blank if guest is selected)
|
|
; A3 -> password character string (blank if guest is selected)
|
|
;
|
|
; All registers preserved.
|
|
;
|
|
|
|
; Stack frame equates
|
|
|
|
pswType EQU -2 ; item type used by Dialog Mgr calls (don't move this!)
|
|
pswIHandle EQU pswType-4 ; handle to item (don't move this!)
|
|
pswBox EQU pswIHandle-8 ; item rect (don't move this!)
|
|
pswSavePort EQU pswBox-4 ; saved grafport
|
|
pswDialogPtr EQU pswSavePort-4 ; PW dialog ptr
|
|
pswItemHit EQU pswDialogPtr-2 ; item selected from Modal dialog
|
|
pswUname EQU pswItemHit-4 ; pointer to user name storage
|
|
pswPwdPtr EQU pswUname-4 ; storage for passward chars pointer
|
|
pswIcon EQU pswPwdPtr-4 ; storage for icon pointer
|
|
pswSelItem EQU pswIcon-2 ; item to be selected
|
|
pswMethod EQU pswSelItem-2 ; temporary storage for login method
|
|
pswPbPtr EQU pswMethod-4 ; temporary storage for Pb
|
|
pswCallbackPtr EQU pswPbPtr-4 ; temporary storage for Callback Proc
|
|
pswSize EQU pswCallbackPtr ; size of local variables
|
|
|
|
PromptUser
|
|
LINK A6,#pswSize ; stack frame
|
|
MOVEM.L D2-D5/A0-A4,-(SP) ; save registers
|
|
MOVE.L A4,pswIcon(A6) ; save the ptr to the icon
|
|
MOVE.L A2,pswUname(A6) ; save the ptr to the user name
|
|
MOVE.L A3,pswPwdPtr(A6) ; save the ptr to the password
|
|
MOVE.W D2,pswSelItem(A6) ; save the item to be selected
|
|
MOVE.L D5,pswPbPtr(A6) ; save the pb pointer
|
|
MOVE.L D4,pswCallbackPtr(A6) ; save the Callback pointer
|
|
|
|
IF forROM or TheFuture THEN ; canÕt have data inside code in ROM <22>
|
|
|
|
MOVE.L ExpandMem,A4 ; A4 -> Expanded Low Memory <22>
|
|
MOVE.L ExpandMemRec.emPPCPromptForUserGlobals(A4),A4 ; A4-> ptr to globals <22>
|
|
|
|
ELSE ; <22>
|
|
|
|
LEA pGlobals,A4 ; A4 -> our globals
|
|
|
|
ENDIF ; forROM or TheFuture <22>
|
|
|
|
MOVE D1,pMethod(A4) ; save the login method
|
|
MOVE D1,pswMethod(A6) ; save the login method in temp storage
|
|
MOVE.B D3,pGuestAllowed(A4) ; save the guest boolean
|
|
MOVE.L A1,pPrompt(A4) ; save the prompt string
|
|
MOVE.L A0,pIconHdl(A4) ; save the icon handle
|
|
PEA pswSavePort(A6) ; save area for port
|
|
_GetPort
|
|
;
|
|
; Bring up the dialog
|
|
;
|
|
@10 SUBQ #4,SP ; room for result
|
|
MOVE #PrmtDlogID,-(SP) ; dialog ID
|
|
CLR.L -(SP) ; no storage
|
|
MOVE.L #-1,-(SP) ; behind param
|
|
_GetNewDialog ; initially invisible
|
|
MOVE.L (SP),A3 ; copy dialog hdl into A3
|
|
MOVE.L A3,pswDialogPtr(A6) ; save it away
|
|
_SetPort
|
|
|
|
;
|
|
; Set the prompt string in the dialog
|
|
;
|
|
MOVE.L pPrompt(A4),D0 ; Set condition code
|
|
BEQ.S @12 ; Don't set item text if NIL
|
|
MOVE.L D0,A2 ; A2 -> prompt string
|
|
MOVE #fItemPromptText,D0 ; item number
|
|
BSR SetDIText ; set item text
|
|
@12 MOVE #sysFont,-(SP) ; set font to system (Chicago)
|
|
_TextFont
|
|
;
|
|
; put icon in dialog
|
|
;
|
|
MOVE.L pIconHdl(A4),D0 ; move handle into D0
|
|
BEQ.S @15 ; it's NIL, don't plot it
|
|
PEA IconRect ; push the icon rect location
|
|
MOVE.L pIconHdl(A4),-(SP) ; push handle to icon
|
|
_PlotIcon
|
|
;
|
|
; Put user name in dialog;
|
|
;
|
|
@15 MOVE #fItemUNameEdit,D0 ; item number
|
|
MOVE.L pswUname(A6),A2 ; get the ptr to the user name
|
|
BSR SetDIText ; set item text
|
|
;
|
|
; get a handle to the text edit item for later
|
|
;
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE #fItemUNameEdit,-(SP) ; item number
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L pswIHandle(A6),pPWDlogUNameHdl(A4) ; save hdl to user name text
|
|
;
|
|
; Create a TERecord for the password characters
|
|
;
|
|
SUBQ #4,SP ; room for result
|
|
PEA OffScrRect ; dest rect
|
|
PEA OffScrRect ; view rect
|
|
_TENew
|
|
MOVE.L (SP)+,pPwdTEHandle(A4) ; save TEHandle
|
|
|
|
;
|
|
; Set up the bullet character the international wayÉ <21>
|
|
;
|
|
SUBQ #2,SP ; room for return char '¥' <21>
|
|
JSR GetPasswordBullet ; go get itÉ <21>
|
|
MOVE.B (SP)+,pBulletChar(A4) ; save the bullet for later <21>
|
|
;
|
|
; If the password was passed, then put it in the edit records
|
|
;
|
|
MOVE.L pPwdTEHandle(A4),D2 ; D2 -> TE handle
|
|
MOVE.L pswPwdPtr(A6),A2 ; A2 -> callers string storage
|
|
BSR PutPswdInDlog ; insert the password if it was specified
|
|
;
|
|
; If we're in the password edit text, switch to Roman script. - AMC/AKN 6/24/92
|
|
; This feature can be disabled with a bit in a resource.
|
|
;
|
|
movem.l d0-d2/a0-a2,-(sp) ; Save some reg's
|
|
|
|
if (forROM or theFuture) then
|
|
move.l ExpandMem,a0 ; <24>
|
|
move.l ExpandMemRec.emPPCPromptForUserGlobals(a0),a0 ; <24> Pointer to PPC globals
|
|
lea PromptForUserGlobalsRec.IKeyScriptDone(a0),a0 ; <24> Pointer to IKeyScriptDone
|
|
else
|
|
lea IKeyScriptDone,a0 ; IKeyScriptDone indicates already switched to Roman
|
|
endif
|
|
|
|
move.w #0,(a0) ; Initialize the flag KeyScriptDone
|
|
move pswSelItem(a6),d0 ; Get selected item
|
|
cmp.w #fItemPEdit,d0 ; Is it Password Item?
|
|
bnz @17 ; No, don't switch script to Roman
|
|
|
|
subq #4,sp ; Room for result
|
|
move.l #PWDRmolyR,-(sp) ; Push resource type
|
|
move.w #PWDRmolyID,-(sp) ; Push resouce ID
|
|
_GetResource ; Fetch the resource
|
|
move.l (sp)+,a0 ; Pop resource handle
|
|
cmpa.l #0,a0 ; Is there an address there?
|
|
beq @17 ; No, don't switch script to Roman
|
|
move.l (a0),a1 ; Otherwise, get pointer
|
|
move.b (a1),d0 ; Get resource data
|
|
cmpi.b #1,d0 ; If the switch is 1, call KeyScript
|
|
bne @17 ; Otherwise don't switch to Roman
|
|
move.w #smRoman,-(sp) ; Set KeyScript Roman in Password EditText
|
|
_KeyScript
|
|
|
|
if (forROM or theFuture) then
|
|
move.l ExpandMem,a0 ; <24>
|
|
move.l ExpandMemRec.emPPCPromptForUserGlobals(a0),a0 ; <24> Pointer to PPC globals
|
|
lea PromptForUserGlobalsRec.IKeyScriptDone(a0),a0 ; <24> Pointer to IKeyScriptDone
|
|
else
|
|
lea IKeyScriptDone,a0 ; IKeyScriptDone indicates already switched to Roman
|
|
endif
|
|
|
|
move.w #1,(a0) ; Don't need to set KeyScript anymore
|
|
@17 movem.l (sp)+,d0-d2/a0-a2 ; Restore reg's
|
|
;
|
|
; select the text item specified
|
|
;
|
|
MOVE pswSelItem(A6),D0 ; D0 = item number to be selected
|
|
BSR SelText ; select the text
|
|
;
|
|
; highlight the correct buttons in the dialog
|
|
;
|
|
TST.B D3 ; is guest login allowed
|
|
BNE.S @20 ; yep, branch
|
|
MOVE #fItemGuest,D0 ; which one to dim
|
|
MOVE #255,D1 ; control will be set to this (dim)
|
|
BSR HiliteItem ; dim the guest radio button
|
|
@20 MOVE pMethod(A4),D1 ; D1 = method (cleartext, scrambled..)
|
|
BSR SetPswdType ; set up the string for password type
|
|
MOVE #fItemRegistered,D0 ; which one to hilite
|
|
MOVE #1,D1 ; control set to 1
|
|
BSR SetCtlItem ; set control
|
|
MOVE.L A3,-(SP) ; push window ptr
|
|
_ShowWindow
|
|
;
|
|
; This is the modal dialog loop
|
|
;
|
|
DialogLoop
|
|
MOVE.L pswDialogPtr(A6),A3 ; Restore the dialog pointer
|
|
BSR SetArrowCurs ; set the arrow cursor
|
|
PEA PSWFilter ; set filter proc
|
|
PEA pswItemHit(A6) ; item hit variable
|
|
_ModalDialog
|
|
;
|
|
; If we're in the password edit text, switch to Roman script. - AMC/AKN 6/24/92
|
|
; This feature can be disabled with a bit in a resource.
|
|
;
|
|
movem.l d0-d2/a0-a2,-(sp) ; Save some reg's
|
|
cmp #fItemPEdit,pswItemHit(A6) ; Password EditText hit?
|
|
bne.s @189 ; No, don't switch to Roman script
|
|
subq #4,sp ; Check resource switch
|
|
move.l #PWDRmolyR,-(sp) ; Push resource type
|
|
move.w #PWDRmolyID,-(sp) ; Push resource ID
|
|
_GetResource ; Fetch the resource
|
|
move.l (sp)+,a0 ; Pop resource handle
|
|
cmpa.l #0,a0 ; Is there an address there?
|
|
beq @190 ; No, don't switch to Roman script
|
|
move.l (a0),a1 ; Otherwise, get pointer
|
|
move.b (a1),d0 ; Get resource data
|
|
cmpi.b #1,d0 ; If the switch is 1, call KeyScript
|
|
bne @190 ; Otherwise don't switch to Roman
|
|
|
|
if (forROM or theFuture) then
|
|
move.l ExpandMem,a0 ; <24>
|
|
move.l ExpandMemRec.emPPCPromptForUserGlobals(a0),a0 ; <24> Pointer to PPC globals
|
|
lea PromptForUserGlobalsRec.IKeyScriptDone(a0),a0 ; <24> Pointer to IKeyScriptDone
|
|
else
|
|
lea IKeyScriptDone,a0 ; IKeyScriptDone indicates already switched to Roman
|
|
endif
|
|
|
|
move.w (a0),d0 ; Get its value
|
|
bnz @190 ; Already set, we're done
|
|
move.w #1,(a0) ; Don't need to set KeyScript anymore
|
|
|
|
move.w #smRoman,-(sp) ; Set KeyScript Roman in Password EditText
|
|
_KeyScript
|
|
bra @190 ; We're done with Roman script switch
|
|
|
|
@189
|
|
cmp #fItemUNameEdit,pswItemHit(A6) ; User name EditText hit?
|
|
bne.s @190 ; No, get out
|
|
if (forROM or theFuture) then
|
|
move.l ExpandMem,a0 ; <24>
|
|
move.l ExpandMemRec.emPPCPromptForUserGlobals(a0),a0 ; <24> Pointer to PPC globals
|
|
lea PromptForUserGlobalsRec.IKeyScriptDone(a0),a0 ; <24> Pointer to IKeyScriptDone
|
|
else
|
|
lea IKeyScriptDone,a0 ; IKeyScriptDone indicates already switched to Roman
|
|
endif
|
|
|
|
move.w #0,(a0) ; May need to set KeyScript now
|
|
@190
|
|
movem.l (sp)+,d0-d2/a0-a2 ; Restore reg's
|
|
|
|
CMP #fItemGuest,pswItemHit(A6) ; control hit?
|
|
BNE.S @200 ; nope, branch
|
|
BSR ClearMethButtons ; zero out all buttons
|
|
MOVE #fItemGuest,D0 ; D0 = button to set
|
|
MOVE #1,D1 ; control set to 1
|
|
BSR SetCtlItem ; set it
|
|
BSR HideUName
|
|
MOVE #noUserAuth,pswMethod(A6) ; save guest as the method
|
|
BRA.S @250 ; branch
|
|
@200 CMP #fItemRegistered,pswItemHit(A6) ; button hit?
|
|
BNE.S @220 ; nope, branch
|
|
BSR ClearMethButtons ; zero out all radio buttons
|
|
MOVE #fItemRegistered,D0 ; D0 = button to set
|
|
MOVE #1,D1 ; control set to 1
|
|
BSR SetCtlItem ; set it
|
|
BSR RestoreUName
|
|
MOVE pMethod(A4),pswMethod(A6) ; save password method passed as the method
|
|
BRA.S @250 ; branch
|
|
;
|
|
; Test to see if a button was hit
|
|
;
|
|
@220 CMP #fItemOKButton,pswItemHit(A6) ; button hit?
|
|
BLT.S @250 ; nope, branch (ignore it)
|
|
BEQ.S ButtonOK ; if OK was hit then branch
|
|
CMP #fItemCancelButton,pswItemHit(A6) ; cancel button hit?
|
|
BEQ.S ButtonCancel ; if it was then branch
|
|
@250 BRA.S DialogLoop ; branch to loop place
|
|
;
|
|
; The OK button was hit. Do the action.
|
|
;
|
|
ButtonOK
|
|
;
|
|
; Put user name and password chars into buffers
|
|
;
|
|
MOVE.L pswUName(A6),A2 ; A2 -> string to be returned to caller
|
|
MOVE pswMethod(A6),D1 ; D1 = login method chosen
|
|
BSR CopyUName ; copy the string in the dialog back to the caller
|
|
MOVE.L pPwdTEHandle(A4),A1
|
|
MOVE.L pswPwdPtr(A6),A3 ; A3 -> callers string storage
|
|
MOVE pswMethod(A6),D1 ; D1 = login method chosen
|
|
BSR CopyPassword ; copy password into the buffer the caller provided
|
|
MOVEQ #noErr,D0 ; set no errors
|
|
CMPI.L #0,pswCallbackPtr(A6)
|
|
BEQ.S DialogDone
|
|
;
|
|
; !!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
;
|
|
MOVE.L pswPbPtr(A6),-(SP)
|
|
MOVEQ #0,D1
|
|
MOVE.W pswMethod(A6),D1
|
|
EXT.L D1
|
|
MOVE.L D1,-(SP)
|
|
MOVE.L pswUName(A6),-(SP)
|
|
MOVE.L pswPwdPtr(A6),-(SP)
|
|
MOVE.L pswCallbackPtr(A6),A0
|
|
JSR (A0)
|
|
;
|
|
; Upon return D0 should contain one of the following info:
|
|
; 0= if want to close the dialog.
|
|
; 5= select the userName
|
|
; 7= select the password
|
|
;
|
|
TST.W D0
|
|
BEQ.S DialogDone
|
|
CMP #fItemUNameEdit,D0
|
|
BEQ SelectItem
|
|
CMP #fItemPEdit,D0
|
|
BEQ SelectItem
|
|
BRA DialogLoop ; branch to loop place
|
|
SelectItem
|
|
MOVE.L pswDialogPtr(A6),A3 ; Restore the dialog pointer
|
|
BSR SelText ; select the text
|
|
BRA DialogLoop ; branch to loop place
|
|
;
|
|
; An error occurred somewhere...
|
|
;
|
|
ButtonCancel
|
|
MOVEQ #-1,D0 ; set error code
|
|
;
|
|
; All done. Close up the dialog.
|
|
;
|
|
DialogDone
|
|
MOVE D0,-(SP) ; save error code
|
|
MOVE.L pswDialogPtr(A6),-(SP) ; push the dialog pointer
|
|
_DisposDialog ; get rid of it
|
|
MOVE.L pswSavePort(A6),-(SP) ; get saved graf port
|
|
_SetPort
|
|
MOVE.L pPwdTEHandle(A4),-(SP) ; password TERecord
|
|
_TEDispose
|
|
MOVE (SP)+,D0 ; restore error code
|
|
MOVE pswMethod(A6),D1 ; D1 = login method chosen
|
|
MOVEM.L (SP)+,D2-D5/A0-A4 ; save registers
|
|
UNLK A6 ; no more stack frame
|
|
RTS
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: PSWFilter
|
|
;
|
|
; Filter procedure for the Password window. It tests to see if a password
|
|
; character is being typed in. If so, it replaces it with a '¥' char
|
|
; and saves it away.
|
|
;
|
|
; Note that this routine is called from the Dialog manager and not from
|
|
; this device package. That means that there are no local variables. There
|
|
; are, however, globals.
|
|
;
|
|
|
|
; Parameters
|
|
|
|
;fItemHit .EQU 8 ; item hit var ptr
|
|
;fEventRec .EQU fItemHit+4 ; event record ptr
|
|
;fDlogPtr .EQU fEventRec+4 ; dialog ptr
|
|
;fBoolean .EQU fDlogPtr+4 ; boolean result
|
|
|
|
pwFLclMouse EQU -4 ; space for mouse pt
|
|
pwFLclSize EQU pwFLclMouse ; size of locals
|
|
|
|
PSWFilter
|
|
LINK A6,#pwFLclSize ; set up stack frame
|
|
MOVEM.L D0-D4/A0-A4,-(SP) ; save registers
|
|
MOVE.L fEventRec(A6),A1 ; A1 -> event record
|
|
MOVE.L fItemHit(A6),A2 ; A2 -> item hit variable
|
|
|
|
IF forROM or TheFuture THEN ; canÕt have data inside code in ROM <22>
|
|
|
|
MOVE.L ExpandMem,A4 ; A4 -> Expanded Low Memory <22>
|
|
MOVE.L ExpandMemRec.emPPCPromptForUserGlobals(A4),A4 ; A4-> ptr to globals <22>
|
|
|
|
ELSE ; <22>
|
|
|
|
LEA pGlobals,A4 ; A4 -> globals
|
|
|
|
ENDIF ; forROM or TheFuture <22>
|
|
|
|
CLR (A2) ; by default return itemHit as 0.
|
|
CLR fBoolean(A6) ; assume False
|
|
|
|
|
|
MOVE.L fDlogPtr(A6),A3 ; dialog window to be updated?
|
|
BSR MySetCursor ; First things first, make our cursor the right one.
|
|
MOVE evtNum(A1),D0 ; what is the event code?
|
|
CMP #keyDwnEvt,D0 ; is it keydown?
|
|
BEQ @10 ; yes, branch
|
|
CMP #autoKeyEvt,D0 ; how about auto key?
|
|
BEQ @10 ; yes, branch
|
|
CMP #updatEvt,D0 ; what about an update?
|
|
BEQ.S @04 ; yes, branch
|
|
BRA @90 ; nothing more to do, just exit
|
|
;
|
|
; An update has occurred. Redraw the misc information in the window.
|
|
;
|
|
@04 MOVE.L evtMessage(A1),A3 ; A3 -> window to be updated
|
|
CMP.L fDlogPtr(A6),A3 ; dialog window to be updated?
|
|
BNE @90 ; if not then just exit
|
|
;
|
|
; Continue updating screen: bold the OK button
|
|
;
|
|
MOVE #fItemOKButton,D0 ; button item number
|
|
BSR BoldButton ; make the button bold
|
|
MOVE.L pIconHdl(A4),A0 ; A0 -> icon handle
|
|
BSR DisplayIcon ; display the icon
|
|
MOVE.L fDlogPtr(A6),A3 ; dialog window ptr
|
|
BRA @90 ; pretend like I was never here.
|
|
;
|
|
; Process the key event
|
|
;
|
|
@10 MOVE.L evtMessage(A1),D1 ; D1 low byte = character
|
|
AND #$FF,D1 ; clear out all except the low byte
|
|
MOVE.W evtMeta(A1),D0
|
|
AND.W #cmdKeyMask,D0
|
|
BEQ @15 ; No Command Key
|
|
; Process the command key.
|
|
CLR D0 ; clear item number
|
|
CMP #rChar,D1 ; Is it Command-R?
|
|
BEQ @DoCmdR
|
|
CMP #gChar,D1 ; Is it Command-G?
|
|
BEQ @DoCmdG
|
|
CMP #periodChar,D1 ; Is it Command-.?
|
|
BEQ @DoCmdStop
|
|
|
|
; Last of all handle the edit functions.
|
|
CMP #'x',D1 ; Is it Command-X?
|
|
BEQ @IsEdit
|
|
CMP #'c',D1 ; Is it Command-C?
|
|
BEQ @IsEdit
|
|
CMP #'v',D1 ; Is it Command-V?
|
|
BEQ @IsEdit
|
|
BRA @BeepAndExit ; Ignore all other command keys.
|
|
|
|
; Handle Command-R
|
|
@DoCmdR
|
|
MOVE #fItemRegistered,D0 ; get the Guest button item
|
|
BRA @ExitCmdKey
|
|
|
|
; Handle Command-G
|
|
@DoCmdG
|
|
TST.B pGuestAllowed(A4) ; test the guest boolean
|
|
BEQ @ExitCmdKey ; no guest allowed, just blow off event.
|
|
MOVE #fItemGuest,D0 ; get the Guest button item
|
|
BRA @ExitCmdKey ;
|
|
|
|
; Handle Command-.
|
|
@DoCmdStop
|
|
MOVE #fItemCancelButton,D0 ; get the Cancel button item
|
|
BRA @ExitCmdKey
|
|
|
|
@IsEdit
|
|
MOVE.L fDlogPtr(A6),A3 ; A3 -> dialog
|
|
MOVE editField(A3),D0 ; D0 = edit text item field minus 1
|
|
ADDQ #1,D0 ; increment it
|
|
CMP #fItemPEdit,D0 ; is it in the password box?
|
|
BNE @ExitFilter ; Let Dialog Manager handle it.
|
|
|
|
@BeepAndExit
|
|
MOVE.W #2,-(SP) ; Push the duration onto the stack
|
|
_SysBeep
|
|
@ExitCmdKey
|
|
MOVE D0,(A2) ; set the item to be returned
|
|
BRA @80 ; exit with TRUE.
|
|
|
|
; Process a normal key stroke
|
|
@15 MOVE.L fDlogPtr(A6),A3 ; A3 -> dialog
|
|
MOVE editField(A3),D0 ; D0 = edit text item field minus 1
|
|
ADDQ #1,D0 ; increment it
|
|
CMP #crChar,D1 ; return key?
|
|
BEQ @70
|
|
CMP #enterChar,D1 ; enter key?
|
|
BEQ @70
|
|
CMP #noUserAuth,pMethod(A4) ; is the method OK?
|
|
BNE.S @20 ; if so then branch
|
|
BRA @80 ; all done, exit with TRUE.
|
|
;
|
|
; A key has been pressed for an active text edit box
|
|
;
|
|
@20 CMP #tabChar,D1 ; tab key?
|
|
BEQ @90 ; just ignore it if it was
|
|
CMP #clrChar,D1 ; is it a clear key?
|
|
BNE.S @25 ; no, branch
|
|
MOVE #bsChar,D1 ; else set character to backspace key
|
|
MOVE.L D1,evtMessage(A1) ; set character to bsKey
|
|
@25 CMP #fItemPEdit,D0 ; is it the password box?
|
|
BNE @60 ; if not then branch
|
|
|
|
; process char that was entered in the password box.
|
|
;
|
|
MOVE.L pPwdTEHandle(A4),A1 ; A1 = real char password handle
|
|
BSR TESelCopy ; copy the selection from the masked TE rec to the real one
|
|
|
|
CMP.B #funcKey,D1
|
|
BEQ @BeepAndExit
|
|
CMP.B #fwdDelete,D1 ; If I had time, this would work.
|
|
BEQ @BeepAndExit
|
|
CMP.B #leftArrow,D1
|
|
BEQ @90 ; Let Dialog Mangager handle it.
|
|
CMP.B #rightArrow,D1
|
|
BEQ @90
|
|
CMP.B #upArrow,D1
|
|
BEQ @90
|
|
CMP.B #downArrow,D1
|
|
BEQ @90
|
|
; Check for selection
|
|
MOVE.L teHandle(A3),A0 ; A0 = handle to dialog text edit record
|
|
MOVE.L (A0),A0 ; A0 -> text edit record
|
|
MOVE teSelEnd(A0),D2 ; get selection end
|
|
SUB teSelStart(A0),D2 ; any selection made
|
|
BNE @35 ; Don't check for max length if selection is made.
|
|
MOVE D0,(A2) ; return the item hit in the variable
|
|
CMP.B #bsChar,D1 ; is it a backspace?
|
|
BEQ @35 ; if so, don't bother checking for maximum length.
|
|
MOVE #maxUsrPwdLen,D0 ; D0 = maximum password length
|
|
BSR ChkLength ; check the password length
|
|
BNE @80 ; if error then branch
|
|
@35 MOVE D1,-(SP) ; Save a copy for later.
|
|
|
|
; Re-Sync password TE and maskChar TE for 2 byte code 6/20/92 AKN
|
|
; If the entire bullet-char-TE is selected, select all of real password TE
|
|
|
|
move.w d1,-(sp) ; Save d1
|
|
|
|
move.w teSelStart(a0),d0 ; Get start of selection
|
|
bnz @40 ; Not all of TE selected, then don't re-sync
|
|
|
|
move.w teSelEnd(a0),d0 ; Get end of selection
|
|
cmp.w teLength(a0),d0 ; Make sure selection goes to end of string
|
|
bnz @40 ; If it doesn't, don't re-sync
|
|
|
|
move.l #0,-(sp) ; Push SelStart
|
|
move.l #30000,-(sp) ; Push SelEnd
|
|
move.l pPwdTEHandle(A4),-(sp) ; Push actual password TE Handle
|
|
_TESetSelect ; Select entire string
|
|
|
|
; If theChar is two byte char, call TEDelete. This forces two byte password
|
|
; to start at beginning of actual password string.
|
|
|
|
movea.l sp,a0 ; A0 -> theChar
|
|
add.l #1,a0 ; Get low byte
|
|
sub #2,sp ; Room for result of CharByte
|
|
move.l a0,-(sp) ; Push address of theChar
|
|
move.w #0,-(sp) ; Push offset 0
|
|
_CharByte ; What kind of Char?
|
|
move.w (sp)+,d0 ; Get result
|
|
cmp.w #smFirstByte,d0 ; Is it 1st byte of two byte char?
|
|
bnz @40 ; No, don't do resync
|
|
|
|
move.l pPwdTEHandle(A4),-(sp) ; Push actual password TE Handle
|
|
_TEDelete ; Clear actual password
|
|
|
|
@40 move.w (sp)+,d1 ; restore D1
|
|
|
|
MOVE D1,-(SP) ; normal character
|
|
MOVE.L pPwdTEHandle(A4),-(SP) ; push handle to actual password characters
|
|
_TEKey ; update our hidden password.
|
|
MOVE (SP)+,D1 ; restore D1.
|
|
CMP #bsChar,D1 ; backspace key?
|
|
BEQ.S @90 ; Let Dialog Mangager handle backspace.
|
|
MOVE.L fEventRec(A6),A1 ; A1 -> event record
|
|
MOVE.B pBulletChar(A4),D1 ; Set D1 to the maskChar. <21>
|
|
MOVE.L D1,evtMessage(A1) ; change the event record so it shows up as a maskchar.
|
|
BRA.S @90 ; Have Dialog Manager handle the rest.
|
|
;
|
|
; A key was pressed for the user name edit box. Make sure it's a maximum of 31 characters or else
|
|
; a beep is sounded.
|
|
;
|
|
@60 CMP.B #bsChar,D1 ; backspace character?
|
|
BEQ.S @90 ; if so then exit (don't process it)
|
|
MOVE #uNameSize,D0 ; maximum length of name
|
|
BSR ChkLength ; calculate the text length
|
|
BNE.S @80 ; if over limit then exit (eat the event)
|
|
BRA.S @90 ; all done (let the dialog mgr take care of the event)
|
|
;
|
|
; A return or enter key was hit
|
|
;
|
|
@70 CLR D0 ; clear item number
|
|
MOVE #fItemOKButton,D0 ; get the OK button item
|
|
BSR HiliteOKButton ; hilite the OK button for a short time
|
|
MOVE D0,(A2) ; set the item to be returned
|
|
|
|
; Return TRUE.
|
|
@80 MOVE #$0100,fBoolean(A6) ; set function result to TRUE (eat the event)
|
|
;
|
|
; All done
|
|
;
|
|
@ExitFilter
|
|
@90 MOVEM.L (SP)+,D0-D4/A0-A4 ; restore registers
|
|
UNLK A6
|
|
MOVE.L (SP)+,A0 ; get return address
|
|
ADD.L #fPSize,SP ; strip parameters
|
|
JMP (A0) ; and return
|
|
|
|
;_________________________________________________________
|
|
;
|
|
; Routine : AbbreviateString
|
|
;
|
|
; Given a string and a max string length, shorten the string until it
|
|
; fits in the given space and append '...' to it if it is shortened.
|
|
;
|
|
; Entry: A0 -> source string
|
|
; A1 -> dest string
|
|
; D0 = max string length
|
|
;
|
|
AbbreviateString
|
|
MOVEM.L D0-D4/A0-A2,-(SP) ; save some registers
|
|
SF D4 ; clear shrink flag
|
|
MOVE D0,D3 ; save max str length
|
|
MOVE.L A1,D2 ; save str ptr
|
|
ADD #1,D2 ; D2 actually points to the text of the string
|
|
CLR D1
|
|
MOVE.B (A0),D1 ; D1 = length of current string
|
|
BSR StrCopy ; copy string into A1
|
|
@10 MOVEM.L D1-D2/A0-A1,-(SP) ; save registers
|
|
SUBQ #2,SP ; func result
|
|
MOVE.L D2,-(SP) ; push string text ptr
|
|
CLR -(SP) ; firstByte is always zero
|
|
MOVE D1,-(SP) ; push byteCount (string length)
|
|
_TextWidth ; check string length
|
|
MOVE (SP)+,D0 ; get string length
|
|
MOVEM.L (SP)+,D1-D2/A0-A1 ; restore registers
|
|
CMP D0,D3 ; how big is it currently?
|
|
BGE.S @20 ; if within range then branch
|
|
ST D4 ; set shrink flag
|
|
SUB #1,D1 ; decrement string length
|
|
BRA.S @10 ; and do it again
|
|
;
|
|
; First see if we shrunk the string down. If we did then append the ... to the string
|
|
;
|
|
@20 TST.B D4 ; shrink flag set?
|
|
BEQ.S @90 ; if cleared then branch
|
|
MOVE.L D2,A1 ; A1 -> new string text area
|
|
SUB #1,A1 ; A1 -> new string
|
|
MOVE.B D1,(A1) ; set new string length
|
|
LEA ThreeDotStr,A0 ; A0 -> our three dot string
|
|
BSR.S AppendString ; append string onto end
|
|
@90 MOVEM.L (SP)+,D0-D4/A0-A2 ; restore registers
|
|
RTS
|
|
;_________________________________________________________
|
|
;
|
|
; Routine : AppendString
|
|
;
|
|
; Append a string to the end of the string.
|
|
;
|
|
; Entry: A0 -> string to append
|
|
; A1 -> dest string
|
|
; Exit: A1 -> new string
|
|
;
|
|
; Called by: AbbrieviateString, MakePrompt
|
|
;
|
|
AppendString
|
|
MOVEM.L D0-D2/A0-A2,-(SP) ; save some registers
|
|
MOVE.L A1,A2 ; save start of string in A2
|
|
CLR D1 ; clear word
|
|
MOVE.B (A1),D1 ; D1 = length of dest string
|
|
BEQ.S @10 ; if zero length then branch
|
|
LEA 0(A1,D1),A1 ; point to end of string
|
|
@10 MOVE.B (A1),D2 ; save byte
|
|
MOVE.L A1,-(SP) ; save start of string
|
|
BSR StrCopy ; copy the string into temp storage
|
|
MOVE.L (SP)+,A1 ; A1 -> place in new string where append string is
|
|
TST.B D1 ; what's then length of the string
|
|
BEQ.S @20 ; if zero length then branch
|
|
MOVE.B (A0),D1 ; get length of appended string
|
|
ADD.B D1,(A2) ; fix length of new string
|
|
MOVE.B D2,(A1) ; restore byte saved earlier
|
|
@20 MOVEM.L (SP)+,D0-D2/A0-A2 ; restore registers
|
|
RTS
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: BoldButton
|
|
;
|
|
; This code outlines a button to be the default selection. This code is
|
|
; taken directly from ROM sources. Note that the button will not be
|
|
; bolded if the related button is in the dimmed mode.
|
|
;
|
|
; Entry: D0 = button item number in dialog
|
|
; A3 -> dialog
|
|
;
|
|
; All registers preserved.
|
|
;
|
|
bbType EQU -2 ; item type used by Dialog Mgr calls
|
|
bbIHandle EQU bbType-4 ; handle to item
|
|
bbBox EQU bbIHandle-8 ; item rect
|
|
BBSize EQU bbBox ; size of local variables
|
|
|
|
BoldButton
|
|
LINK A6,#BBSize ; set up stack frame
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA bbType(A6) ; type storage
|
|
PEA bbIHandle(A6) ; item handle storage
|
|
PEA bbBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L bbIHandle(A6),A0 ; A0 = handle to control
|
|
MOVE.L (A0),A0 ; A0 -> control record
|
|
CMP.B #$FE,contrlHilite(A0) ; test control hilite state
|
|
BLT.S @90 ; if inactive then branch
|
|
LEA bbBox(A6),A0 ; A0 -> OK button rect
|
|
MOVEQ #3,D0
|
|
MOVEQ #16,D1
|
|
MOVEQ #4,D2
|
|
MOVE.L A0,-(SP) ; rect
|
|
MOVE D2,-(SP) ; size for re-insetting
|
|
MOVE D2,-(SP)
|
|
MOVE.L A0,-(SP) ; rect
|
|
MOVE D1,-(SP) ; roundness
|
|
MOVE D1,-(SP)
|
|
MOVE.L A0,-(SP) ; rect
|
|
NEG D2
|
|
MOVE D2,-(SP) ; push size
|
|
MOVE D2,-(SP) ; push size
|
|
MOVE D0,-(SP) ; pensize
|
|
MOVE D0,-(SP)
|
|
_PenSize
|
|
_InsetRect
|
|
_FrameRoundRect
|
|
_InsetRect
|
|
_PenNormal ; back to the way it was
|
|
@90 MOVEM.L (SP)+,A0-A2/D0-D3 ; restore registers
|
|
UNLK A6
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: CheckForCursKey
|
|
;
|
|
; Check to see if the key passed in D1 was a cursor key. If it was then
|
|
; clear the returned flag.
|
|
;
|
|
; Entry: D1.B = key hit
|
|
; Exit: D0 = status of key hit: (ccr's set)
|
|
; zero = cursor key hit
|
|
; non-zero = no cursor key hit
|
|
;
|
|
; Called by: PWFilter, VPFilter
|
|
;
|
|
CheckForCursKey
|
|
MOVEQ #-1,D0 ; assume no cursor key hit
|
|
CMP.B #$1C,D1 ; cursor key range?
|
|
BLT.S @10 ; if less then branch
|
|
CMP.B #$1F,D1 ; check upper range
|
|
BGT.S @10 ; if out of bounds then branch
|
|
MOVEQ #0,D0 ; clear flag indicating cursor key hit
|
|
@10 RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: ChkLength
|
|
;
|
|
; Check to make sure the text is within the required length. Beep if
|
|
; it isn't
|
|
;
|
|
; Entry: A3 -> dialog record ptr
|
|
; D0 = maximum length of text
|
|
; Exit: CCR's set (z-bit set if no errors)
|
|
;
|
|
ChkLength
|
|
MOVEM.L A0-A4/D0-D2,-(SP) ; save registers
|
|
MOVE.L teHandle(A3),A0 ; A0 -> te Handle
|
|
MOVE.L (A0),A0 ; A0 -> te record
|
|
MOVE teLength(A0),D2 ; D2 = length of text
|
|
CMP D0,D2 ; is it within range?
|
|
BLT.S @05 ; yes, branch
|
|
;
|
|
; Password already 8 chars long, but if there's a selection then OK it
|
|
;
|
|
MOVE teSelEnd(A0),D1 ; D1 = selection start range
|
|
SUB teSelStart(A0),D1 ; D1 = number of bytes in selection
|
|
BLE.S @10 ; if there's no selection then branch
|
|
@05 CLR D2 ; set ccr's (no error)
|
|
BRA.S @20
|
|
@10 MOVE #beepLen,-(SP) ; length of beep
|
|
_SysBeep
|
|
MOVEQ #-1,D2 ; set ccr's
|
|
@20 MOVEM.L (SP)+,A0-A4/D0-D2 ; save registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: ClearMethButtons
|
|
;
|
|
; Clear all active user authentication buttons to zero.
|
|
;
|
|
; Entry: A3 -> PSW dialog
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
ClearMethButtons
|
|
MOVEM.L D0-D1,-(SP) ; save registers
|
|
MOVE #fItemGuest,D0 ; initial button number
|
|
CLR D1 ; hilite value = no
|
|
BSR SetCtlItem ; set control to zero
|
|
MOVE #fItemRegistered,D0 ; initial button number
|
|
CLR D1 ; hilite value = no
|
|
BSR SetCtlItem ; set control to zero
|
|
MOVEM.L (SP)+,D0-D1 ; restore registers
|
|
RTS
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: CopyPassword
|
|
;
|
|
; Entry: A1 -> TE Handle
|
|
; A3 -> buffer to copy password into
|
|
; D1 = login method chosen
|
|
; Exit: A3 -> buffer filled with password
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
CopyPassword
|
|
CMP #noUserAuth,D1 ; guest?
|
|
BNE.S @05 ; nope.. branch
|
|
MOVE.B #0,(A3) ; return NIL string
|
|
BRA.S @40 ; return
|
|
@05 MOVEM.L A0/A1/A3/D0/D3,-(SP) ; save registers
|
|
MOVE.L (A1),A0 ; A0 -> te rec ptr
|
|
MOVE teLength(A0),D3 ; D3 = length of text
|
|
BNE.S @06
|
|
MOVE.B #0,(A3)
|
|
BEQ.S @20 ; if nothing there then branch
|
|
@06 SUBQ #4,SP ; make space
|
|
MOVE.L A1,-(SP) ; push te handle
|
|
_TEGetText
|
|
MOVE.L (SP)+,A0 ; A0 -> te char ptr
|
|
MOVE.L (A0),A0 ; A0 -> characters
|
|
CLR.L D0 ; clear D0 long word
|
|
MOVE D3,D0 ; set length of data
|
|
MOVE.L A3,A1 ; get back ptr to storage
|
|
MOVE.B D3,(A1)+ ; set length into the string
|
|
_BlockMove
|
|
@20 MOVEM.L (SP)+,A0/A1/A3/D0/D3 ; restore registers
|
|
@40 RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: CopyUName
|
|
;
|
|
; Copies user name from dialog into a string buffer. If the user name
|
|
; is greater than uNameSize, then truncate it.
|
|
;
|
|
; Entry: A4 -> globals
|
|
; A2 -> buffer to copy name into
|
|
; D1 = login method chosen
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
cunStr EQU -256 ; string
|
|
cunSize EQU cunStr ; size of locals
|
|
|
|
CopyUName
|
|
CMP #noUserAuth,D1 ; guest?
|
|
BNE.S @05 ; nope.. branch
|
|
MOVE.B #0,(A2) ; return NIL string
|
|
BRA.S @40 ; return
|
|
@05 LINK A6,#cunSize ; allocate locals
|
|
MOVEM.L D0-D3/A0-A2,-(SP) ; save some registers
|
|
MOVE.L pPWDlogUNameHdl(A4),-(SP) ; A0 = handle to user name Dlog text record
|
|
PEA cunStr(A6) ; push ptr to space
|
|
_GetIText ; get that text!
|
|
LEA cunStr(A6),A0 ; A0 -> name string user typed in
|
|
MOVEQ #0,D0 ; clear length
|
|
CMP.B #uNameSize,(A0) ; get length byte
|
|
BLE.S @10 ; if less or equal then branch
|
|
MOVE.B #uNameSize,(A0) ; else set uName size
|
|
@10 MOVE.L A2,A1 ; A1 -> dest buffer
|
|
BSR StrCopy ; copy user name into buffer
|
|
MOVEM.L (SP)+,D0-D3/A0-A2 ; restore registers
|
|
UNLK A6
|
|
@40 RTS
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: MySetCursor
|
|
;
|
|
; Setup the cursor as appropriate
|
|
;
|
|
; Entry: A3 -> dialog ptr
|
|
;
|
|
; All registers preserved
|
|
;
|
|
MySetCursor
|
|
MOVEM.L A0-A3/D0-D4,-(SP) ; save registers
|
|
LINK A6,#-4 ; set up stack frame.
|
|
PEA -4(A6) ; VAR mouseLoc : Point
|
|
_GetMouse ; get mouse local coordinates.
|
|
MOVE.L A3,-(SP) ; Push Dialog Pointer
|
|
MOVE.L -4(A6),-(SP) ; mouseLoc moved onto stack.
|
|
_FindDItem ; Which item is the point over.
|
|
MOVE.W (SP)+,D0 ; Pop the item into D0.
|
|
CMP #fItemUNameEdit-1,D0 ; is mouse over user name edit box?
|
|
BEQ @25 ; yes it is.
|
|
CMP #fItemPEdit-1,D0 ; is mouse over password edit box?
|
|
BEQ @25
|
|
_InitCursor ; set cursor to arrow
|
|
BRA.S @26 ; branch to sub exit pt
|
|
@25 SUBQ #4,SP ; make room for curs handle
|
|
MOVE #iBeamCursor,-(SP) ; set cursor ID
|
|
_GetCursor
|
|
MOVE.L (SP)+,A0 ; A0 = curs handle
|
|
MOVE.L (A0),A0 ; A0 -> cursor
|
|
MOVE.L A0,-(SP) ; push cursor
|
|
_SetCursor ; set cursor to i-beam
|
|
@26 UNLK A6 ; restore stack frame
|
|
MOVEM.L (SP)+,A0-A3/D0-D4 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: DisplayIcon
|
|
;
|
|
; Display an icon in the top left corner of the current grafport
|
|
;
|
|
; Entry: A0 -> icon handle
|
|
;
|
|
; All registers preserved
|
|
;
|
|
|
|
DisplayIcon
|
|
MOVEM.L A0-A3/D0-D4,-(SP) ; save registers
|
|
PEA IconRect ; push the icon rect location
|
|
MOVE.L A0,-(SP) ; push handle to icon
|
|
_PlotIcon
|
|
MOVEM.L (SP)+,A0-A3/D0-D4 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: HideControlItem
|
|
;
|
|
; Hide the control item.
|
|
;
|
|
; Entry: D0 = control item number
|
|
; A3 -> dialog
|
|
; A6 -> local storage for item information
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
HideControlItem
|
|
MOVEM.L A0-A1/D0-D3,-(SP) ; save registers
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L pswIHandle(A6),-(SP) ; push handle to control
|
|
_HideControl
|
|
MOVEM.L (SP)+,A0-A1/D0-D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: HideUName
|
|
;
|
|
; Entry: A3 -> PSW dialog record
|
|
;
|
|
; Called by : PromptUser, PSWFilter
|
|
;
|
|
HideUName
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemUserTextLine,-(SP) ; hide the static string "Name".
|
|
_HideDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemUNameEdit,-(SP) ; hide the edit field for user name.
|
|
_HideDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemPTextLine,-(SP) ; hide the static string "Password".
|
|
_HideDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemPEdit,-(SP) ; hide edit field for password.
|
|
_HideDItem
|
|
|
|
MOVEM.L (SP)+,A0-A2/D0-D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: HiliteItem
|
|
;
|
|
; Highlight the control. This can be used to dim an item.
|
|
;
|
|
; Entry: D0 = item number
|
|
; D1 = value
|
|
; A3 -> dialog
|
|
; A6 -> local storage for item information
|
|
;
|
|
HiliteItem
|
|
MOVEM.L A0-A1/D0-D3,-(SP) ; save registers
|
|
MOVE D1,D3 ; save value in D3
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L pswIHandle(A6),-(SP) ; push handle to control
|
|
MOVE D3,-(SP) ; make inactive
|
|
_HiliteControl
|
|
MOVEM.L (SP)+,A0-A1/D0-D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: HiliteOKButton
|
|
;
|
|
; Hilite the OK button in the dialog box. This is used when the user
|
|
; types the Return or Enter key and the application wants to make it
|
|
; appear as though the mouse was pressed in the button.
|
|
;
|
|
; Entry: D0 = item number
|
|
; A3 -> dialog
|
|
;
|
|
hOKType EQU -2 ; item type used by Dialog Mgr calls
|
|
hOKIHandle EQU hOKType-4 ; handle to item
|
|
hOKBox EQU hOKIHandle-8 ; item rect
|
|
hOKSize EQU hOKBox ; size of locals
|
|
|
|
HiliteOKButton
|
|
LINK A6,#hOKSize ; make some space
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA hOKType(A6) ; type storage
|
|
PEA hOKIHandle(A6) ; item handle storage
|
|
PEA hOKBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L hOKIHandle(A6),-(SP) ; push handle to control
|
|
MOVE #1,-(SP) ; set on
|
|
_HiliteControl
|
|
MOVE.L #5,A0 ; delay time
|
|
_Delay ; short delay
|
|
MOVE.L hOKIHandle(A6),-(SP) ; push handle to control
|
|
MOVE #0,-(SP) ; set off
|
|
_HiliteControl
|
|
MOVEM.L (SP)+,A0-A2/D0-D3 ; restore registers
|
|
UNLK A6
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: PutPswdInDlog
|
|
;
|
|
; This routine puts the password in dialog if there is one
|
|
;
|
|
; Entry: D2 = TE handle
|
|
; A2 -> password string
|
|
;
|
|
; Called by: PromptUser
|
|
;
|
|
PutPswdInDlog
|
|
MOVEM.L D0/D3,-(SP) ; save registers
|
|
CLR.L D3 ; clear out D3
|
|
MOVE.B (A2)+,D3 ; get length of string
|
|
BEQ.S @20 ; if nothing there then branch
|
|
;
|
|
; Insert the password into the actual TE record
|
|
;
|
|
MOVE.L A2,-(SP) ; push ptr to text chars
|
|
MOVE.L D3,-(SP) ; push length
|
|
MOVE.L D2,-(SP) ; push TE handle
|
|
_TESetText ; put password chars into text edit record
|
|
;
|
|
; Change the password characters and pad them with maskChars
|
|
;
|
|
@05 SUBQ #1,D3 ; set index value
|
|
@10 MOVE.B pBulletChar(A4),0(A2,D3) ; set password string with maskChars <21>
|
|
DBRA D3,@10 ; loop if necessary
|
|
SUBQ #1,A2 ; A2 -> masked password char string
|
|
MOVE #fItemPEdit,D0 ; item number
|
|
BSR SetDIText ; set password into dialog edit record
|
|
@20 MOVEM.L (SP)+,D0/D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: RestoreUName
|
|
;
|
|
; Set the password editable text edit box to be the one activated and
|
|
; cause a redraw of the name and password fields.
|
|
;
|
|
; Entry: A3 -> Dialog record
|
|
; A6 -> Dialog locals
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
RestoreUName
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemUserTextLine,-(SP) ; show the static string "Name".
|
|
_ShowDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemUNameEdit,-(SP) ; show the edit field for user name.
|
|
_ShowDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemPTextLine,-(SP) ; show the static string "Password".
|
|
_ShowDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemPEdit,-(SP) ; show edit field for password.
|
|
_ShowDItem
|
|
|
|
MOVE.L A3,-(SP)
|
|
MOVE #fItemPEdit,-(SP) ; Highlite user name.
|
|
CLR -(SP)
|
|
MOVE #1000,-(SP)
|
|
_SelIText
|
|
|
|
MOVEM.L (SP)+,A0-A2/D0-D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: SelText
|
|
;
|
|
; Select the entire dialog text edit record.
|
|
;
|
|
; Entry: A3 -> Dialog Ptr
|
|
; A6 -> local storage for item information
|
|
; D0 = edit text item number
|
|
;
|
|
SelText
|
|
MOVEM.L D0-D3/A0-A2,-(SP) ; save registers
|
|
MOVE D0,D3 ; save item number in D2
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D3,-(SP) ; item number (user name edit rect)
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D3,-(SP) ; item number
|
|
CLR -(SP) ; sel start = 0
|
|
MOVE #1000,-(SP) ; some large number for sel end
|
|
_SelIText
|
|
MOVEM.L (SP)+,D0-D3/A0-A2 ; restore registers
|
|
RTS
|
|
|
|
;_________________________________________________________
|
|
;
|
|
; Routine : SetArrowCurs
|
|
;
|
|
; Set the cursor back to an arrow. We are doing this in a subroutine
|
|
; just to ensure that all our registers don't get munged.
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
SetArrowCurs
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
_InitCursor
|
|
MOVEM.L (SP)+,A0-A2/D0-D3 ; save registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: SetCtlItem
|
|
;
|
|
; Set the value of the requested control. This can be used to either
|
|
; dim an item or just to turn an item on or off.
|
|
;
|
|
; Entry: D0 = item number
|
|
; D1 = value
|
|
; A3 -> dialog
|
|
; A6 -> local storage for item information
|
|
; Exit: locals modified
|
|
;
|
|
; Called by : PromptUser, ClearMethButtons
|
|
;
|
|
SetCtlItem
|
|
MOVEM.L A0-A1/D0-D3,-(SP) ; save registers
|
|
MOVE D1,D3 ; save value in D3
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L pswIHandle(A6),-(SP) ; push handle to control
|
|
MOVE D3,-(SP) ; value to set
|
|
_SetCtlValue
|
|
MOVEM.L (SP)+,A0-A1/D0-D3 ; restore registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: SetDIText
|
|
;
|
|
; Entry: A3 -> dialog record
|
|
; A2 -> text string to enter
|
|
; D0 = item number
|
|
; A6 -> local storage for item information
|
|
;
|
|
; All registers preserved.
|
|
;
|
|
; Called by : PromptUser, PutPswdInDlog, SetPswdType
|
|
;
|
|
SetDIText
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
MOVE.L A3,-(SP) ; dialog ptr
|
|
MOVE D0,-(SP) ; item number
|
|
PEA pswType(A6) ; type storage
|
|
PEA pswIHandle(A6) ; item handle storage
|
|
PEA pswBox(A6) ; rect storage
|
|
_GetDItem
|
|
MOVE.L pswIHandle(A6),-(SP) ; push item handle
|
|
MOVE.L A2,-(SP) ; string ptr
|
|
_SetIText
|
|
MOVEM.L (SP)+,A0-A2/D0-D3 ; save registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: SetPswdType
|
|
;
|
|
; Set the dialog stat text item to the appropriate password UAM.
|
|
;
|
|
; Entry: A3 -> dialog
|
|
; D1 = which UAM to set string to
|
|
; A6 -> local storage for item information
|
|
;
|
|
; All registers preserved.
|
|
;
|
|
; Called by : PromptUser
|
|
;
|
|
SetPswdType
|
|
MOVEM.L A0-A2/D0-D3,-(SP) ; save registers
|
|
SUBQ #4,SP ; space for result
|
|
NEG D1 ; make D1 negative so the next add does the right thing {RH}
|
|
ADD #pswdStrStart,D1 ; compute rsrc ID of string {RH}
|
|
MOVE D1,-(SP) ; ID of password type string
|
|
_GetString
|
|
MOVE.L (SP),A0 ; get handle
|
|
TST.L (SP)+ ; is it valid?
|
|
BEQ.S @10 ; if not then branch
|
|
_HLock ; lock the string down
|
|
MOVE.L (A0),A2 ; A2 -> text string
|
|
MOVE #fItemPwdType,D0 ; item number
|
|
BSR.S SetDIText ; set the dialog text
|
|
_HUnlock ; unlock the string
|
|
@10 MOVEM.L (SP)+,A0-A2/D0-D3 ; save registers
|
|
RTS
|
|
|
|
;_________________________________________________________
|
|
;
|
|
; Routine : StrCopy
|
|
;
|
|
; Copy a string. We have to special case for NIL source strings.
|
|
;
|
|
; Entry: A0 -> source string (incl length byte)
|
|
; A1 -> dest buffer
|
|
; Exit: A1 -> past buffer where string was copied
|
|
;
|
|
StrCopy
|
|
MOVEM.L A0/A2-A3/D0-D1,-(SP) ; save registers
|
|
MOVE.L A0,D0 ; is the string NIL?
|
|
BNE.S @10 ; if not then branch
|
|
MOVE.B #0,(A1)+ ; stuff a null pathname
|
|
BRA.S @30 ; and jump to completion
|
|
@10 CLR.L D0 ; clear out D0 longword
|
|
MOVE.B (A0),D0 ; length of string in D0
|
|
ADDQ #1,D0 ; includes the length byte too
|
|
MOVE.L A1,A3 ; save A1
|
|
ADD D0,A3 ; A3 -> after dest string
|
|
_BlockMove ; copy string to buffer
|
|
EXG A3,A1 ; on exit: A1 -> past copied string; A3 -> start of string
|
|
@30 MOVEM.L (SP)+,A0/A2-A3/D0-D1 ; restore registers
|
|
RTS ; go home
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Routine: TESelCopy
|
|
;
|
|
; Set the selection range of the actual password character TE record the same
|
|
; as the masked dialog TE password character record. This routine does not
|
|
; copy the data, only the selection range.
|
|
;
|
|
; Entry: A1 = real Char TE handle
|
|
; A3 -> dialog record
|
|
; A4 -> globals
|
|
;
|
|
; Called by PSWFilter
|
|
;
|
|
TESelCopy
|
|
MOVEM.L D0-D3/A0-A2,-(SP) ; save registers
|
|
MOVE.L teHandle(A3),A2 ; A2 = handle to dialog text edit record
|
|
MOVE.L (A2),A2 ; A2 -> text edit record
|
|
MOVE teSelStart(A2),D0 ; get selection start
|
|
EXT.L D0
|
|
MOVE.L D0,-(SP) ; push selection start pt of masked TERecord
|
|
MOVE teSelEnd(A2),D0 ; get selection end pt of masked TERecord
|
|
EXT.L D0
|
|
MOVE.L D0,-(SP) ; push selection end pt of masked TERecord
|
|
MOVE.L A1,-(SP) ; push handle to real password chars
|
|
_TESetSelect ; set the selection range of the real pswd chars
|
|
MOVEM.L (SP)+,D0-D3/A0-A2 ; save registers
|
|
RTS
|
|
|
|
;___________________________________________________________________________
|
|
;
|
|
; Our Globals and other constants
|
|
;
|
|
|
|
IF NOT (forROM or TheFuture) THEN ; canÕt use data inside code in ROM <22>
|
|
pGlobals DCB.B pGlobSize,0 ; our block of globals
|
|
|
|
IKeyScriptDone ds.w 1
|
|
|
|
ENDIF
|
|
|
|
ALIGN 2
|
|
|
|
OffScrRect DC.W $1000,$1000,$1100,$1100 ; rect or the offscreen password box
|
|
IconRect DC.W $0005,$0005,$0025,$0025 ; rect in the psw dialog box for icon
|
|
|
|
STRING PASCAL
|
|
ThreeDotStr
|
|
DC.B '...' ; three dot string *** NOT INTERNATIONAL FRIENDLY
|
|
ALIGN 2
|
|
|
|
END
|