;
;	File:		StyledTextEdit.a (formerly te68k_style.a)
;
;	Contains:	TextEdit for ROM or (when included in TextEditPatch.a) 'ptch' 0
;
;	Written by:	S Capps, M Kaptanoglu, R Wetmore, Sue Bartalo (most recently)
;
;	Copyright:	© 1982-1989, 1991 by Apple Computer, Inc., all rights reserved.
;
;	Change History (most recent first):
;
;		 <4>	 1/17/92	DCL		Backed out the previous change because this file is not supposed
;									to be touched.  Holy File.
;		 <3>	12/12/91	DCL		#1009157: Changed a Tst to Tst.b so as not to test the potential
;									garbage in the other byte. Changed procedure noClickProc in
;									TextEdit.a, StyledTextEdit.a, and TextEditPatchIIciROM.a
;		 <2>	 1/16/90	SMB		Included TextEditPriv.a
;		<1>		12/18/89	CCH		Adding for the first time into BBS.
; BBS versions above:
;___________________________________________________________________________________________________
;EASE READ ONLY COPY of file ÒStyledTextEdit.aÓ
; 1.7	SMB 08/25/1989  Removed load of nEqu.d.
; 1.6	smb 05/20/1989   Had to reset A2 to selStart(a3) in TECopy after a NewHandle call, which may
;		have invalidated the pointer to the teRecord (upon which A2 was based!). See bug #46036.
;		Fix for bug 39276: changed add operation in TECustomHook from a long op to a word op.
; 		Must lock the StScrpHandle for SetStylScrap to work correctly: see bug #36986.
; 1.5	smb 03/02/1989 Added Script Manager patch for setting up teSysJust from the system script
;		for Harpo.
; 1.4	SMB 02/22/1989 Replaced hardware casms with feature casms, and changed
;		routine names so they would not conflict with mpw includes. Also
;		removed additional equates that are in ToolEqu.a. Also renamed this
;		file from te68k_patch.a to StyledTextEdit.a to be used for Harpo Rom and
;		6.0.4 System builds.
; 1.3	SMB 02/22/1989 Test
; ¥1.2	CCH 02/15/1989 Submitting REAL 6.0.3 te68k source until BigBang sources
; 		get rolled in.
; FILE: TE68K.TEXT
; 	'/<RWW[0-9]Ç6È>[ÂNO]/'
; © Apple Computer, Inc. 1982-1988
; All Rights Reserved
;
;find /<<<END HISTORY>>>/ "{active}" # Execute to find the next available change number.
; ----------------------------------------------------------------------
;
; 		Text Edit
;
; 			Modification history:
;
; 			23-Jul-83	New Today
; 			 2-Aug-83	Code review changes:
; 						added std2Offset constant
; 						stdEntry points to param via A2
; 						changed #7 to #Lock
; 						moved epilog4
; 						flags trick in lock/unlock in stdentry/exit
; 						cleaned up selection safety chk in stdentry
; 						used grafGlobals(A5) instead of 0(A5)
; 						cleaned up(Ha!) TEClick
; 						Changed DoFind to handle top and pin H to DestRect
; 						switched end checks for teFind in DoText
; 						Changed and commented selsort- now returns A2^ to selStart
; 						callers of selSort now use A2
; 						Shortened rect stuff in RecalDraw
; 						CallBreak uses reg arguments instead of stack
; 			 3-Aug-83	Cleaned up TEKey a bit
; 						Cleaned up refresh a bit
; 						Changed all indices to unsigned (BGE's)
; 						Added idle proc for scroll and key
; 						Addes TEInsert
; 						Fixed the Bryan Stearns memorial 1-char bug in RecalDraw
; 						Added hilite hook for MicroSoft and other bizarre things
; 						Added caret hook too
; 						SetSelect uses longs
; 						Added TESetJust, TEGetText
; 			 5-Aug-83	Fixed a bug in FindLine
; 						Fixed bug in Recaline (now waits for whole text to finish)
; 						Optimized dobackgnd to always stop at end
; 			 6-Aug-83	Dropped total dobackgnd from recal(I guess addition IS communitive)
; 			 7-Aug-83	Reinstated total dobackgnd from recal(FUCK!)
; 			 8-Aug-83	Dropped pinrects and used extended rects in DoText to save code
; 			17-Aug-83	Fixed Rony bug in RecalDraw
; 			19-Aug-83	Added system double/caret times
; 			21-Aug-83	Added DoText and recal hooks
; 			25-Aug-83	Fixed unwind bug in stdexit
; 			25-Aug-83	Fixed Insert D7 bug
; 			 4-Sep-83	Fixed First char select bug in DoText
; 			 9-Sep-83	Fixed caret activate problem w/ inactive records
; 						Dropped background stuff(Finally gave up)
; 						Added global word break for Europe.
; 			12-Sep-83	Made InvertHook push the rectangle

; -----------------------------------------------------------------------

; 23 Jan 85	LAK	Adapted for new equate files.
; 24-Jan-85	EHB	Added patch in RecalDraw
; 25-Jan-85	EHB	Fixed Refresh to only hilight visible part of selection
; 25-Jan-85	EHB	Added Capp's TextBox fix
; 16-Jan-85	EHB	Fixed center/right justify in TextBox fix
; 03-May-85	SC	Fixed the <CR>-in-1st-char bug with word select.  FindWord
; 					would abort if the left char scan got to the beginning, but
; 					it wouldn't check if the 0th char was a break character or not
; 03-May-85	SC	Dropped forROM and for44T compile switches for readability
; 03-May-85	SC	New version of FindLine, cleaner and fixes bugs.  Still
; 					inefficient because it measures whole line repeatedly, but
; 					faster quickdraw fixes this.
; 03-May-85	SC	Made trim measure skip wordBreak code and only trim chars
; 					<= space.  This should truly measure only the black characters
; 					And not the word break chars now.
; 04-May-85	SC	Changed D2 usage in TEClick to D5 long sign bit
; 04-May-85	SC	SkipLoop in TrimMeasure could go negative
; 04-May-85	SC	Dropped DelGuts and InsGuts call from PasteGuts and made a
; 					combined inline call for munger speed.  Could make DelGuts and
; 					InsGuts inline since only 1 caller, but left that for another day
; 05-May-85	SC	Made StdEntry/Exit use LINK instructions not SP based
; 05-May-85	SC	TESetSelect trashed teSelPoint, cleaned up code a bit
; 05-May-85	SC	Dropped teSelPoint usage, get off stack frame instead of TeHandle
; 05-May-85	SC	Tricks played with A0 and teCarOn, teCarAct in DrawCaret, cleaned
; 					up for readability.
; 05-May-85	SC	Longized all the 0(A0,DX.L) and call to _TextWidth and _DrawText
; 05-May-85	SC	Fixed up recalLines to reduce flashiness
; 06-May-85	SC	DoFormat had an extra measure for left justify that was not needed
; 06-May-85	SC	DoText used tempRect, use stack frame instead
; 07-May-85	SC	Undo refresh hilite stuff, moved similar stuff to Hilite
; 08-May-85	SC	Added default click proc for auto scrolling
; 08-May-85	SC	Added TEPinScroll which does a pinned scroll (Not upward
; 					compatible so I couldn't include in real scroll, but it is
; 					used by the default click proc and TEScrollView
; 08-May-85	SC	Added TEScrollView which insures selection is visible before
; 					doing something.  Called from TEKey, TEPaste, TECut, TEIdle, etc.
; 09-May-85	SC	StdEntry/Exit save restore teTextH flags
; 09-May-85	SC	teLftClick not a byte, now the tefLeftClk bit in teFlags
; 09-May-85	SC	Made SelView local proc
; 09-May-85	SC	Dropped trim measure black stuff
; 09-May-85	SC	Made a local CalText proc to avoid StdEntry
; 11-May-85	SC	Completely trashed DoText, OffsetStuff, DoFormat and
; 					replaced them with a clean versions of DoFind, DoHilite,
; 					DoDraw, DoCaret.  This was to clean up the scaled fonts
; 					problem, the direct pen adjustment and general mayhem
; 					With the old DoText.
; 11-May-85	SC	Local proc Scroll broken out for use by TEScroll and TEPinScroll
; 11-May-85	SC	Reinstated teSelPoint, it's in documentation
; 11-May-85	SC	Added TEAutoView trap to enable/disable the auto scrolling
; 11-May-85	SC	Use _XMunger instead of _Munger
; 12-May-85	SC	New local proc MungeSetup to do common munger stuff
; 12-May-85	SC	Use D5 in recallines to hold telength
; 13-May-85	SC	Save/Restore text stuff in std entry/exit and made setlinarray
; 					avoid calling _GethandleSize(done once in stdEntry)
; 13-May-85	SC	Added preflight routine to check memory.  Called from
; 					pasteguts, insertGuts, and TextBox.  Did similar to TENew
; 15-May-85	SC	Multiple standard entries with stack peel amount in D1.  Does
; 					a preflight and then escapes if the preflight fails
; 18-May-85	SC	Put back DoText funnel for compatibility
; 18-May-85	SC	Dropped printable trim in FindLine @ end
; 18-May-85	SC	LineWidth didn't handle the line past teLength correctly
; 18-May-85	SC	Merged LineWidth and TrimMeasure
; 18-May-85	SC	Made trim measure skip wordBreak code and only trim chars
; 					<= space.  This should truly measure only the black characters
; 					And not the word break chars now. (Deja Vu - did this on 3 May
; 					but a bug in FindLine made it LOOK as though it didn't work
; 					so I undid it on 9-May)
; 18-May-85	SC	New routine PinDisplay replaces pin code in Hilite and Refresh
; 18-May-85	SC	Made DefClikProc obey autoScroll bit
; 20-May-85	SC	DoSearch longize D3-D4 (Thanks Bill and Larry)
; 20-May-85	SC	CleanupSel saved teTextH flags twice!!
; 20-May-85	SC	Fast TextBox didn't catch zero string length case (oops)
; 20-May-85	SC	SelView called before caret view in DelGuts and PasteGuts;
; 					should be after (leaves carets behind in Dialogs)
; 21-May-85	SC	Added negative length to Fast TextBox
; 23-May-85	SC	Dropped port save/restore font
; 	7-Jun-85	EHB	Fast TextBox shouldn't catch zero strings else no EraseRect(oops)
; 10-Jun-85	SC	CharbyChar had a BLT that should've been a BLE (It gets there
; 					by a BGE so it should stay in loop if BLE).
; 10-Jun-85	SC	DoText links a stack frame/DoBye and findDone UNLK
; 10-Jun-85	SC	In rangeRect, stuff the rect.left in tempRect and set pen to
; 					right for compatibility with old DoText
; 10-Jun-85	SC	DoSearch returns in D0 as before
; 15-Jun-85	SC	Undid "teLftClick not a byte, now the tefLeftClk bit in teFlags"
; 					had to drop back to old one for compatibility.  TERecback is
; 					now the TEFlags
; 15-Jun-85	SC	DoText must return ThePort in A0 for compatibility
; 16-July-85 SC	PinDisplay has new entry point for TEUpdate compatability
; 					Refresh changed to take A0 pointing to an update rect not
; 					D0/D1, calls PinA0Rect.
; 26-Jul-85	EHB	Added ShowCaret to end of TEPinScroll (needed for null scroll)
; 01-Oct-85	EHB	Set up D2 for all calls to CallBreak (identifies caller)
; 01-Oct-85	EHB	Added hooks for TrimMeasure, FindWord, and FindLine.
; 30-Oct-85	EHB	In DoFind, set up D3/D4 with selStart/selEnd before calling DoText
; 31-Oct-85	EHB	In RecalDraw, draw whole words if WordRedraw (new lowMem) is TRUE
; 31-Oct-85	EHB	Fast TextBox was scanning 0 len strings for CR's
; 01-Nov-85	EHB	If WordRedraw=0->draw normal, if >0 -> draw word, if <0 -> draw line
; 03-Nov-85	SC	Fixed special case D3=0 in DoCaret
; 05-Nov-85	EHB	Moved label to make WordRedraw fix work right

; --------------------------------- Lonely Heifer ROMs ----------------------------

; 14-Jan-85	EHB	In PasteGuts, call SelSort and get sel length for preflight
; 					Fix longize bug in the beginning of DoSearch
; 					Added cursor key support to TEKey

; <19feb86>	BBM Made some modifications to work under MPW

; --------------------------------- ROM 76 ----------------------------

; <C78/17jul86> MBK removed equates to an external file; added four new
; 				traps (TEStylNew, iTEStylPaste, iTESetStyle, iTEGetStyle);
; 				added the following new routines: SetOneStyle, GetDefStyle,
; 				ScanMeasure, GetLineHites, GetHite, CopyStyle, DeleteStyle,
; 				DecStyleCount, StylMeasure, SetLineHite, PasteStyle, MakeRoom,
; 				DupStyle, FindStyle, CompareStyles, AddStyle, ExtendStyle,
; 				FindLineHite, GetCurStyle, GetNumStyles, GetStyle,
; 				RecalstStarts, SetHiteAscent, SetStyle, ConcatStyles,
; 				ChangeStyle, and FindFeature; modified the following routines:
; 				TESetText, LineRect, PinDisplay, StdEntry, TECopy, DelGuts,
; 				RecalDraw, FindLine, RecalLines, SetLineArray, TEPaste,
; 				InsGuts, TEKey, TEPinScroll and TESelView.

; <C94/29jul86> MBK	Added 3 more traps (iTEReplaceStyle, TEGetOffset, TEFindStyle);
; 				renamed iTEGetStyle to TEFindStyle (iTEGetStyle now returns the
; 				style handle); fixed selection bug, the problem was in
; 				ScanMeasure and DoSearch. Fixed bug in CharByChar. Started
; 				fixing recalibration problem.

; <C95/4aug86>	MBK Fixed the scrolling problem in SelView; Modified
; 				Recallines to take into account changes in point size.

; <C105/3Sep86> MBK Renamed iTEGetStyle to iGetStylHandle and TEFindStyle to
; 				iTEGetStyle.  Added iSetStylHandle. Added TEDispatch to handle
; 				All style traps (except TEStylNew) with only 1 real trap for
; 				them all. Made the following changes for International:
; 				added the Pixel2Char, Char2Pixel, and HiliteText hooks;
; 				modified doSearch and doDraw to test teSysJust and perform
; 				their functions backwards if it's set; totally rewrote
; 				DoHilite.  Added NextLineRect to speed up DoDraw.  Rewrote
; 				stages 2 and 3 of Recal for speed.  Added new feature of
; 				Not resetting the line heights in Recallines if the high bit
; 				of the line height already stored is set.  Changed the
; 				iTESetStyle and iTEReplaceStyle input modes to be OR'able.
; 				Also combined the body of these 2 routines for efficiency.
; 				Added stuff to compute distance to be auto-scrolled for
; 				TERecs with style, in DefClikProc.  Changed BSET and BCLR
; 				of handles to _HLock and _HUnlock.

; <C139/10Sep86> MBK Fixed iTEGetStyle to return the grafport settings for
; 				records without style. Made addSize OR'able in StyleGuts.
; 				Fixed "index expected in D0" bug in DoSearch. Added
; 				DoMeasure, ChkBounds, and made FindLine call Pixel2Char
; 				for International.  Fixed word-wrapping with spaces. Put
; 				local equates back in this file and put the rest of the
; 				equates in nToolEqu.a. Got rid of scrp equates, since they
; 				were the same as the st- equates.

; <C182/6oct86> MBK Changed colorBit to clrBit since colorBit is a Quickdraw
; 				Trap already. Modified DoHilite to always measure from start
; 				of line, to fix highlighting problem with scaled fonts. Got
; 				rid of special code in PasteStyle to prevent style duplication,
; 				And just call ConcatStyles at the end. Added DoErase to fix
; 				italics erase problem. Removed code to shrink style runs array
; 				in ConcatStyles. Fixed problem of not clearing flag bits in
; 				ptrs before doing operations on an address. Changed color from
; 				LONGINT to RGBColor, and added Ernie's RGBForeColor and
; 				GetForeColor to handle this for the Alladin world.

; <C207/16oct86>MBK Fixed problem in which CR at bottom of ViewRect did not cause
; 				scrolling (cleaned up DefClikProc, which fixed the problem seen
; 				in the Poke program). Changed Pixel2Char not to expect a buffer
; 				ptr as input, and to allocate the space itself on the stack.
; 				Added StylTextBox. Changed scrpStartChar to a LONGINT. Changed
; 				TECopy and TEPaste not to touch the desk scrap if the TERec is
; 				an old one (since David G. mentioned a lot of old applications
; 				may need to preserve the desk scrap for Undo). Changed DoHilite
; 				back to what it was (except with middle lines being highlighted
; 				as a block for speed) because the International version was
; 				just too slow; this means I also removed the HiliteText hook.
; 				Modified RecalDraw to adjust the redraw selection according to
; 				changes in line height.

; <C229/29oct86>MBK Fixed 2 register preservation problems. Fixed InsertRecal
; 				memory overload problem. Redesigned method of updating line heights.

; <C381/8nov86>MBK	Made all changes resulting from code review.

; <C393/10nov86>MBK	Fixed CopyStyle and InsertRecal to reset ptr values after a
; 				memory allocation call (the ptrs were pointing to trash).

; --------------------------------- ROM 77 ----------------------------

; <C440/19nov86>MBK	Fixed SetLineHite to take the line height from the only style
; 				when text length is 0 (instead of using the system font as a default).
; 				Fixed RecalLines to consider the next character the start of the
; 				next line if the width of the viewRect is less than the width of
; 				a single character.  Fixed styleGuts to access FmDefaultSize as
; 				a byte, not a word.  Fixed RecalLines bug in which lines are not
; 				recalibrated when text is typed over a single CR.

; <C454/21nov86>MBK Fixed bug in RangeRect that caused selection to be off in MultiPlan.
; 				Fixed special case in which line redraw did not work, in RecalLines.

; <C475/02dec86>MBK Set the high bit of the pnMode before highlighting, to use the new
; 				background color highlighting method.

; <C485/04dec86>MBK Set the error code in D0 before calling SysError.  Fixed bug in which
; 				carets left on the screen were not getting erased (in Mac3D).

; <C513/12dec86>MBK Changed to clear bit in HiliteMode instead of setting bit in pnMode
; 				for color hilighting.  Fixed selection bug in Pixel2Char.

; <C574/30dec86>MBK Fixed SetStyle to save D2 on the stack because _RGBForeColor destroys it.
; 				Fixed Pixel2Char to restore D0 from D1 if NewPtr has to be called.

; <C597/06jan87>MBK Restore A3 ptr after RGBForeColor call in StdExit, in case TERec gets moved.

; <C622/13jan87>MBK Changed to clear the color highlight bit only if a highlight
; 				hook has not been installed (this was a problem with highlighting
; 				in the hex editor of ResEdit).  Modified DoErase to erase the previous
; 				character if the mode is XOR, otherwise redrawing it will wipe it out
; 				(this was a problem in NetTrek).  Modified StylMeasure to lock the style
; 				Record so that dereferenced pointer doesn't end up pointing to garbage.
; 				Also fixed Pixel2Char to do a signed comparison on the stack space.
; 				This bug was discovered by tEx, when the RAM cache was set high.

; ** BETA 3 **

; <C676/23jan87>MBK Added iGetStylScrap, PutStylScrap, iTEGetPoint, and iTEGetHeight.

; ** BETA 4 **

; <C717/28jan87>MBK Made changes in GetDefStyle, DoDraw, MeasureIt,
; 				StylMeasure, SetHiteAscent, and SetStyle to protect unlocked
; 				pointers from memory reallocation.  Added startLine and
; 				endLine input to iTEGetHeight.  Added RecalDraw to PutStylScrap.

; <C719/29jan87>MBK I removed the C717 change to SetHiteAscent.  The ptr there
; 				was not an offset from styleTab, it was an addr on the stack.

; ** BETA 5 **

; <C734/30jan87>MBK I changed PutStylScrap to iTEStylInsert, which unlike
; 				PutStylScrap will insert the text as well as the style info.
; 				Fixed StyleGuts to check for point sizes <= 0 when an addSize
; 				is done.  It now converts such values to 1. Modified iTEGetHeight
; 				to subtract 1 from startLine because GetLineHites wants it
; 				0-based.  iSetStylHandle fixed to dispose of old style handle
; 				before setting new one.

; ** BETA 6 **

; <C766/05feb87>MBK Fixed CopyStyle to lock my style handle before calling
; 				PutScrap.  Fixed DelGuts to relock text handle after munging.
; 				Removed call to StdEntry from iTEStylInsert because TEDispatch
; 				does it.

; <C788/11feb87>MBK Fixed iTEStylInsert to get the input parameters in the
; 				correct order.

; <C815/13feb87>MBK Fixed StdEntry to set the Grafport's txMode from TERec.teMode.
; 				Fixed RangeRect to set pnLoc correctly for compatibility with
; 				old applications.  Fixed FindLine to check for a CR at the end
; 				of a string of unwrapped blanks.

; ** BETA 8 **

; <C851/27Apr87>MBK Miscellaneous bug fixes (search on 851 to get more detailed
; 				descriptions); added code to handle setting styles on null
; 				selections.

; <C854/21may87>MBK Changed TECalText delta to 8001, fixed Pixel2Char disposhandle
; 				problem, fixed find style problem in PstStylScrap, fixed GetLineHites
; 				to work with fixed height, fixed recal deletion problem, restored input
; 				parameter order of iTEGetHeight.

; <C858/4jun87>MBK Fixed problems of iTEStylInsert destroying the StScrpHandle, style
; 				duplication problem in PstStylGuts, and iTEGetPoint returning incorrect
; 				offset when text ends in CR.  Removed conditionals around bug fixes.

; <C905/13oct87> MSH Port to HcMac (Laguna). No color on this machine
; <C914/29Oct87> rwh Port to Modern Victorian

; ------------------------------ System 6.0 ----------------------------
; <C971/RWW101287>	Did some personal cleanup.  Added new equates for new structures.
; 					Changed Bcc's and Bcs's to more logical forms.
; 					Began comparing various patches against this source to resolve differences.
; <C971/RWW101987>	Fixed 0 length bug in iTEStylInsert
; <C971/RWW102187>	Added conditional equates to make RAM-based testing easier
; <C971/RWW102287>	Patched ReCalLines to properly shrink lineStarts array
; <C971/RWW102387>	Broke out some common code, trying not to reinvent the wheel:
; 					AnyNullStyle, GetTrueStyle, GetOneStyle
; 					Changed iGetStylScrap to return a proper scrap record, even if
; 					there is no selection range.  Prevents apps from having
; 					to special case insertion points
; 					Rewrote most of iTEGetHeight to properly sort and pin start/end
; 					Added conditional inclusion of TEDispatch'ed routine addresses
; 					so I can find them without a Cray
; <C971/RWW102687>	InitRsrved had some strangeness in it
; 					Added TESetEraseFlag and iTEContinuousStyle.  Added in code to check
; 					for erase flag before performing _EraseRect's
; <C971/RWW102787>	Changed references to faces to be byte instead of word length
; <C971/RWW102887>	Changed branches to optimal form.  Those patches marked "<C971/RWW102887>NO"
; 					are for new ROMs and total replacement patches only.
; 					(There were an awful lot of word branches where shorts would do!)
; 					Added SetStyleScrap
; <C971/RWW102987>	Changed fail test in SetGuts to masking uninteresting bits
; 					Added doToggle functionality to SetGuts, StyleGuts, SetRsrved, CheckMatch
; <C971/RWW103087>	Added some hysteresis to lineStarts hack, to try to prevent some
; 					heap thrashing from constant SetHandleSize calls
; <C971/RWW110387>	Added new internal dispatch table to (quasi-) support tabs.  We won't
; 					officially support tabs, but these hooks will make the job a lot
; 					simpler for those who need it.  (It used to be a lot easier to hook
; 					in tab support than it is now that styles have to be reckoned with.)
; <C971/RWW110487>	Yanked SetEraseFlag and associated logic.  Only bought us about 10% - not
; 					enough to get excited over.  Added iTECustomHook to give a high end
; 					way to stuff new internal dispatch table addresses
; <PMAB381/RWW020488> Took out some redundancies and moved autoscroll flag from its position in
; 					"teFlags" (nŽe teRecBack) to the new dispatch record.  Ooops.  It acted as
; 					a high bit set in the new handle to the TEDispatchRec
; <PMAB387/DBG021088> Fixed bug in TEDispose where dispatch vector was not getting released for
; 					unstyled TE records.
; <S425/RWW031688>	Fixed bug in iTEContinuousStyle and changed the way it handles face
; 					attributes
; <S508/RWW080288>	Revisiting of S508, installed on Altair only by mistake.
; 					Fixes problem of TEHandle being dereferenced across a call to
; 					InstallIntDispatch in TEStylNew, which could thrash the heap.
; <19Feb89smb>		Replaced hardware casms with feature casms, and changed routine names
;					so they would not conflict with mpw includes.  Also removed additional
;					equates that are in ToolEqu.a.
; <28Feb89smb>		Added Script Manager patch for setting up teSysJust from the system script
;					for Harpo.
; <16May89smb>		Had to reset A2 to selStart(a3) in TECopy after a NewHandle call, which may
;					have invalidated the pointer to the teRecord (upon which A2 was based!).
;					See bug #46036.  Fix for bug 39276: changed add operation in TECustomHook
;					from a long op to a word op.
; <17May89smb>		Must lock the StScrpHandle for SetStylScrap to work correctly: see bug #36986.
; _______________________________________________________________________
;<<<END HISTORY>>>	<- This is to make the end of these comments easy to find with MPW.


			Blanks		On
			String		AsIs

	If &TYPE('&RWWDebug') = 'UNDEFINED' Then
		If &TYPE('InsideTEPatch') = 'UNDEFINED' Then		; <S383>
			LOAD		'StandardEqu.d'
			INCLUDE		'ScriptPriv.a'						; <28Feb89smb>
			INCLUDE		'TextEditPriv.a'					; <1/9/90smb>
		EndIf												; <S383>
	EndIf

; *************************************************************************************************
; *************************************************************************************************
; *************************************************************************************************

TextEdit	Proc		Export

			Export		TextBox
			Export		TEActivate
			Export		TEClick
			Export		TECopy
			Export		TECut
			Export		TEDeactivate
			Export		TEDelete
			Export		TEInit
			Export		TENew
			Export		TEDispose
			Export		TEKey
			Export		TEPaste
			Export		TEIdle
			Export		TEUpdate
			Export		TEInsert
			Export		TESetText
			Export		TECalText
			Export		TESetSelect
			Export		TEScroll
			Export		TESetJust
			Export		TEGetText
			Export		TEAutoView
			Export		TEPinScroll
			Export		TESelView

			Export		TEStylNew
			Export		TEGetOffset

			Export		TEDispatch

; hooks to be stored in the trap table

			Export		XTrimMeasure
			Export		XFindWord
			Export		XFindLine

			Export		vPixel2Char
			Export		vChar2Pixel

;-----------------------

teStylSize	Equ			28						; initial size of teStylesRec with 2 entries
stBaseSize	Equ			20						; added to fix MakeRoom bug

; iTESetStyle/iTEContinuousStyle modes
doAll2		Equ			$1F						; all of the above + add size
doAll3		Equ			$3F						; all of the above + toggle faces

;-----------------------

teFind		Equ			0
teMark		Equ			1
teDraw		Equ			-1
teLoc		Equ			-2

teLFlush	Equ			0						; default
teRFlush	Equ			-1
teCenter	Equ			1

; constants for identifying the routine that called callbreak

teWordSelect Equ		4						; clickExpand to select word
teWordDrag	 Equ		8						; clickExpand to drag new word
teFromFind	 Equ		12						; FindLine called it
teFromRecal	 Equ		16						; RecalLines called it

inHandle	Equ			8						; TE handle offset
saveHandle	Equ			-2						; incoming handle flags
savePort	Equ			saveHandle-4			; incoming graf port
saveClip	Equ			savePort-4				; incoming clip in TE port
saveTH		Equ			saveClip-2				; saved text handle flags
saveFont	Equ			saveTH-2				; Grafport's font
saveFace	Equ			saveFont-2				; Grafport's face
saveSize	Equ			saveFace-2				; Grafport's size
saveColor	Equ			saveSize-6				; Grafport's color
stdLink		Equ			saveColor

; standard frame for doText

saveLeft	Equ			-2						; true left
saveJust	Equ			saveLeft-2				; left setting after justification
txtLink		Equ			saveJust

; frame for recallines

savedD4		Equ			-2
savedD2		Equ			savedD4-2
startHndl	Equ			savedD2-4
savePtr		Equ			startHndl-4
oldNLines	Equ			savePtr-2
RecalLink	Equ			oldNLines

AddrTable	DC.W		iTEStylPaste-AddrTable				; 0
			DC.W		iTESetStyle-AddrTable				; 1
			DC.W		iTEReplaceStyle-AddrTable			; 2
			DC.W		iTEGetStyle-AddrTable				; 3
			DC.W		iGetStylHandle-AddrTable			; 4
			DC.W		iSetStylHandle-AddrTable			; 5
			DC.W		iGetStylScrap-AddrTable				; 6
			DC.W		iTEStylInsert-AddrTable				; 7
			DC.W		iTEGetPoint-AddrTable				; 8
			DC.W		iTEGetHeight-AddrTable				; 9

			; ** <C971/RWW102687>	New entry points
			DC.W		iTEContinuousStyle-AddrTable		; 10
			DC.W		iSetStylScrap-AddrTable				; 11
			DC.W		iTECustomHook-AddrTable				; 12
			DC.W		iTENumStyles-AddrTable				; 13

; ----------------------------------------------------------------------

; 			FUNCTION	TEGetText( h: TEHandle	): Handle;

; 			Returns the text handle

; ----------------------------------------------------------------------
TEGetText
			Bsr 		StdEntry

			Move.L		teTextH(A3),(A2)		; return the text handle

			Bra 		epilog4

; ----------------------------------------------------------------------

; 			PROCEDURE TEInit

; ----------------------------------------------------------------------
TEInit
			MoveQ		#0,D0
			Move		D0,TEScrpLength 		; save in global space
			_NewHandle
			Move.L		A0,TEScrpHandle 		; Save in global space

			Lea 		XDoText,A0				; set up doText hook
			Move.L		A0,teDoText
			Lea 		XRecalLines,A0			; set up recal hook
			Move.L		A0,teRecal
			Lea 		DefWordBrk,A0			; get default word break
			Move.L		A0,teWdBreak
			
; <28Feb89smb>			
	If onHcMac then
			WITH	SMgrRecord,ScriptRecord
			GetSMgrCore a0						; load SMgr globals pointer.
			tst.b	smgrEnabled(a0)				; script manager disabled?
			beq		@bail						; yes -> bail out.
			move.w	smgrSysScript(a0),d0		; get system script code.
			lsl.w	#2,d0						; script code is long offset.
			move.l	smgrEntry(a0,d0.w),a0		; load system script entry.
			move.b	scriptJust(a0),d0			; load script just.
			ext.w	d0							; sign extend just.
			move.w	d0,TESysJust				; set global just.
			endWith							
@bail
	endif
			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE TEDispose( h: TEHandle )

; 			** <C207/13oct86/MBK> **	Added code to dispose of style
; 			related handles if this TERec has style.

; ----------------------------------------------------------------------
TEDispose
			Link		A6,#0
			MoveM.L 	D2-D7/A2-A4,-(SP)		; save stdregs
			Move.L		8(A6),A4				; Pop handle into A4
			Move.L		(A4),A3 				; Dereference into A3

			Move.L		teTextH(A3),A0			; get rid of text
			_DisposHandle

; Following lines moved here from within "styled" section below.
			Move.L		teDispatchH(A3),A0		; Added to (quasi-) support tabs <C971/RWW110387><PMAB387/DBG021088>
			_DisposHandle						; <PMAB387/DBG021088>

			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@0						; more to dispose if so

			Move.L		teStylesH(A3),A2		; get style handle
			Move.L		(A2),A2					; dereference
			Move.L		styleTab(A2),A0			; handle to distinct styles
			_DisposHandle

			Move.L		lhTab(A2),A0			; handle to line heights
			_DisposHandle

			Bsr.S		DisposRsrved			; dispose of reserved handle

			Move.L		teStylesH(A3),A0		; get rid of itself
			_DisposHandle

@0			Move.L		A4,A0					; get rid of itself
			_DisposHandle

			MoveQ		#4,D0
			Bra 		Std2Exit

; ----------------------------------------------------------------------

; 			PROCEDURE DisposRsrved;
; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 			selection is NIL in iTESetStyle.  I store it in the scrap
; 			format so that it can easily be inserted using PstStylGuts.
; 			This procedure is called to dispose of the nullStyle handle.
; ----------------------------------------------------------------------
DisposRsrved
			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; deref
			Move.L		nullStyle(A0),A0		; get reserved handle
			Move.L		A0,-(SP)				; save this handle
			Move.L		(A0),A0					; deref
			Move.L		nullScrap(A0),A0		; get handle to scrap for null selection
			_DisposHandle						; get rid of null scrap handle
			Move.L		(SP)+,A0				; get back nullStyle handle
			_DisposHandle						; get rid of nullStyle handle
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TextBox( Text: Ptr; Length: LONGINT; r: Rect; style: INTEGER );
; 								18			14				10			8

TBJust		Equ			8
TBBox		Equ			10
TBLength	Equ			14
TBText		Equ			18
; ----------------------------------------------------------------------
TextBox
			Link		A6,#0
			MoveM.L 	D2-D7/A2-A4,-(SP)		; save StdRegs on stack

			Tst.W		TBJust(A6)				; ÒleftÓ justified?					<C971/RWW110987>
			Bne.S		@05						; no => skip this					<C971/RWW110987>

			Move.W		teSysJust,TBJust(A6)	; he meant, Òdefault justificationÓ	<C971/RWW110987>

@05			Cmp.W		#teForceLeft,TBJust(A6)	; _real_ left justification?		<C971/RWW110987>
			Bne.S		@08						; no => skip this					<C971/RWW110987>

			Clr.W		TBJust(A6)				; clear justification				<C971/RWW110987>
@08												; 									<C971/RWW110987>

; here's Capp's code to make TextBox fast for drawing single lines
; Added EHB 25-Jan-85.

			Move.L		TBText(A6),A0			; see if any CR's in text
			Move.L		TBLength(A6),D0			; get length
			Blt.S		tbExit					; escape if illegal string		<C971/RWW102887>NO
			Beq.S		NoZeroScan				; => don't scan NIL strings		<EHB 31-Oct-85>
@0
			Cmp.B		#$0D,(A0)+
			Beq.S		useRealOne
			SubQ.L		#1,D0
			Bne.S		@0

; no carriage returns, try in rect

NoZeroScan	SubQ		#2,SP					; see how big it is?
			Move.L		TBText(A6),-(SP)		; pass text
			Clr.W		-(SP)
			Move		TBLength+2(A6),-(SP)	; pass length (low word)
			_TextWidth
			Move.W		(SP)+,D3				; save it

			Move.L		TBBox(A6),A0			; point to rect
			Move		right(A0),D0
			Sub 		left(A0),D0
			SubQ		#2,D0
			Cmp 		D3,D0
			Ble.S		useRealOne

			Move.L		A0,-(SP)				; erase the rect
			_EraseRect

			SubQ		#8,SP
			Move.L		SP,-(SP)
			_GetFontInfo
			Move		(SP)+,D0				; get ascent
			AddQ		#6,SP					; skip rest

			Move.L		TBBox(A6),A0			; point to rect
			Move.L		(A0),-(SP)				; push topleft
			Add 		D0,(SP) 				; go down ascent
			AddQ		#1,2(SP)				; indent 1 for TE compatibility
			_MoveTo

			Tst.W		TBJust(A6)				; look at justification
												; leave high byte for others
			Beq.S		@2						; if left go do it

; assume centered
			Move.L		TBBox(A6),A0			; point to rect
			Move		right(A0),D0			; calc width
			Sub 		left(A0),D0
			Sub 		D3,D0					; subtract text width
			SubQ		#1,D0					; caret space TE compatibility

			Tst.W		TBJust(A6)				; look at justification
			Bmi.S		@1						; if right skip right shift
			AsR 		#1,D0					; divide by two
@1
			Move		D0,-(SP)				; move over
			Clr 		-(SP)					; dv = 0
			_Move
@2
			Move.L		TBText(A6),-(SP)		; pass text
			Clr 		-(SP)
			Move		TBLength+2(A6),-(SP)	; pass length (low word)
			_DrawText
tbExit
			Bra.S		Go14Exit				; go to standard exit

; end of TextBox patch	<EHB 25-Jan-85>

UseRealOne
												; watch out for wierd (SP) offsets
			SubQ		#4,SP					; make room for return handle
			Move.L		TBBox(A6),-(SP)			; pass rect to init code
			Move.L		(SP),-(SP)				; pass rect twice
			Move.L		(SP),-(SP)				; pass rect twice
			_EraseRect
			_TENew
			Move.L		(SP)+,A4				; save handle

			Move.L		(A4),A0 				; dereference
			Move.W		TBJust(A6),teJust(A0)	; and set style

			Move.L		TBLength(A6),D0			; get length
			Beq.S		noTextBox

			Move.L		TBText(A6),-(SP)		; pass text pointer
			Move.L		D0,-(SP)				; pass text length
			Move.L		A4,-(SP)				; pass tehandle

			_TESetText

			Move.L		TBBox(A6),-(SP)			; pass rect to update
			Move.L		A4,-(SP)				; pass tehandle
			_TEUpdate							; and draw it

noTextBox
			Move.L		A4,-(SP)				; pass tehandle
			_TEDispose							; and dispose it
Go14Exit
			MoveQ		#14,D0
			Bra 		Std2Exit


; ----------------------------------------------------------------------

; 			PROCEDURE TESetText( text: Ptr; l: Length; h: TEHandle	);

; 			** Modified 6/18/86 by MBK **

; 			Makes the text passed in the current text to edit

; ----------------------------------------------------------------------
TESetText
			Bsr 		StdEntry

			Move.L		(A2)+,D0				; get length passed

			Move		D0,teSelStart(A3)		; save as selection
			Move		D0,teSelEnd(A3)
			Move		D0,teLength(A3) 		; save as length

			Move.L		teTextH(A3),A0			; handle to stuff into
			Move.L		D0,-(SP)
			_HUnlock							; and unlock it
			Move.L		(SP)+,D0
			Move.L		(A2)+,A0				; set up ptr
			Move.L		teTextH(A3),A1			; handle to stuff into
			_PtrToXHand

			Move.L		teTextH(A3),A0			; handle to stuff into
			_HLock								; relock it

			Bsr.S		SetOneStyle				; set GrafPort's style			<C971/RWW102887>NO

			Bsr			CalText 				; go do it
noText
go12
			Bra 		epilog12


; ----------------------------------------------------------------------

; 			PROCEDURE SetOneStyle

; 			** Added 6/2/83 by MBK **

; 			Called by TESetText to set the entire body of the new text
; 			to a single style, which is taken from the GrafPort by
; 			default.

; ----------------------------------------------------------------------
SetOneStyle
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; quit if no style

; Set style handle to minimum size (i.e., 1 style for entire text)
			Move.L		teStylesH(A3),A0		; get style handle
			MoveQ		#teStylSize,D0			; size of record with 1 style
			Bsr.S		MySetHandleSize			; reset handle size				<C971/RWW102887>NO
			Move.L		(A0),A0					; dereference

; Reset StyleRec's handle size to just 1 StyleRec
			Move.L		styleTab(A0),A0			; handle to StyleRec's
			MoveQ		#stRecSize,D0			; size of 1 style record
			Bsr.S		MySetHandleSize			; reset handle size				<C971/RWW102887>NO

			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; dereference to A0

			Move.W		teLength(A3),D0			; get length of text
			Bsr.S		GetDefStyle				; store default style in StyleRec <C971/RWW102887>NO

@0			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE MySetHandleSize

; 			** <C381/7nov86/MBK> **

; 			MySetHandleSize unlocks the TEHandle and the text handle, attempts
; 			to set the input handle size, calls system error if there is one,
; 			And otherwise relocks TEHandle and the text handle.

; 	Entry:
; 			D0:		requested handle size
; 			A0:		a handle
; 			A3:		Ptr to TERec
; 			A4:		Handle to TERec

; 	Exit:
; 			A3:		Could have a different value if memory was shifted

; ----------------------------------------------------------------------

MySetHandleSize
			MoveM.L		D0/A0,-(SP)				; save input
			Move.L		teTextH(A3),A0			; text handle
			_HUnLock							; unlock it
			MoveM.L		(SP)+,D0/A0				; restore input

			_SetHandleSize						; do it
			Bne.S		badExit					; fly away if system error

			MoveM.L		D0/A0,-(SP)				; save input
			Move.L		teTextH(A3),A0			; text handle
			_HLock								; lock that too
			MoveM.L		(SP)+,D0/A0				; restore input

			Rts

badExit
			Move.W		#dsMemFullErr,D0		; memory full error			** <C485/03dec86/MBK> **

			_SysError							; go away and never come back


; ----------------------------------------------------------------------

; 			PROCEDURE GetDefStyle

; 			** Added 6/2/86 by MBK **

; 			GetDefStyle gets the default style for this TERec (taken
; 			from its GrafPort) and stores it in the styleRec pointed
; 			to by A0.

; 	Entry:
; 			D0:		length of text
; 			A0:		dereferenced TEStylesH
; 			A3:		Ptr to TERec

; ----------------------------------------------------------------------
GetDefStyle
			Move.W		#1,nRuns(A0)			; always 1 style to start
			Move.W		#1,nStyles(A0)			; # of styleRec's
			Lea			runs(A0),A1				; point to start of style array
			Clr.L		(A1)+					; start offset and index
			Move.W		D0,(A1)+				; 1 beyond the end
			Move.W		#$FFFF,(A1)				; make it no style

			Move.L		styleTab(A0),A0			; handle to StyleRec's
			Move.L		(A0),A0					; dereference
			Move.W		#1,stCount(A0)			; so set count to 1

			Bsr.S		GetSize					; get ascent & hite				<C971/RWW102887>NO

; Dereference the handle again. GetSize calls GetFontInfo, which could
; move memory around.
			Move.L		teStylesH(A3),A0		; style handle
			Move.L		(A0),A0					; dereference
			Move.L		styleTab(A0),A0			; handle to StyleRec's
			Move.L		(A0),A0					; dereference

			Move.W		D0,stAscent(A0)		 	; save in ascent		** <C207/10oct86/MBK> **
			Move.W		D1,stHeight(A0)			; save in line height	** <C207/10oct86/MBK> **

; Get the font, face, size and color and save away
			Move.L		teGrafPort(A3),A1		; get this port
			Move.W		txFont(A1),stFont(A0)	; save the font
			Move.W		txFace(A1),stFace(A0)	; save the face
			Move.W		txSize(A1),stSize(A0) 	; save the size
			Pea			stColor(A0)				; place to store color	** <C182/6oct86/MBK> **

;;	If forRAM THEN
	If (Not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; are we on a color system?	(as per Jerome) <C971/RWW112487>
			Bnz.S		@1						; Nope								<C971/RWW112487>
			_GetForeColor						; 									<C971/RWW112487>
			Bra.S		@2						; 									<C971/RWW112487>
@1			Bsr			GetForeColor			; 									<C971/RWW112487>
@2
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb>
			_GetForeColor						; for Ikki				** <C182/6oct86/MBK> **
	Else
			Bsr			GetForeColor			; for Alladin			** <C182/6oct86/MBK> **
	EndIf

			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE GetSize

; 			** <C207/10oct86/MBK> **

; 			Get ascent and line height from current font.

; 	Exit:
; 			D0:		ascent
; 			D1:		line height (= descent + leading!)

; ----------------------------------------------------------------------

GetSize
			Move.L		A0,-(SP)				; calling routines need this

; Get line height, etc. for font
			SubQ		#8,SP					; make room for font info stuff
			Move.L		SP,-(SP)				; push address
			_GetFontInfo
			Move		(SP)+,D0				; get ascent
			Move		D0,D1
			Add 		(SP)+,D1				; add descent
			AddQ		#2,SP					; skip max wid
			Add 		(SP)+,D1				; add leading

			Move.L		(SP)+,A0

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TECalText{ ( h: TEHandle	) };

; 			When the user installs his own text handle/rectangle in the record,
; 			this routine should be called to calibrate the line array to it

; ----------------------------------------------------------------------

CalText
			Move.L		teSelStart(A3),-(SP)	; save selStart/End

			Clr 		teSelStart(A3)			; recall from beginning

; The delta must be 32,767 for the recalibration to work correctly when the insert length
; is 32,767 and the text length is 0. (an arbitrarily large negative number won't do).
			Move		#$8001,D7				; fake delta(large - number)

			Clr.L		teLines(A3) 			; insure total recal

			Bsr 		ReCalLines				; redo the line stuff

			Move.L		(SP)+,teSelStart(A3)	; restore selStart/End

			Rts

TECalText
			Bsr 		StdEntry

			Bsr.S		CalText					; 								<C971/RWW102887>NO
epilog4
			MoveQ		#4,D0
			; fall into std exit

; ----------------------------------------------------------------------

; 			Std Exit assumes original argument is good

StdExit
			Move.L		inHandle(A6),A4 		; Place handle into A4
			Bra.S		RealExit

; ** <C105/29aug86/MBK> ** For style routines, which also have a routine
; 							selector on the top of the stack

StdExit2	Move.L		inHandle+2(A6),A4 		; Place handle into A4

RealExit	Move.L		(A4),A3 				; re-dereference it

			Move		D0,D4					; save strip amount

			Move.L		teTextH(A3),A0			; get text handle
			Move.B		saveTH(A6),D0			; get the text handle flags
			_HSetState							; set up the handle

			Move.L		saveClip(A6),-(SP)
			Move.L		(SP),-(SP)
			_SetClip							; restore caller's clip
			_DisposRgn							; and dispose of our copy

			Move.L		A4,A0					; get the handle
			Move.B		saveHandle(A6),D0		; get the handle's flags
			_HSetState							; restore the handle

			Pea			saveColor(A6)			; set foreground color 		** <C182/6oct86/MBK> **

;;	If forRAM THEN
	If (not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; are we on a color system?	(as per Jerome) <C971/RWW112487>
			Bnz.S		@1						; Nope								<C971/RWW112487>
			_RGBForeColor						; 									<C971/RWW112487>
			Move.L		(A4),A3					; 									<C971/RWW112487>
			Bra.S		@2						; 									<C971/RWW112487>
@1			Bsr			RGBForeColor			; 									<C971/RWW112487>
@2
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb>
			_RGBForeColor						; for Ikki					** <C182/6oct86/MBK> **
			Move.L		(A4),A3					; restore ptr just in case	** <C597/06jan87/MBK> **
	Else
			Bsr			RGBForeColor			; for Alladin				** <C182/6oct86/MBK> **
	EndIf
			Move.L		teGrafPort(A3),A0		; restore GrafPort stuff
			Move.W		saveSize(A6),txSize(A0)	; restore Grafport's size
			Move.W		saveFace(A6),txFace(A0)	; restore Grafport's face
			Move.W		saveFont(A6),txFont(A0)	; restore Grafport's font

			Move.L		savePort(A6),-(SP)		; restore port to user's passed
			_SetPort

			Move		D4,D0					; restore strip amount
Std2Exit
			MoveM.L 	(SP)+,D2-D7/A2-A4		; restore regs
			Unlk		A6

			Move.L		(SP)+,A0				; remove return add
			Add 		D0,SP					; strip parameters
			Jmp 		(A0)


; ----------------------------------------------------------------------

; 			PROCEDURE TESetSelect{ ( selStart, selEnd: LONGINT; h: TEHandle	) };

; 			Sets the current select range

; ----------------------------------------------------------------------
TESetSelect
			Bsr 		StdEntry

			Bsr			ClearRsrved				; clear out reserved style

			Bsr 		HideCaret
			Bsr 		HiLite

			Move		14(A6),teSelEnd(A3) 	; Jam the selection end
			Move		18(A6),teSelStart(A3)	; jam selStart
			Bsr 		CleanUpSel				; sort and clean up selection

			Bsr 		ShowCaret
			Bsr 		HiLite

			Bsr 		SelView 				; insure selection is visible

			Bra 		go12

; ----------------------------------------------------------------------

; 			FUNCTION TENew{ ( destRect, viewRect: Rect ): TEHandle };

; ----------------------------------------------------------------------
TENew
			Link		A6,#0
			MoveM.L 	D2-D7/A2-A4,-(SP)		; Save regs

			Clr.L		16(A6)					; return NIL

			MoveQ		#TERecSize,D0			; Allocate a record
			_NewHandle	,CLEAR
			Bne			badExit					; escape if error				<C971/RWW102887>NO

			Move.L		A0,A4					; save handle

			_HLock								; get object handle and lock it
			Move.L		(A4),A3 				; dereference it

			MoveQ		#0,D0					; get text handle
			_NewHandle
			Bne			badExit					; escape if error				<C971/RWW102887>NO
			Move.L		A0,teTextH(A3)

; Dest and view rect must be together in record
			Lea 		teDestRect(A3),A0		; point to rects in beginning
			Move.L		12(A6),A2				; Get dest rectangle arg
			Move.L		(A2)+,(A0)+ 			; save away in record
			Move.L		(A2)+,(A0)+
			Move.L		8(A6),A2				; Get view rectangle arg
			Move.L		(A2)+,(A0)+ 			; save away in record
			Move.L		(A2)+,(A0)+

; Get line height, etc. for font
			Bsr			GetSize					; get ascent & hite		** <C207/10oct86/MBK> **
			Move.W		D0,teAscent(A3)		 	; save in ascent		** <C207/10oct86/MBK> **
			Move.W		D1,teLineHite(A3)		; save in line height	** <C207/10oct86/MBK> **

; Get the font and face and save away
			Move.L		grafGlobals(A5),A2		; get lisagraf globals and then
			Move.L		thePort(A2),A2			; thePort
			Move.L		A2,teGrafPort(A3)		; save this port
			Move.L		txFont(A2),teFontStuff(A3)		; save the font/face
			Move.L		txFont+4(A2),teFontStuff+4(A3)	; save the mode/size

			Move.L		teWdBreak,teWordBreak(A3)	; Set global word breaker

			Lea 		DefClikProc,A0			; setup default click proc
			Move.L		A0,TEClikProc(A3)

			Bsr.S		InstallIntDispatch		; install new internal dispatch tbl	<C971/RWW110387>

			Move.L		teTextH(A3),A0			; need to unlock text handle	<S555/RWW080488>
			_HUnlock							; MyNewHandle locked it			<S555/RWW080488>

			Move.L		A4,A0					; set up for HUnlock
			_HUnlock
			Move.L		A4,16(A6)				; return handle
@0
			MoveQ		#8,D0
			Bra			Std2Exit				; 								<C971/RWW102887>NO

; ----------------------------------------------------------------------

; 			PROCEDURE ClearRsrved;
; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 			selection is NIL in iTESetStyle.  I store it in the scrap
; 			format so that it can easily be inserted using PstStylGuts.
; 			This procedure is called to set the style count to 0 whenever
; 			the selection is changed.
; ----------------------------------------------------------------------

ClearRsrved
			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@0						; this hdl isn't there if not

			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; deref
			Move.L		nullStyle(A0),A0		; get reserved handle
			Move.L		(A0),A0					; deref
			Move.L		nullScrap(A0),A0		; get handle to scrap for null selection
			Move.L		(A0),A0					; deref
			Move.W		#0,scrpNStyles(A0)		; indicate no style
@0			Rts

; ----------------------------------------------------------------------
; 	InstallIntDispatch
; 	<C971/RWW110387>

; 	Added this code to (quasi-) support tabs

; ----------------------------------------------------------------------
InstallIntDispatch
			MoveQ		#intDispSize,D0
			Bsr			MyNewHandle				; Replaces next two lines			<S508/RWW080288>
; 			_NewHandle							;									<S508/RWW080288>
; 			Bne			badExit					;									<S508/RWW080288>

			Move.L		A0,teDispatchH(A3)		; install it in the record
			Move.L		(A0),A0

			Lea			xEOLHook,A1
			Move.L		A1,EOLHook(A0)

			Lea			xDRAWHook,A1
			Move.L		A1,DRAWHook(A0)

			Lea			Char2Pixel,A1
			Move.L		A1,WIDTHHook(A0)

			Lea			Pixel2Char,A1			; 									<C971/RWW111887>
			Move.L		A1,HITTESTHook(A0)		; 									<C971/RWW111887>
			
			Clr.L		newTEFlags(A0)			; <PMAB381/RWW020488>

			Rts

; ----------------------------------------------------------------------

; 			FUNCTION TEStylNew{ ( destRect, viewRect: Rect ): TEHandle };
; 			** Added 5/23/86 by MBK **

; 			TEStyleNew sets txSize to -1 and stores a handle to the
; 			style information in txFont, txFace. The LineHeight and
; 			FontAscent fields are set to -1.

; ----------------------------------------------------------------------
TEStylNew
			Link		A6,#0
			MoveM.L 	D2-D7/A2-A4,-(SP)		; Save regs

			Clr.L		16(A6)					; return NIL

			MoveQ		#TERecSize,D0			; Allocate a record
			_NewHandle	,CLEAR
			Bne			badExit					; escape if error				<C971/RWW102887>NO

			Move.L		A0,A4					; save handle

			_HLock								; get object handle and lock it
			Move.L		(A4),A3 				; dereference it

			MoveQ		#0,D0					; get text handle
			_NewHandle
			Bne			badExit					; escape if error				<C971/RWW102887>NO
			Move.L		A0,teTextH(A3)

; Dest and view rect must be together in record
			Lea 		teDestRect(A3),A0		; point to rects in beginning
			Move.L		12(A6),A2				; Get dest rectangle arg
			Move.L		(A2)+,(A0)+ 			; save away in record
			Move.L		(A2)+,(A0)+
			Move.L		8(A6),A2				; Get view rectangle arg
			Move.L		(A2)+,(A0)+ 			; save away in record
			Move.L		(A2)+,(A0)+

; Set size to -1 to indicate this is a stylish record & allocate handle to style
			Move.W		#-1,teSize(A3)			; set style flag (Go style)
			MoveQ		#teStylSize,D0			; min size is for 1 style descriptor
			Bsr			MyNewHandle				; get handle to style info		** <C381/7nov86/MBK> **
			Move.L		A0,teStylesH(A3)		; former txFont location

; Get Style Handle for storing font, face, size, and color
			MoveQ		#stRecSize,D0			; size of style descriptor
			Bsr			MyNewHandle				; get StyleHandle				<C971/RWW102887>NO
			Move.L		teStylesH(A3),A2		; handle to style info
			Move.L		(A2),A2					; dereference
			Move.L		A0,styleTab(A2)			; store handle to styles array

; Get handle to array of largest line height on each line
			MoveQ		#4,D0					; Make room for one entry in line height array
			Bsr			MyNewHandle				; allocate handle to line hites	<C971/RWW102887>NO
			Move.L		A0,A1					; save handle

			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; dereference
			Move.L		A1,lhTab(A0)			; store line hites handle

; Save the GrafPort and save default style from GrafPort
			Move.L		grafGlobals(A5),A1		; get lisagraf globals and then
			Move.L		thePort(A1),A1			; thePort
			Move.L		A1,teGrafPort(A3)		; save this port
			Move.W		txMode(A1),teMode(A3)	; save the mode

			MoveQ		#1,D0					; length of text + 1
			Bsr			GetDefStyle				; save default style in StyleRec

; Store one entry in line height array
			Move.L		teStylesH(A3),A0		; style handle
			Move.L		(A0),A0					; dereference
			Move.L		lhTab(A0),A1			; handle to line height table
			Move.L		(A1),A1					; dereference
			Move.L		styleTab(A0),A0			; handle to StyleRec's
			Move.L		(A0),A0					; dereference

			Move.W		stAscent(A0),2(A1)		; save ascent
			Move.W		stHeight(A0),(A1)		; save line height

			Move.W		#$FFFF,teAscent(A3) 	; won't be used unless somebody
			Move.W		#$FFFF,teLineHite(A3)	; sets the ascent and line height

			Move.L		teWdBreak,teWordBreak(A3)	; Set global word breaker

			Lea 		DefClikProc,A0			; setup default click proc
			Move.L		A0,TEClikProc(A3)

			Bsr.S		InitRsrved				; init reserved handle

			Bsr			InstallIntDispatch		; install new internal dispatch tbl	<C971/RWW110387>

			Move.L		teTextH(A3),A0			; need to unlock text handle	** <C381/7nov86/MBK> **
			_HUnlock							; MyNewHandle locked it			** <C381/7nov86/MBK> **

			Move.L		A4,A0					; set up for HUnlock
			_HUnlock
			Move.L		A4,16(A6)				; return handle
@0
			MoveQ		#8,D0
			Bra			Std2Exit				; 								<C971/RWW102887>NO

; ----------------------------------------------------------------------

; 			PROCEDURE InitRsrved;
; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 			selection is NIL in iTESetStyle.  I store it in the scrap
; 			format so that it can easily be inserted using PstStylGuts.
; 			This procedure is called to create the nullStyle handle.
; ----------------------------------------------------------------------

InitRsrved
			Move.L		A2,-(SP)				; save reg
			MoveQ		#nullStSize,D0			; size of reserved handle
			Bsr.S		MyNewHandle				; NewHandle with error checking
			Move.L		teStylesH(A3),A2		; get style handle
			Move.L		(A2),A2					; deref
			Move.L		A0,nullStyle(A2)		; store new handle
; <S508/RWW062388>	MyNewHandle could thrash the heap.  Gotta save this handle for later.
			Move.L		A0,-(SP)				; Save off the handle				<S508/RWW062388>

			MoveQ		#scrpRecSize+2,D0		; size of scrap handle
; what?			AddQ	#2,D0					; include room for # of styles		<C971/RWW102687>
			Bsr.S		MyNewHandle				; NewHandle with error checking
; <S508/RWW062388>	This pulls off the nullStyle handle we saved a few lines ago.
; not needed.	Move.L	nullStyle(A2),A2		; get reserved handle
			Move.L		(SP)+,A2				; Retrieve nullStyle handle			<S508/RWW062388>
			Move.L		(A2),A2					; deref
			Move.L		A0,nullScrap(A2)		; store new scrap handle

; what?			Move.L	nullScrap(A2),A0		; get handle to scrap for null selection <C971/RWW102687>
			Move.L		(A0),A0					; deref
			Move.W		#0,scrpNStyles(A0)		; indicate no style

			Move.L		(SP)+,A2				; restore reg
			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE MyNewHandle
; 			** <C381/7nov86/MBK> **

; 			MyNewHandle unlocks the TEHandle and the text handle, attempts
; 			to allocate memory for a handle, calls system error if there is one,
; 			And otherwise relocks TEHandle and the text handle.

; 	Entry:
; 			D0:		requested handle size
; 			A3:		Ptr to TERec
; 			A4:		Handle to TERec

; 	Exit:
; 			A0:		the handle
; 			A3:		Could have a different value if memory was shifted

; ----------------------------------------------------------------------

MyNewHandle
			Move.L		D0,-(SP)				; save input
			Move.L		teTextH(A3),A0			; text handle
			_HUnlock							; make it easy to get memory
			Move.L		A4,A0					; TEHandle
			_HUnlock							; make it easy to get memory
			Move.L		(SP)+,D0				; get the input
			_NewHandle							; do it
			Bne			badExit					; fly away if system error

			Move.L		A0,-(SP)				; save handle
			Move.L		A4,A0					; get TEHandle
			_HLock								; relock it
			Move.L		(A4),A3					; reset TEPtr
			Move.L		teTextH(A3),A0			; text handle
			_HLock								; lock that too
			Move.L		(SP)+,A0				; restore handle

			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE TEUpdate( r: Rect; h: TEHandle )

; 			Redraws the entire object sected by r

; ----------------------------------------------------------------------
TEUpdate
			Bsr 		StdEntry

			Move.L		(A2)+,A0				; get rect
			Bsr 		Refresh

			Bra 		epilog8


; ----------------------------------------------------------------------

; 			A local cover for do find called from TEClick

; 			This takes a character index in D6 and expands it into D0,D1
; 			For character select mode, it simply copies it into D0,D1, but
; 			for word select, it locates the surrounding word and returns
; 			D0,D1 pointing to the word start and end(Respectively)
; 			Long at D5 negative if word select

; ----------------------------------------------------------------------

ClickExpand
			Move		D6,D0					; default for no-word select
			Move		D6,D1				
			Tst.L		D5						; see if word select (if negative)
			Bpl.S		byebye
			Bsr 		FindWord				; find word @D0
byebye
			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE HiLite;

; 			A3 is dereferenced object

; 			Now this pins the selStart and selEnd to the viewRect lines

; ----------------------------------------------------------------------
HiLite
			Tst.B		teActive(A3)			; don't do if not active
			Beq.S		byebye

			MoveM		teSelStart(A3),D3-D4	; disp start is D3, disp end is D4

			MoveQ		#teMark,D7				; set mark mode
			Bra 		DoText					; Remove old selection


; ----------------------------------------------------------------------

; 			PROCEDURE TEClick( pt: Point; extend: BOOLEAN; h: TEHandle );

; 		Uses:
; 			D6 as a character index corresponding to the current mouse point
; 			D5 a copy of the previous D6
; 			D5 long sign minus if word select
; 			A2 anchor left point for hilighting selection
; 			A4 anchor right for hilighting selection
; 			D0 for left of word at click spot
; 			D1 for right of word at click spot
; 			D3 split dispStarts for left and right piece of highlight
; 			D4 split dispEnds for left and right piece of highlight

; ----------------------------------------------------------------------
TEClick
			Bsr 		StdEntry

			Bsr			ClearRsrved				; clear out reserved style

; Find the new point and get index of it in D6
			Move.L		14(A6),teSelPoint(A3)	; pass selPoint
			Bsr 		DoFind					; juggle dispStart/End and do find

			Bsr 		HideCaret				; Remove caret

			SubQ		#4,SP					; make room for the tickCount
			_TickCount
			Move.L		(SP)+,D0 				; Ticks in D0

			Sub.L		teClikTime(A3),D0		; see if double click
			Cmp.L		doubleTime,D0			; 1/2 second click time
			Sle 		D5						; D5 = 0 if single click
			Cmp 		teClikLoc(A3),D6		; see if same location
			Seq 		D1
			And.B		D1,D5					; D5 ST if double click
			RoR.L		#8,D5					; get switch in high D5

			Move		D6,teClikLoc(A3)		; double click only if not moved

; D6 now contains the character location at which to look

; Find out if we want an extended selection or a normal one
; For an extended selection, fake out the loop below by fooling it into thinking
; we've already entered it "normally" but with the old selection already
; hilighted, etc.

			Tst.B		12(A6)					; see if extend flag is on
			Beq.S		notExtended

			MoveM		teSelStart(A3),D0-D1	; get old selection
			Cmp 		D6,D0					; chk side of new loc
			Bhs.S		useRight
			Move		D0,A2					; save anchor left
			Move		D0,A4					; and anchor right
			Bra.S		goToIt
useRight
			Move		D1,A2					; save anchor left
			Move		D1,A4					; and anchor right
goToIt
			Move		D6,D5
			Bra.S		goSelect

notExtended
			Bsr.S		HiLite					; Remove old selection
			MoveQ		#teWordSelect,D2		; say "ClickExpand, word selection" <EHB 01Oct85>
			Bsr.S		ClickExpand				; 								<C971/RWW102887>NO
; D0/D1 now contain the "bounds" of this click
			MoveM		D0-D1,teSelStart(A3)
			Move		D0,A2					; save anchor left
			Move		D1,A4					; and anchor right
			Move		D6,D5					; save "old" D6

; remember whether initial click was to left or right of character
			Move.B		teLftClick(A3),teLftCaret(A3)

			Bsr 		ShowCaret				; feedback to user
			Bsr 		HiLite

waitLoop
			Move.L		teClikProc(A3),D0		; call the click proc
			Beq.S		noClikProc
			Move.L		D0,A0
			Jsr 		(A0)
			Beq.S		done1					; if returns zero abort drag

noClikProc
			Clr 		-(SP)					; make room for result
			_WaitMouseUp						; see if button still down
			Tst		(SP)+					; pop result, check only the significant byte			<3> - <4>
			Beq.S		done1

			Pea 		teSelPoint(A3)			; pass address for point
			_GetMouse

			Bsr.S		DoFind					; juggle dispStart/End and do find

			Cmp 		D6,D5					; see if change
			Beq.S		waitLoop

			Bsr 		HideCaret

; There was a change so highlight only the new part. This is a really tricky part...
; The thing we're trying to do is is highlight only the part that changes of the
; selection which is being dragged out in this loop

goSelect
			MoveQ		#teWordDrag,D2			; say "ClickExpand, word dragging"
			Bsr 		ClickExpand 			; Get new points

			Lea 		teSelEnd(A3),A0 		; point between selStart/End

			Cmp 		D6,A4					; see if less than anchor right
			Blo.S		notToLeft				; skip if not to left of anchor
			Move		-(A0),D3				; save previous left
			Move		D0,(A0)+				; save new left
			Move		D0,D4					; save dispEnd too
			Swap		D3
			Swap		D4
			Move		A4,D3					; save other dispStart
			Move		(A0)+,D4				; save other dispEnd
			Move		A4,-(A0)
			Bra.S		hiliteIt


notToLeft
			Cmp 		D6,A2					; see if greater than anchor left
			Bhi.S		keepWaiting 			; skip if not to right of anchor
			Move		(A0)+,D3				; save previous right
			Move		D1,-(A0)				; save new right
			Move		D1,D4					; save dispEnd too
			Swap		D3
			Swap		D4
			Move		-(A0),D3				; save other dispEnd
			Move		A2,D4					; save other dispStart
			Move		A2,(A0)+


hiliteIt
			MoveQ		#teMark,D7				; set mark mode
			Bsr 		DoText					; do one half

			Swap		D3						; get other dispStart/End
			Swap		D4						; and hilight too
			Bsr 		DoText					; and other half

keepWaiting
			Move		D6,D5					; save new end

			Bra.S		waitLoop				; continue on
done1
			Bsr 		ShowCaret				; redisplay caret

; ** <C139/23Sep86/MBK> ** Save tick count at the end of TEClick so that
; extra TextEdit computing time will not be counted between clicks

			SubQ		#4,SP					; make room for the tickCount
			_TickCount
			Move.L		(SP)+,teClikTime(A3)	; remember click time

epilog10
			MoveQ		#10,D0
			Bra 		StdExit



; ----------------------------------------------------------------------

; 			DoFind

; 			Take the teSelPoint(A3) and return D6 w/corresponding char index

; 		Exit
; 			D6 contains the selection index returned from DoText

; ----------------------------------------------------------------------

DoFind

; find out which text line it's on

			Move		teSelPoint+v(A3),D0 	; i:=(selPoint.v-destRect.top)
			Bsr 		PtToLine				; line index in D0
			Bge.S		southPole				; below the last line

			Add 		D0,D0					; double D0
			Bpl.S		noPole					; default if i < 0 is D6 = 0
northPole
			MoveQ		#0,D6					; if above point to beginning
			Rts
southPole
			Move		teLength(A3),D6 		; return index(t):=length
			Rts
noPole
			MoveM		teLines(A3,D0),D3-D4	; dispStart := lines[i]
			MoveQ		#teFind,D7				; set find mode
			Bsr 		DoText					; return index(t) in D0
			Move		D0,D6					; return in D6
			Rts

; ----------------------------------------------------------------------

; 			Pixel2Char
; 			** Added 6/18/86 MBK **

; 	Entry:
; 			D0.W:			length of block
; 			D1.W:			pixel width relative to start of block
; 			D2.W:			slop
; 			A0:				ptr to start of block

; 	Exit:
; 			D0 (low word)	pixel width to last offset
; 				(high word)	boolean = TRUE if offset corresponding to
; 							the given pixel width was found
; 			D1.W:			character offset
; 			D2.W:			flagged if hit on left of char

; ----------------------------------------------------------------------

Pixel2Char
			Move.L		jPixel2Char,-(SP)		; call the Pixel2Char Routine
			Rts

vPixel2Char										; here's our Pixel2Char
			MoveM.L		D3-D4/A4,-(SP)

			Move.W		D1,D3					; save pixel width
			MoveQ		#0,D4					; clear whole register		** <C381/5nov86/MBK> **
			Move.W		D0,D4					; save count

			AddQ		#1,D0					; plus 1 for measure
			Ext.L		D0						; should be long
			Add.L		D0,D0					; double for words
			Move.L		D0,D1					; save in D1				** <C381/5nov86/MBK> **

; ** <C207/16oct86/MBK> ** try to get room on the stack; if not available,
; 						make a last ditch effort with NewPtr

			_StackSpace							; get stack size			** <C381/5nov86/MBK> **
			Sub.l		d1,d0					; stack, use newPtr			** <C381/5nov86/MBK> **
			Cmp.l		#1024,d0				; 							** <C381/5nov86/MBK> **

			Blt.s		tryHeap				

			Sub.l		d1,sp					; push the array.  		** <C381/5nov86/MBK> **
			Move.l		sp,a4					; save the array pointer
			Bra.S		onStack

tryHeap
			Move.L		D1,D0					; RESTORE size				** <C574/30dec86/MBK> **
			Move.L		A0,-(SP)				; save text ptr				** <C381/5nov86/MBK> **
			_NewPtr								; for array of char widths
			Move.L		A0,A4					; save ptr to array
			Move.L		(SP)+,A0				; restore text ptr			** <C381/5nov86/MBK> **

; Must save ptr for the dispose, because A4 will be modified.
			Move.L		A4,-(SP)				; save ptr for dispose

			MoveQ		#0,D1					; to say newPtr was used	** <C381/5nov86/MBK> **
			Tst.W		D0						; check result code			** <C381/5nov86/MBK> **
			Beq.S		onStack					; continue if no error		** <C381/5nov86/MBK> **

			Move.W		#dsMemFullErr,D0		; memory full error			** <C485/03dec86/MBK> **
			_SysError							; else call _SysError		** <C381/5nov86/MBK> **

onStack		Move.L		D1,-(SP)				; save buffer size			** <C381/5nov86/MBK> **
			Move.W		D4,-(SP)				; length of block
			Move.L		A0,-(SP)				; ptr to text
			Move.L		A4,-(SP)				; ptr to charLocs
			_MeasureText						; measure all at once

			Move.W		D4,D1					; get count
			Add.L		D4,D4					; mult count by 2
			Add.L		D4,A4					; pt to 1 beyond last entry	** <C381/5nov86/MBK> **
			Cmp.W		(A4),D3					; pt within width?

; This is to fix the following bug: if you clicked the mouse EXACTLY at
; the end of a line (ended by a CR), the selection was set to the character
; following the CR, instead of preceding it.
			Bge.S		@2						; quit if not

@0			Cmp.W		-(A4),D3				; pt within width?
			Bge.S		@1						; quit if so

			SubQ		#1,D1					; dec the count
			Bne.S		@0						; keep trying

			AddQ		#1,D1					; adjust for later decrement

@1			Move.W		2(A4),D2				; width to right of offset
			Move.W		(A4),D4					; width to left of offset
			Sub.W		D4,D2					; get difference
			AsR.W		#1,D2					; divide by 2
			Add.W		D2,D4					; width to middle of last char
			MoveQ		#1,D0					; point was found
			Swap		D0						; store flag in high byte
			MoveQ		#0,D2					; assume right
			Cmp.W		D4,D3					; compare to pixel width
			Bge.S		@3						; left if pixel width is less

			MoveQ		#1,D2					; else it's to the left
			Bra.S		@3

@2			MoveQ		#0,D0					; found flag is false
			MoveQ		#0,D2					; right of offset

@3			Move.W		(A4),D0					; return pixel width
			Move.L		(SP)+,D3				; stack or heap?
			Beq.S		@4						; 0 means heap

			Add.L		D3,SP					; else fix the stack
			Bra.S		@5

@4
			Move.L		(SP)+,A4				; restore ptr for dispose

			MoveM.L		D0-D2,-(SP)				; save stuff
			Move.L		A4,A0
			_DisposPtr							; dispose of char widths array
			MoveM.L		(SP)+,D0-D2				; restore stuff

@5			MoveM.L		(SP)+,D3-D4/A4

			Rts


; ----------------------------------------------------------------------

; 			DoSearch
; 			** Rewritten 6/18/86 MBK **

; ----------------------------------------------------------------------
DoSearch

; ** <C139/10Sep86/MBK> ** Modified to call Preamble to get A2; the index
; 							is in D0, but don't use it since it's not
; 							documented in Inside Mac

			Bsr			Preamble				; get A2 from D3

			Move		(A2),D3 				; set left anchor			<14Jan86>
			Move		D3,D4 					; init char counter

			Bsr 		LineRect				; set rLine to A2 line

			Move		(A2),D7 				; set left anchor

			Move.W		teSelPoint+h(A3),D5		; get h coord
			Sub.W		teSelRect+left(A3),D5	; subtract justification
			Move		teSelRect+left(A3),teSelRect+right(A3)	; init right side to left
			Move.W		#$8002,teSelRect+left(A3)	; bogus left

			Move.W		2(A2),D6				; end of line

			Tst.W		teSize(A3)				; check style flag
			Bmi.S		@0

			MoveQ		#1,D2					; just 1 style
			Move.W		D3,D1					; start of line
			Move.W		D6,D0					; whole line
			Bra.S		@3

@0			Move.W		D3,D0					; get selection start!!!
			Move.W		D6,D1					; end of line
			Bsr			Get1stStyle				; get 1st style (depending on teSysJust)
			Move.L		A0,A2					; preserve ptr to current style
			Move.W		D0,D2					; preserve # of styles

			Move.L		teStylesH(A3),A0		; handle to style info	** <C381/6nov86/MBK> **
			_HLock								; lock it up			** <C381/6nov86/MBK> **
			Move.L		A2,A0					; restore style ptr		** <C381/6nov86/MBK> **

@1			Move.L		A0,A2					; save ptr to style start
			Bsr			SetStyle				; set the style
			Move.W		startChar(A0),D1		; get start of style
			AddQ.L		#stStartSize,A0			; pt to next style
			Move.W		startChar(A0),D0		; start of next style
			Cmp.W		D3,D1
			Bhs.S		@2						; made this unsigned	** <C381/6nov86/MBK> **
			Move.W		D3,D1					; reset if needed

@2			Move.W		D1,D7
			Cmp.W		D0,D6					; compare to end of line
			Bhs.S		@3						; made this unsigned	** <C381/6nov86/MBK> **
			Move.W		D6,D0					; set end of style to end of line

@3			Move.W		D2,-(SP)
			Sub.W		D1,D0					; length
			Move.L		teTextH(A3),A0			; handle to text
			Move.L		(A0),A0					; dereference
			AddA.W		D1,A0					; add offset to start of line
			Move.W		D5,D1					; get pixel offset
			MoveQ		#0,D2					; slop					** <C139/22Sep86/MBK> **
; 			Bsr			Pixel2Char				; measure all at once
			Bsr.S		TEHitTestHook			; call our hook instead				<C971/RWW111887>

			Add.W		D0,teSelRect+right(A3)	; update selRect
			Sub.W		D0,D5					; update pixel offset
			Add.W		D1,D7					; update char offset

			Swap		D0						; get flag
			Tst.W		D0						; pixel to left of offset?
			Bne.S		HitIt					; point was found

			Add.W		D1,D4					; current position
			Cmp.W		D4,D6					; reached end of line?
			Bls.S		@4						; made this unsigned	** <C381/6nov86/MBK> **

			Move.L		A2,A0					; ptr to current style
			Move.W		(SP)+,D2				; restore style count
			Bsr			GetNextStyle			; get next one based on teSysJust
			SubQ		#1,D2					; dec # of styles
			Bne.S		@1						; keep looping if more			<C971/RWW102887>NO

			MoveQ		#1,D7					; decremented below
			Bra.S		findLeft				; force to loc 0 on left

@4			Move.W		#$7FFE,teSelRect+right(A3)	; else store bogus right
			MoveQ		#0,D2					; assume right
			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference

; ** <C971/RWW110387>	Added this code to support tabs
; 			Cmp.B		#$0D,-1(A0,D7)			; get the last charleft
			Move.B		-1(A0,D7),D0			; THESE TWO LINES REPLACE PREVIOUS	<C971/RWW110387>
			Bsr.S		TEEolHook				; 									<C971/RWW110387>

			Bne.S		hitIt					; must be right

			MoveQ		#1,D2					; else set left if CR
hitIt
			AddQ.L		#2,SP					; remove count from stack
			SF			teLftClick(A3)			; assume to right
			Tst.W		D2						; left or right?
			Beq.S		findDone

findLeft	SubQ		#1,D7					; adjust result to left half
			ST			teLftClick(A3)			; mark it to left

findDone
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@5

			Move.L		teStylesH(A3),A0		; handle to style info
			_HUnlock							; unlock it

@5			Move		D7,D0					; return in D0
			Bra			doBye


; ----------------------------------------------------------------------

; 	TEEolHook
; 	<C971/RWW110387>

; 	This vectored routine was added to make life simpler for those who
; 		wanted to add tabs to TextEdit.  We won't officially support it,
; 		but it's here for people who need it.

; ----------------------------------------------------------------------

TEEolHook
			Move.L		teDispatchH(A3),A0
			Move.L		(A0),A0					; get at table
			Move.L		EOLHook(A0),A0
			Jmp			(A0)

; ----------------------------------------------------------------------

; 	xEOLHook
; 	<C971/RWW110387>

; 	Actual routine that tests character as end-of-line character.  Stock
; 		version only checks for CR.  To support tabs you'd add a
; 		test for TAB here as well, and then determine if the TAB puts
; 		you over the length for Òend of lineÓ.

; 	ENTRY:	D0.B	=	character to check

; ----------------------------------------------------------------------
XEOLHook	Cmp.B		#$0D,D0					; is it a CR?
			Rts									; return with telltale CCR


; ----------------------------------------------------------------------

; 	TEWidthHook
; 	<C971/RWW110387>

; 	Added hook for those needing to intercept the measurement of a line

; 	Stock version only calls Char2Pixel.  To support tabs, you'd check
; 		the selection to be measured for tabs and add in the appropriate
; 		tab widths.

; 	ENTRY:	A0.L	=>	Text to measure
; 			D0.W	=	Length of text to be measured
; 			D1.W	=	Offset into text
; 			D2.L	=	Slop (low word)
; 						Hilite flag (high word)

; 	EXIT:	D1.W	=	Width of measured text

; ----------------------------------------------------------------------
TEWidthHook
			Move.L		teDispatchH(A3),A1
			Move.L		(A1),A1
			Move.L		WIDTHHook(A1),A1
			Jmp			(A1)

; ----------------------------------------------------------------------

; 	TEHitTestHook
; 	<C971/RWW111887>

; 	Added hook for those needing to intercept hit testing on a line

; 	Stock version only calls Pixel2Char.  To support tabs, you'd check
; 		the selection to be tested and add in the appropriate tab widths.

; 	ENTRY:	A0.L	=>	ptr to start of block
; 			D0.W	=	Length of block
; 			D1.W	=	Pixel width relative to start of block
; 			D2.L	=	Slop

; 	EXIT:	D0.L	=	Pixel width to last offset (low word)
; 						BOOLEAN = TRUE if offset corresponding to
; 							the given pixel width was found (high word)
; 			D1.W	=	Character offset
; 			D2.W	=	Flagged if hit on left of char
; ----------------------------------------------------------------------
TEHitTestHook
			Move.L		teDispatchH(A3),A1
			Move.L		(A1),A1
			Move.L		HITTESTHook(A1),A1
			Jmp			(A1)

; ----------------------------------------------------------------------

; 	TEDrawHook
; 	<C971/RWW110387>

; 	Added hook for those needing to intercept the drawing of a line

; ----------------------------------------------------------------------
TEDrawHook
			Move.L		teDispatchH(A3),A1
			Move.L		(A1),A1					; get at table
			Move.L		DRAWHook(A1),A1
			Jmp			(A1)

; ----------------------------------------------------------------------

; 	xDRAWHook
; 	<C971/RWW110387>

; 	Actual routine that does drawing.  Stock version only does _DrawText.
; 		To support tabs, you'd check the selection to be drawn for tabs,
; 		and take appropriate action on the intervening pieces.

; 	ENTRY:	A0.L	=>	text to draw
; 			D0.W	=	starting character
; 			D1.W	=	length to draw

; ----------------------------------------------------------------------
xDRAWHook	Move.L		A0,-(SP)
			Move.W		D0,-(SP)
			Move.W		D1,-(SP)
			_DrawText
			Rts

; ----------------------------------------------------------------------

; 			DoDraw

; 			** Rewritten 6/18/86 by MBK **

; 			Given display start and end in [D3..D4], this draws the text

; ----------------------------------------------------------------------

DoDraw
			Bsr 		PinDisplay
			Bsr			Preamble				; set rLine to A2 line

; ** <C105/14aug86/MBK> Only call LineRect at start to avoid height search **
			Bsr			LineRect

@0			Bsr			PrepLine				; pin D4 at line end
			Bls			doBye					; done...

			Bsr			ChkBounds				; extend bounds if necessary
			Tst.W		teSysJust				; reverse order?
			Beq.S		@05						; no, normal

			Move.W		#$8002,teSelRect+left(A3)	; else, set unbound left

@05			Move.W		D4,D6					; selEnd
			Bsr			DoErase					; to fix italics problem** <C182/2oct86/MBK> **

			Move.W		saveLeft(A6),-(SP)		; saved true left value	** <C105/18aug86/MBK> Got rid of rTrue **
			Move.W		teSelRect+top(A3),-(SP)	; position pen
			Move		teAscent(A3),D0

			Tst.W		teSize(A3)				; check style flag
			Bmi.S		@1

; record has no style, so draw all at once	(the old way)
			Add 		D0,(SP) 				; drop pen to baseline
			_MoveTo

			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference
			Add.L		D3,A0					; offset pointer

; ** <C971/RWW110387>	Added code to support tabs
; 			Move.L		A0,-(SP)				; pass pointer
; 			Clr 		-(SP)					; no offset
; 			Move		D4,-(SP)				; range
; 			Sub 		D3,(SP) 				; draw amt := range-i
; 			_DrawText							; draw it

			Clr.W		D0						; D0-D1 aren't a concern, sinceÉ	<C971/RWW110387>
			Move.W		D4,D1					; Éone would expect _DrawTextÉ		<C971/RWW110387>
			Sub.W		D3,D1					; Éto blow them away anyways		<C971/RWW110387>
			Bsr.S		TEDrawHook				; go draw it						<C971/RWW110387>

			Bra.S		@6						; 								<C971/RWW102887>NO

; record has style, so draw one style at a time
@1			Tst.W		D0						; check default ascent
			Bpl.S		@2						; use it if set

			Bsr			PtrToLine				; get line #
			Ext.L		D0						; make it long just in case	** <C381/6nov86/MBK> **
			LsL.L		#2,D0					; mult by 4					** <C381/6nov86/MBK> **

			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; deref
			Move.L		lhTab(A0),A0			; array of max hite indeces
			Move.L		(A0),A0					; deref
			Move.W		2(A0,D0.L),D0			; max ascent

@2			Add 		D0,(SP) 				; drop pen to baseline
			_MoveTo

			Move.W		D3,D0					; start offset
			Move.W		D4,D1					; end of selection

; ** <C105/13aug86/MBK> Changed to Get1stStyle for International **
			Bsr			Get1stStyle				; get its style
			Move.W		D0,D2					; save style count

@3			Move.L		A0,A4					; ptr to style
			Bsr			SetStyle				; set style
			Move.W		startChar(A0),D0		; get start of style
			AddQ		#stStartSize,A0			; ptr to next style
			Move.W		D6,D4					; init to end of line
			Cmp.W		startChar(A0),D6		; compare to end of line
			Blo.S		@4
			Move.W		startChar(A0),D4		; set to end of style

@4			Move.W		D2,-(SP)				; save the count
			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference

			Cmp.W		D3,D0
			Bhs.S		@5						; made this unsigned	** <C381/6nov86/MBK> **
			Move.W		D3,D0					; reset if needed

@5			AddA.W		D0,A0					; offset pointer


; ** <C971/RWW110387>	Added code to support tabs
; 			Move.L		A0,-(SP)				; pass pointer
; 			Clr 		-(SP)					; no offset
; 			Move		D4,-(SP)				; range
; 			Sub 		D0,(SP) 				; draw amt := range-i

			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1
			Sub.L		A1,A4					; save as an offset

; 			_DrawText							; draw it

			Move.W		D4,D1					; amount := range - i				<C971/RWW110387>
			Sub.W		D0,D1					; 									<C971/RWW110387>
			Clr.W		D0						; no offset							<C971/RWW110387>
			Bsr			TEDrawHook				; go draw it						<C971/RWW110387>

; Unlock the style handle when through with pointer.
			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1
			Add.L		A1,A4					; restore as pointer

			Move.L		A4,A0					; ptr to style
			Move.W		(SP)+,D2				; restore the count

			Bsr			GetNextStyle			; get next based on teSysJust
			SubQ		#1,D2					; dec the style counter
			Bne.S		@3						; must be more than 1 line

; ** <C105/14aug86/MBK> NextLineRect will not search for height from start **
@6			Bsr			PtrToLine				; convert A2 to line #
			AddQ		#1,D0					; next line
			Bsr			NextLineRect			; set next line's rect
			Move		(A2),D3 				; get start
			Bra 		@0						; keep going

doBye
			MoveM.L 	(SP)+,D2-D7/A2-A4		; restore regs
			Unlk		A6						; unlink DoText frame
			Move.L		grafGlobals(A5),A0		; get the port in A0 for
			Move.L		thePort(A0),A0			; compatibility
			Rts

; ----------------------------------------------------------------------

; 			DoErase

; 			** <C182/2oct86/MBK> **

; 			DoErase was added to solve the problem of half the previous
; 			character getting erased when an EraseRect is done before
; 			drawing the current character. (This is a problem for Italics
; 			And certain special fonts). In DoErase, if the offset is the
; 			same as the line start, I still erase the whole line, in case
; 			of a change in line height (and the offset must be the same as
; 			a line start if the line height has changed); otherwise, I
; 			don't erase the previous character since it's going to be
; 			drawn over anyway.

; 	Entry:
; 			D3:		start offset
; 			A2:		line start

; ------------------------------------------------------------------------
DoErase
			Move.W		teSelRect+left(A3),-(SP)	; save left side for draw
			Cmp.W		(A2),D3					; at start of line?

			Beq.S		@2						; don't worry if so

; If the mode is XOR, we must erase the previous character as well as redrawing it.
; Redrawing the character in XOR without erasing it first just erases it.  This means
; the italics problem will not be fixed in this mode.
			Cmp.W		#srcXor,teMode(A3)		; is drawing mode XOR?
			Beq.S		@2						; do it the old way if so

			Tst.W		teSize(A3)				; TERec with style?
			Bpl.S		@1						; skip style setup if not

			Move.W		D3,D0					; selection start
			Move.W		D0,D1					; don't care about end
			Bsr.S		Get1stStyle				; 1st style on line				<C971/RWW102887>NO
			Bsr			SetStyle				; set the port

@1			SubQ.L		#2,SP					; room for result
			Move.L		teTextH(A3),A0			; text handle
			Move.L		(A0),-(SP)				; ptr on stack
			Move.W		D3,-(SP)				; offset to current char
			Move.W		#1,-(SP)				; just one char
			_TextWidth							; how wide is it?
			Move.W		(SP)+,D0				; this wide

; Don't want to erase the prev character because that destroys part of the character
; before it (if it's italics or a kerned font).  However, the last pixel should be erased
; in case the application leaves a caret drawn there (like Mac3D does).
			Tst.W		D0						; nothing to do if no width			** <C485/04dec86/MBK> **
			Beq.S		@0						; else subtract one from char width	** <C485/04dec86/MBK> **
			SubQ.W		#1,D0					; 	to fix caret erase problem		** <C485/04dec86/MBK> **
@0
			Add.W		D0,teSelRect+Left(A3) 	; adjust left

@2			Pea 		teSelRect(A3)			; erase the expanded rect
			_EraseRect
			Move.W		(SP)+,teSelRect+left(A3)	; restore left side for draw

			Rts



; ----------------------------------------------------------------------

; 			Get1stStyle

; 			** <C105/13aug86/MBK> Added for International **

; 			This returns the 1st style block found on a line of text
; 			If teSysJust = 0, and the last style block on the line
; 			otherwise.

; 	Entry:
; 			D0:		start offset
; 			D1:		End offset

; 	Exit:
; 			A0:		ptr to style block to be processed 1st
; 			D0:		number of styles between the 2 offsets

; ----------------------------------------------------------------------

Get1stStyle
			Bsr			GetCurStyle				; get style at start offset
			Bsr			GetNumStyles			; get # of styles in string
			Tst.W		teSysJust				; is text left to right?
			Beq.S		@0						; if so, that's it

			MoveQ		#0,D1					; clear whole register		** <C381/6nov86/MBK> **
			Move.W		D0,D1					; else, get # of styles
			SubQ.W		#1,D1
			LsL.L		#2,D1					; * stStartSize				** <C381/6nov86/MBK> **
			Add.L		D1,A0					; to pt to last style block	** <C381/6nov86/MBK> **

@0			Rts


; ----------------------------------------------------------------------

; 			GetNextStyle

; 			** <C105/13aug86/MBK> Added for International **

; 			This returns the next style block found on a line of text.
; 			If teSysJust = 0, this is the following style block;
; 			If teSysJust <> 0, this is the preceding style block.

; 	Entry:
; 			A0:		ptr to current style block

; 	Exit:
; 			A0:		ptr to next style block

; ----------------------------------------------------------------------

GetNextStyle
			Tst.W		teSysJust				; is text left to right?
			Beq.S		@0

			SubQ.L		#stStartSize,A0			; no, get preceding style
			Bra.S		@1

@0			AddQ.L		#stStartSize,A0			; yes, get following style

@1			Rts


; ----------------------------------------------------------------------

; 			PrepLine

; 			Given display start and end in [D3..D4], and a line start in
; 			(A2), this gets the line's rectangle in rLine(A6).  Then pins
; 			D4 at the lineStart of the next line.  Then gets the range's
; 			rectangle in rTrue.  And, the expanded rect in teSelRect(A3).
; 			(It calls range rect to do this).  Finally exits with CC's
; 			Set according to D3 and D5(the length).

; 		Exit:
; 			CC's set to relationship of D3 to dispEnd in D5


; ----------------------------------------------------------------------
PrepLine
			Move		D5,D4					; get right
			Cmp 		2(A2),D4				; pin to right
			Blo.S		@0
			Move		2(A2),D4				; set to line end
@0
			Bsr 		RangeRect				; get rect from D3 to D4 in teSelRect

			Cmp 		D3,D5					; finished?
			Rts


; ----------------------------------------------------------------------

; 			Preamble

; 			Given display start and end in [D3..D4], this first sorts the
; 			two, and copies D4 into D5.  Then, it skips to the lineStart
; 			entry containing D3.  It sets up A2 to point to that line.

; 		Exit:
; 			CC's set to relationship of D3 to the next line's start, 2(A2)
; 			D5 a copy of incoming D4

; ----------------------------------------------------------------------
Preamble
			Move.L		(SP)+,A0				; get local RTS
			MoveM.L 	D2-D7/A2-A4,-(SP)
			Move.L		A0,-(SP)				; replace RTS

			Cmp 		D3,D4					; sort range
			Bhs.S		@0
			Exg 		D4,D3					; swap regs
@0
			Cmp 		teLength(A3),D4 		; pin disp end
			Blo.S		@1
			Move		teLength(A3),D4 		; pin disp end
@1

			Lea 		teLines(A3),A2			; point to line starts

			And.L		lo16,D4 				; longize D4
			Move		D4,D5					; save D5 as limit
			And.L		lo16,D3 				; longize D3

			Beq.S		@2						; skip out if 1st line(for empty rec.)

			Move.W		D3,D0
			Bsr.S		GetLine					; get its line ptr				<C971/RWW102887>NO
@2
			Rts


; ----------------------------------------------------------------------

; 			GetLine

; 			Given an offset, find the ptr to the line it's on.

; 	Entry:	D0:		offset
; 			A2:		ptr to line from which to start search

; 	Exit:	A2:		ptr to line on which offset is found

; ----------------------------------------------------------------------

GetLine
@0			Cmp 		2(A2),D0				; D0 past or at next linestart?
			Bls.S		@1						; if at next line start

			AddQ		#2,A2					; next lineStart
			Bra.S		@0
@1
			Bne.S		@2						; if AT next line start
			AddQ		#2,A2					; next lineStart
@2
			Rts


; ----------------------------------------------------------------------

; 			DoText funnel proc for compatibility

DoText
			Move.L		teDoText,-(SP)
			Rts
XDoText
			Link		A6,#txtLink 			; link frame for DoText procs

			Tst 		D7						; check dispatch code
			Beq 		DoSearch
			Bgt.S		DoHilite
			Cmp 		#-1,D7
			Beq 		DoDraw					; fall into doCaret

; ----------------------------------------------------------------------

; 			DoCaret

; 			Given display start sets up the caret rect in teSelRect.  Note
; 			all the weird shit it has to do because of caret positioning
; 			around the end of a line and at the end of the text.

; ----------------------------------------------------------------------

DoCaret
			Bsr.S		Preamble				; set rLine to A2 line

			Tst 		D3						; special case @ 1st character		<03Nov85> SC
			Beq.S		@2						; if so skip all these checks		<03Nov85> SC

			Cmp 		(A2),D3 				; right at line start?
			Bne.S		@2						; skip if not next-line start

			Move		teLength(A3),D0 		; are we past last char?
			Beq.S		@2						; (and is there a last char?)
			Cmp 		D0,D3					; are we past last char?
			Blo.S		@0						; if not, skip special case

			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference

; ** <C971/RWW110387>	Added this code to support tabs
; 			Cmp.B		#$0D,-1(A0,D3)			; if last char <> CR then...

			Move.B		-1(A0,D3),D0			; THESE TWO LINES REPLACE PREVIOUS	<C971/RWW110387>
			Bsr			TEEolHook				; 									<C971/RWW110387>

			Beq.S		@2						; skip the line

			Bra.S		@1
@0
			Tst.B		teLftCaret(A3)			; to left?
			Bne.S		@2						; skip line pull back if so
@1
			SubQ		#2,A2					; skip to previous line
@2
			Bsr			LineRect				; removed from Prep		** <C105/14aug86/MBK> **
			Bsr			PrepLine				; get selRect from D3..D4		<C971/RWW102887>NO

			Move		saveLeft(A6),D0			; get caret loc
			Move		D0,teSelRect+right(A3)	; and set in teSelRect
			SubQ		#1,D0
			Move		D0,teSelRect+left(A3)

			Bra 		doBye


; ----------------------------------------------------------------------

; 			DoHilite

; ----------------------------------------------------------------------

DoHilite
			Bsr 		PinDisplay
			Bsr			Preamble				; set rLine to A2 line

			Bsr			LineRect				; get top, bottom and just
			Bsr			PrepLine				; pin D4 at line end
			Bls.S		@1						; done...						<C971/RWW102887>NO

			Bsr.S		ChkBounds				; check far left and right		<C971/RWW102887>NO

			Move.L		teHiHook(A3),D0 		; do the inversion via hook if
			Bsr 		InvertHook				; there

			Cmp.W		2(A2),D5				; only 1 line?
			Bls.S		@1						; made this unsigned	** <C381/6nov86/MBK> **

			Bsr			PtrToLine				; get current line #
			Move.W		D0,D1					; save it
			Move.W		D5,D0					; offset to look for
			Bsr			GetLine					; get D5 line ptr
			Bsr			PtrToLine				; convert A2 ptr to line #
			AddQ		#1,D1
			Cmp.W		D0,D1					; get the difference
			Beq.S		@0						; no lines inbetween

			Move.W		D0,-(SP)				; save line #
			Exg			D0,D1
			Move.W		teSelRect+bottom(A3),teSelRect+top(A3)
			Bsr			GetLineHites			; hites from 2nd to last lines
			Add.W		D0,teSelRect+bottom(A3)	; hite to last line
			Move.W		#$8002,teSelRect+left(A3)	; far left
			Move.W		#$7FFE,teSelRect+right(A3)	; far right

			Move.L		teHiHook(A3),D0
			Bsr			InvertHook				; hilite it
			Move.W		(SP)+,D0				; restore line #

; hilite last line
@0			Bsr.S		NextLineRect			; get rectangle for last line	<C971/RWW102887>NO
			Move.W		(A2),D3					; for chkBounds
			Bsr			PrepLine				; get left and right
			Bls.S		@1						; done...

			Bsr.S		ChkBounds				; check far left and right		<C971/RWW102887>NO

			Move.L		teHiHook(A3),D0 		; do the inversion via hook if
			Bsr 		InvertHook				; there

@1			Bra 		doBye


; ----------------------------------------------------------------------

; 			ChkBounds

; 			** <C139/22Sep86/MBK> Added for International **

; 			The left and right sides of the selection rectangle are
; 			extended if the line start = the selection start and the
; 			line end = the selection end, respectively.

; 	Entry:
; 			A2 :	Ptr to the current line

; ----------------------------------------------------------------------

ChkBounds
			Move.W		(A2),D0					; start of line
			Move.W		2(A2),D1				; end of line
			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@2						; skip ahead if not
			Tst.W		teSysJust				; reverse order?
			Beq.S		@2						; this is easy if not

			Bsr			Get1stStyle				; get actual 1st style
			SubQ		#1,D0					; look for end of last style
			Bne.S		@0

; Reset start and end of line if only 1 style
			Move.W		(A2),D0					; reset start of line
			Move.W		2(A2),D1				; end of line
			Bra.S		@2

; more than 1 style, so find actual start and end line offsets
@0			SubQ		#1,D0					; dec style count
			LsL.W		#2,D0					; * stStartSize				** <C381/6nov86/MBK> **
			Neg			D0						; negative for subtraction

			Move.W		startChar(A0,D0),D1		; start of next-to-last style
			Move.W		(A2),D0					; get start of line again
			Cmp.W		startChar(A0),D0		; compare to start of style
			Bhs.S		@2						; made this unsigned	** <C381/6nov86/MBK> **

			Move.W		startChar(A0),D0		; else set to style start

; if block begins at start of line, make left a large negative number
@2			Cmp.W		D0,D3
			Bne.S		@3
			Move.W		#$8002,teSelRect+left(A3)

; if block ends at end of line, make right a large positive number
@3			Cmp.W		D1,D4
			Bne.S		@4
			Move.W		#$7FFE,teSelRect+right(A3)

@4			Rts

; ----------------------------------------------------------------------

; 			NextLineRect

; 			** <C105/14aug86/MBK> Added to speed things up **

; 			LineRect was being called from the line drawing loop in
; 			DoDraw, and adding up line heights from the 1st line to the
; 			current one.  That was fine for fixed line heights, but too
; 			slow for variable ones.  Now I call NextLineRect from the
; 			loop to simply set the top of this line from the bottom of
; 			the previous one, and get the height of this line only to
; 			Set the bottom.  NextLineRect also calls DoJust to set
; 			the justification.

; 	Entry:
; 			D0:		Current line #
; 	Exit:
; 			A2:		Ptr to current line #

; ----------------------------------------------------------------------

NextLineRect
			Move.W		teSelRect+bottom(A3),teSelRect+top(A3)
			Bsr			GetHite					; get height of this line
			Add.W		D1,teSelRect+bottom(A3)	; adjust bottom

; ** <C381/5nov86/MBK> ** Replaced call to LineToPtr with these 2 lines
; 							since noone else called it
			Add.W		D0,D0					; double for word entries	** <C381/5nov86/MBK> **
			Lea			teLines(A3,D0),A2		; pt to line starts array	** <C381/5nov86/MBK> **

			Move.W		teDestRect+left(A3),teSelRect+left(A3)
			Bsr.S		DoJust					; set the justification			<C971/RWW102887>NO

			Rts


; ----------------------------------------------------------------------

; 			PtrToLine

; 			** <C105/14aug86/MBK> **

; 			Get the line # from the A2 value.

; 	Entry:
; 			A2:		Ptr to current line #
; 	Exit:
; 			D0:		Current line #

; ----------------------------------------------------------------------

PtrToLine
			Lea			teLines(A3),A0			; pt to line starts array
			Move.L		A2,D0					; current line ptr
			Sub.L		A0,D0					; current line offset
			AsR.L		#1,D0					; current line number

			Rts


; ----------------------------------------------------------------------

; 			LineRect

; 			** Modified 6/18/86 by MBK **

; 			Given the line start array in A2, this fills in the rLine(A6)
; 			With the rectangle for that line except that right = left.
; 			It adjusts the rect for the current format.

; ----------------------------------------------------------------------

LineRect
			Bsr.S		PtrToLine				; get line # from A2			<C971/RWW102887>NO

			Move.W		D0,D1
			MoveQ		#0,D0					; from 0 to this line	** MBK 6/18/86 **
			Bsr.S		GetLineHites			; get height 					<C971/RWW102887>NO

			Lea 		teDestRect+8(A3),A0 	; point past destRect
			Lea 		teSelRect+8(A3),A1		; and past stack rect
			Move.L		-(A0),-(A1)
			Move.L		-(A0),-(A1)
			Add 		D0,(A1) 				; add to top

			Move		top(A1),bottom(A1)
			Move.W		D1,D0					; current line			** MBK 6/18/86 **
			Bsr			GetHite					; height of this line	** MBK 6/18/86 **
			Add 		D1,bottom(A1)			; add line height to bottom

; now offset to right according to the format

; ** <C105/12aug86/MBK> ** Added the DoJust label for just doing justification
DoJust
; ** <C229/28oct86/MBK> ** Changed to save justification on stack instead of in D2
			Move.W		teJust(A3),-(SP)		; get justification		** <C105/12aug86/MBK> **
			Bne.S		@0						; go process if not left** <C105/12aug86/MBK> **

			Move.W		teSysJust,(SP)			; check text direction	** <C105/12aug86/MBK> **
			Beq.S		@2						; do nothing if left

@0
			Cmp.W		#teForceLeft,(SP)
			Beq.S		@2

			Bsr			LineWidth				; get width of (A2) line in D0

			Move		teDestRect+right(A3),D1
			Sub 		teDestRect+left(A3),D1
			Sub 		D0,D1
			SubQ		#1,D1					; subtract one for caret

			Tst.W		(SP)					; see what format
			Bmi.S		@1
			AsR 		#1,D1					; div by 2 for centering
@1
			Add 		D1,teSelRect+left(A3)	; bump rect over
@2
			AddQ		#1,teSelRect+left(A3)	; indent for caret
			Move		teSelRect+left(A3),teSelRect+right(A3)
			Move.W		teSelRect+left(A3),saveJust(A6)	; left just		** <C105/18aug86/MBK> **

			AddQ.L		#2,SP					; restore it			** <C105/12aug86/MBK> **

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE GetLineHites
; 			** Added 6/3/86 by MBK **

; 			Gets the line height of each line from start to end line and
; 			returns the total of all the line heights.  If teLineHite
; 			has a non-zero value, a fixed line height is used
; 			for each line. Otherwise, GetLineHites gets the line height
; 			for each line from the MaxHites array.

; 	Entry:
; 			D0 	starting line #
; 			D1 	ending line #		(Preserved)

; 	Exit:
; 			D0 	total distance in pixels from top of start line to top of
; 				End line

; ----------------------------------------------------------------------
GetLineHites
			MoveM.L		D1-D2,-(SP)				; save stuff

; If this TERec has no style, just use the old teLineHite
			Sub.W		D0,D1					; get # of lines
			Beq.S		@0						; if none, skip this

			Move.W		teLineHite(A3),D2		; get default line hite
; If lineHite is positive, use it no matter what type of TERec.
			Bpl.S		@0

			Tst.W		teSize(A3)				; check style flag
			Bmi.S		@1						; if not, use TERec value

; somebody set the default, so use fixed line height for all lines
@0			MulU		D1,D2					; * fixed line height
			Bra.S		@3						; that was easy!				<C971/RWW102887>NO

; Get maximum height on this line from the array
@1			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; dereference
			Move.L		lhTab(A0),A0			; handle to max hites
			Move.L		(A0),A0					; dereference
			LsL.W		#2,D0					; multiply by 4
			AddA.W		D0,A0					; starting line
			MoveQ		#0,D2					; line height accumulator

@2			Move.W		(A0),D0					; get line height		** <C105/28aug86/MBK> **
			And.W		#$7FFF,D0				; mask out high bit		** <C105/28aug86/MBK> **
			Add.W		D0,D2					; accumulate heights
			AddQ		#4,A0					; point to next
			SubQ		#1,D1					; dec the counter
			Bne.S		@2						; keep accumulating

@3			Move.L		D2,D0					; answer in D0
			MoveM.L		(SP)+,D1-D2				; restore stuff

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE GetHite

; 			** Added 6/16/86 by MBK **

; 			Gets the line height of the given line.

; 	Entry:
; 			D0 	line number
; 	Exit:
; 			D1 	height of this line

; ----------------------------------------------------------------------
GetHite
; If this TERec has no style, just use the old teLineHite
			Move.W		teLineHite(A3),D1		; get default line height
			Bpl.S		@0						; use it if set			** <C381/5nov86/MBK> **
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; if not, use TERec value

; Get maximum height on this line from the array
			Move.L		teStylesH(A3),A0		; handle to style info	** <C381/5nov86/MBK> **
			Move.L		(A0),A0					; dereference			** <C381/5nov86/MBK> **
			Move.L		lhTab(A0),A0			; handle to max hites	** <C381/5nov86/MBK> **
			Move.L		(A0),A0					; dereference
			Move.W		D0,D1					; preserve D0			** <C381/5nov86/MBK> **
			LsL.W		#2,D1					; for 2 word entries	** <C381/5nov86/MBK> **
			Move.W		0(A0,D1),D1				; get height			** <C381/5nov86/MBK> **
			And.W		#$7FFF,D1				; mask out high bit		** <C105/28aug86/MBK> **


@0			Rts


; ----------------------------------------------------------------------

; 			LineWidth

; 			Measures the width of the line at (A2)..2(A2).  Trims break chars
; 			from the right side

; 	 Entry
; 			A3 = dereferenced handle to TE object

; 	 Exit
; 			leaves the width in D0

; ----------------------------------------------------------------------

LineWidth
			Move		(A2),D6 				; get left anchor
			Move		2(A2),D7				; get right part

MeasD6D7
			Move.L		teTrimMeasure,-(SP) 	; push trimMeasure routine			<EHB 01Oct85>
			Rts 								; and call it						<EHB 01Oct85>

XTrimMeasure
			Cmp 		teLength(A3),D6 		; are we past last char?
			Beq.S		zeroExit				; escape quick					<C971/RWW102887>NO

			Cmp 		D6,D7					; is line empty?
			Bls.S		zeroExit				; if so, skip trimming(fast exit)<C971/RWW102887>NO

			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference

@0			SubQ		#1,D7					; look to left
			Cmp 		D6,D7
			Beq.S		@1						; assume done if = to left

			Cmp.B		#$20,0(A0,D7) 			; if last char <= space then...
			Bls.S		@0						; it's a break

@1			AddQ		#1,D7					; use next char

			; fall into MeasureIt				; get width in [D6 to D7)


; ----------------------------------------------------------------------

; 			MeasureIt

; 			** Rewritten 6/20/86 by MBK **

; 	 Entry
; 			A3 = dereferenced handle to TE object
; 			Does a TextWidth for teTextH(A3), [D6 to D7]
; 	 Exit
; 			leaves the width in D0

; ----------------------------------------------------------------------
MeasureIt
			Cmp 		D6,D7					; nothing to measure?
			Bls.S		zeroExit				; 								<C971/RWW102887>NO

			MoveM.L		D2/D4/D6,-(SP)			; save stuff
			And.L		lo16,D6 				; longize it

; Skip all the new stuff if style is not set
			Tst.W		teSize(A3)				; record with style?
			Bmi.S		@0						; if not, go do it the old way

			Move.W		D7,D0					; end offset
			Bsr.S		GetWidth				; get string width				<C971/RWW102887>NO
			Move.W		D1,D0					; return width in D0
			Bra.S		@3

; Record does have style; get # of styles within selection
@0			MoveQ		#0,D4					; clear accumulator
			Move.W		D6,D0					; start of selection
			Bsr			GetCurStyle				; get current style
			Move.W		D7,D1					; end of selection
			Bsr			GetNumStyles			; # of styles in selection
			Move.W		D0,D2					; save # of styles

; Set the GrafPort to the current style
@1			Bsr			SetStyle				; set current style
			AddQ		#stStartSize,A0			; pt to next style
			Move.W		startChar(A0),D0		; start of next style
			Cmp.W		D0,D7					; compare to end of selection
			Bhs.S		@2						; ok if less

			Move.W		D7,D0					; else set to end of selection

; Get the width of this selection
@2			Move.W		D2,-(SP)				; save the count
			Bsr.S		GetWidth				; get string width				<C971/RWW102887>NO

; Accumulate total width of the selection
			Add.W		D1,D4					; accumulate width
			Move.W		(SP)+,D2				; restore the count
			Move.W		startChar(A0),D6		; start of next style
			SubQ		#1,D2					; dec the style counter
			Bne.S		@1						; more styles

			Move.W		D4,D0					; return width in D0

@3			MoveM.L		(SP)+,D2/D4/D6			; restore stuff

			Rts
zeroExit
			MoveQ		#0,D0					; nothing to measure
			Rts


GetWidth
			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@0						; if not, A0 is nothing

			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1					; dereference
			Sub.L		A1,A0					; save as offset
@0

			Move.L		A0,-(SP)				; save A0

			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0 				; dereference
			Move.W		D6,D1					; offset into text
			Sub.W		D1,D0					; length
			MoveQ		#0,D2					; slop, hilite flag		** <C139/22Sep86/MBK> **

; 			Bsr.S		Char2Pixel				; get width						<C971/RWW102887>NO
			Bsr			TEWidthHook				; THIS LINE REPLACES PREVIOUS		<C971/RWW110387>

			Move.L		(SP)+,A0				; restore A0

			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@1						; if not, A0 is nothing

			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1					; dereference
			Add.L		A1,A0					; restore as pointer
@1
			Rts


; ----------------------------------------------------------------------

; 			Char2Pixel

; 			** <C105/8aug86/MBK> **

; 	Entry:	A0:		ptr to text
; 			D0.W	length of text to be measured
; 			D1.W	offset into text
; 			D2		slop (low word)
; 					hilite flag (high word)

; 	Exit:	D1.W	width of measured text

; ----------------------------------------------------------------------

Char2Pixel
			Move.L		jChar2Pixel,-(SP)		; call the Char2Pixel Routine 		<EHB 01Oct85>
			Rts

vChar2Pixel										; here's our Char2Pixel
			SubQ		#2,SP					; room for result
			Move.L		A0,-(SP)				; pass pointer
			Move.W		D1,-(SP)				; offset
			Move		D0,-(SP)				; length
			_TextWidth							; get width
			Move.W		(SP)+,D1				; resulting width

			Rts


; ----------------------------------------------------------------------

; 			RangeRect

; 			Given the line rect in rLine(A6), this sets teSelRect to the
; 			line rect with the left side at the given loc in D3 and the
; 			right side at D4.  If D3 is the first char on the line, it

; ----------------------------------------------------------------------

RangeRect
			Cmp.W		(A2),D3					; same as line start?
			Bhi.S		@0						; made this unsigned	** <C381/6nov86/MBK> **

			Cmp.W		2(A2),D4				; same as line end?
			Blo.S		@0						; made this unsigned	** <C381/6nov86/MBK> **

; Must set D6 in this case (DoMeasure sets it but MeasureIt doesn't)
			Move.W		(A2),D6					; set D6 to beg of line ** <C454/21nov86/MBK> **

			Move.W		D4,D7					; just need 2nd measure
			Bsr			MeasureIt				; measure whole line
			Add.W		D0,teSelRect+right(A3)	; save right side
			Bra.S		@1						; done with measuring

@0			Move		D3,D7					; get measure right
			Bsr.S		DoMeasure				; measure from [D6..D7)			<C971/RWW102887>NO
			Add 		D0,teSelRect+left(A3) 	; set left

			Move		D4,D7					; get 2nd measure right
			Bsr.S		DoMeasure				; measure from [D6..D7)			<C971/RWW102887>NO
			Add 		D0,teSelRect+right(A3)	; save right side

@1			Lea			teSelRect(A3),A1
			Move.W		left(A1),saveLeft(A6)	; just need to save left

			Move		left(A1),tempRect		; compatibility shit
			Move.L		botRight(A1),-(SP)		; push pen loc for compatibility

; In the pre-Mac+ version Capps used pnLoc throughout DoText.  He added the
; MoveTo here to maintain compatibility with that, but unfortunately in the
; pre-Mac+ version the pnloc is less by line height minus ascent.
; This fixes bug LM-RM-107.  Don't worry about new style records since this
; is only for maintaining compatibility with old apps.

;;	If forRAM THEN
	If (not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; are we on a color system?	(as per Jerome) <C971/RWW112487>
			Bnz.S		@2						; Nope								<C971/RWW112487>
	EndIf

;; <19Feb89smb> If onNuMac|onMvMac|forRAM THEN				; <C914/29Oct87> rwh
			Tst.W		teSize(A3)				; if it's a new style record
			Bmi.S		@2						; 	don't have to worry about it
			Move.W		teLineHite(A3),D0		; else, get hite - ascent
			Sub.W		teAscent(A3),D0
			Sub.W		D0,(SP)					; subtract from pnloc.v
@2
;; <19Feb89smb> EndIf

			_MoveTo 							; compatibility shit

			Rts


; ----------------------------------------------------------------------

; 			DoMeasure
; 			** <C139/22Sep/86> MBK **

; 			DoMeasure was added to handle reverse justification.
; 			DoMeasure measures from the actual start of the line
; 			to the given offset.  MeasureIt is still called directly
; 			when the distance between 2 offsets is desired.

; ----------------------------------------------------------------------

DoMeasure
			MoveM.L		D3/D5-D6,-(SP)
			MoveQ		#0,D5					; width accumulator
			Move.W		(A2),D6					; line start

			Cmp 		D6,D7					; nothing to measure?
			Blo.S		@4						; made this unsigned	** <C381/6nov86/MBK> **

			Tst.W		teSize(A3)				; style record?
			Bpl.S		@3						; just do normal measure if not
			Tst.W		teSysJust				; reverse order?
			Beq.S		@3						; just do normal measure if not

			Move.W		D6,D3					; start offset
			Move.W		(A2),D0					; start of line
			Move.W		2(A2),D1				; end of line
			Bsr			Get1stStyle				; get actual 1st style on line
			Move.W		D7,D0					; end offset

@0			Move.W		startChar(A0),D6		; store actual start of line
			Cmp.W		D6,D3					; should not be less than
			Bls.S		@1						; made this unsigned	** <C381/6nov86/MBK> **

			Move.W		D3,D6					; the selection start

@1			Cmp.W		D6,D7					; if greater than selection end
			Blo.S		@2						; then end is not in this style

			Move.W		D7,D0					; selection end
			Cmp.W		stStartSize(A0),D7		; if less than next style start
			Bls.S		@3						; made this unsigned	** <C381/6nov86/MBK> **

@2			Move.W		stStartSize(A0),D0		; else set end as next
			Cmp.W		2(A2),D0				; style start
			Bls.S		@25						; made this unsigned	** <C381/6nov86/MBK> **

			Move.W		2(A2),D0				; line's end

@25			Move.W		D0,-(SP)				; SetStyle destroys this	** <C229/28oct86/MBK> **
			Bsr			SetStyle				; set the style
			Move.W		(SP)+,D0				; restore length to measure ** <C229/28oct86/MBK> **
			Bsr			GetWidth				; get string width
			Add.W		D1,D5					; accumulate width
			SubQ.L		#stStartSize,A0			; pt to prev style
			Bra.S		@0						; keep measuring

@3			Bsr			MeasureIt				; last measurement
			Add.W		D0,D5					; final width

@4			Move.W		D5,D0					; return width in D0

			MoveM.L		(SP)+,D3/D5-D6

			Rts


; ----------------------------------------------------------------------

; 			PinDisplay

; 			Pins D3 and D4 to the viewRect
; 			Expects A3 the usual TE record
; 			Alternate entry with rect already in A0

; 		Trashes D0, A0

PinDisplay
			Lea 		teViewRect(A3),A0		; use viewRect
PinA0Rect
			Move		top(A0),D0				; load D0 w/top

			Bsr.S		PtToLine				; turn into a lineStart
			Bge.S		@4						; escape if top gone
			Add 		D0,D0					; double for array ref.
			Blt.S		@1
			Cmp 		teLines(A3,D0),D3		; pin D3 to viewRect.top
			Bhs.S		@0
			Move		teLines(A3,D0),D3		; dispStart = lines[i]
@0
			Cmp 		teLines(A3,D0),D4		; pin D4 to viewRect.top
			Bhs.S		@1
			Move		teLines(A3,D0),D4		; dispEnd = lines[i]
@1
			Move		bottom(A0),D0			; get bottom in D0
			SubQ		#1,D0
			Bsr.S		PtToLine

			AddQ		#1,D0					; inc line #			** MBK 6/18/86 **
			Cmp			teNLines(A3),D0			; compare to max		** MBK 6/18/86 **
			Bhi.S		@3						; made this unsigned	** <C381/6nov86/MBK> **

			Add 		D0,D0
			Cmp 		teLines(A3,D0),D3		; pin D3 to viewRect.bottom
			Blo.S		@2
			Move		teLines(A3,D0),D3		; dispStart = lines[i]
@2
			Cmp 		teLines(A3,D0),D4		; pin D4 to viewRect.bottom
			Blo.S		@3
			Move		teLines(A3,D0),D4		; dispEnd = lines[i]
@3
			Rts
@4
			Move		D3,D4					; nothing in range
			Rts


; ----------------------------------------------------------------------

; 			PtToLine
; 			** Rewritten 6/13/86 by MBK **

; 		Entry:
; 			D0 contains a V coordinate of a point of which we want to find the
; 				corresponding line index into lineStart array
; 		Exit:
; 			D0 contains line index(May be negative)
; 			CC's set according to D0 vs teNLines

; ----------------------------------------------------------------------

PtToLine
			MoveM.L		D2/D6-D7/A0,-(SP)

			Sub 		teDestRect+top(A3),D0	; origin to destRect
			Ext.L		D0						; extend to long
			Move.W		teNLines(A3),D7			; save total # of lines
			Beq.S		@4						; if none, quit now

			Move.W		teLineHite(A3),D1		; get default line height

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; if not, do it the old way

			Tst.W		D1						; was line height set?
			Bmi.S		@1						; wasn't set, so use array

@0			DivS		D1,D0					; else divide by line height
			Bra.S		@4						; you're done

@1			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; dereference
			Move.L		lhTab(A0),A0			; max heights per line
			Move.L		(A0),A0					; dereference

			MoveQ		#0,D1					; init line hite accumulator
			Move.W		D7,D2					; get # of lines

@2			Move.W		(A0),D6
			And.W		#$7FFF,D6				; mask out high bit		** <C105/28aug86/MBK> **
			Add.W		D6,D1					; get the height
			AddQ.W		#4,A0
			Cmp.W		D1,D0					; compare to point
			Blt.S		@3						; found it

			SubQ.W		#1,D2					; dec counter
			Bne.S		@2						; more lines to point

@3			Move.W		D7,D0					; total # of lines
			Sub.W		D2,D0					; get line index

@4			Cmp 		D7,D0 					; compare the max # lines

			MoveM.L		(SP)+,D2/D6-D7/A0

			Rts


; ----------------------------------------------------------------------

; 			Invert Hook

; 			This calls the passed hook if there, but otherwise uses _InverRect
; 			Used for carets and selection.  The hook passed must remove the
; 			rect from the stack

; 		Entry:
; 			D0 the hook proc in question
; 			selRect(A3) set up for rectangle in question

; ----------------------------------------------------------------------

InvertHook
; Clear HiliteMode bit to tell QuickDraw to use color highlighting.
; Only do this if a hook is not installed.
			Pea 		teSelRect(A3)			; 	default selection method

;;	If forRAM THEN
	If (Not forROM) THEN						; <19Feb89smb>
			; we have to do this test, so we have to explicitly check D0.L again rather
			; 	than count on the SR flags coming in being right as in the ROM versions
			BTst		#14,ROM85				; on a color system?				<C971/RWW112487>
			Bnz.S		@1						; 									<C971/RWW112487>

			Tst.L		D0						; does a hook exist?
			Bne.S		@2						; yes, go do it
			Lea			HiliteMode,A0			; 									<C971/RWW112487>
			BClr		#7,(A0)					; 									<C971/RWW112487>
			Bra.S		defHilite				; 									<C971/RWW112487>

@1			Tst.L		D0						; does a hook exist?				<C971/RWW112487>
			Beq.S		defHilite				; no								<C971/RWW112487>
@2
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb>
			Bne.S		@0
			Lea			HiliteMode,A0			; new memory location for hiliting
			BClr		#7,(A0)					; tell them we want color hiliting
			Bra.S		defHilite				; do the inversion
@0
	Else
			Beq.S		defHilite				; there, otherwise just invert

	EndIf

			Move.L		D0,A0
			Jmp 		(A0)
defHilite
			_InverRect
			Rts

; Color highlighting is not to be used on the caret, so I created this separate
; procedure just for caret highlighting.

;;	If onNuMac|onMvMac|forRAM THEN					; <C914/29Oct87> rwh
	If hasCQD|(Not forROM) THEN						; <19Feb89smb> 

CaretHook
			Pea 		teSelRect(A3)			; default selection method
			Tst.L		D0						; make absolutely sure!			<S487/RWW050288>
			Beq.S		defHilite				; there, otherwise just invert
			Move.L		D0,A0
			Jmp 		(A0)
	EndIf


; ----------------------------------------------------------------------
; 			Standard Entry for procs, saves registers and pops handle arg into
; 			A4 and dereferences it into A3.  Points A2 to first parameter
; 			AFTER the handle.

StdEntry
			MoveQ		#0,D0					; not a style trap		** <C105/28aug86/MBK **
StdEntry2
			Move.L		(SP)+,A0				; save return address
			Link		A6,#stdLink 			; stack frame
			MoveM.L 	D2-D7/A2-A4,-(SP)
			Move.L		A0,-(SP)				; push return address back on stack

			Tst.W		D0						; is it a style trap?	** <C105/28aug86/MBK **
			Beq.S		@0						; if not, skip this		** <C105/28aug86/MBK **

			Move.W		inHandle(A6),D0			; get the selector		** <C105/28aug86/MBK **
			Lea			AddrTable,A0			; table of addresses	** <C105/28aug86/MBK **
			Add.W		D0,D0					; each entry is 2 bytes	** <C381/5nov86/MBK **
			Move.W		0(A0,D0),D0				; get offset to the trap** <C381/5nov86/MBK **
			Lea			0(A0,D0),A0				; get trap's addr		** <C381/5nov86/MBK **
			Move.L		A0,D3					; save addr in D3		** <C381/5nov86/MBK **

			Move.L		inHandle+2(A6),A4		; get TEHandle			** <C105/28aug86/MBK **
			Bra.S		@1

@0			MoveQ		#0,D3					; use D3 as a flag		** <C105/28aug86/MBK **
			Move.L		inHandle(A6),A4 		; Pop handle into A4

; Modified to use _HGetState ** <C105/5sep86/MBK> **
@1			Move.L		A4,A0					; set up for GetState
			_HGetState							; get handle flags
			Move.B		D0,saveHandle(A6)		; save handle flags

			Pea 		savePort(A6)			; save incoming port
			_GetPort						

			Move.L		A4,A0					; get the TEHandle
			_HLock

			Move.L		(A4),A3 				; Dereference into A3	** <C381/8nov86/MBK **

; Do all safety related entry stuff
			Move.L		teGrafPort(A3),A2		; save "thePort" for below
			Move.L		A2,-(SP)				; set to our port
			_SetPort

; Get clip from this port into rgn defined above
			SubQ		#4,SP					; make room for clip
			_NewRgn
			Move.L		(SP),saveClip(A6)		; save user's clip in frame
			Move.L		(SP),-(SP)				; stay on stack for sectrgn below
			_GetClip						

			Pea 		teViewRect(A3)			; clip to viewRect
			_ClipRect

; First param on stack from above.  Do not pass go. Do not collect $200
			Move.L		clipRgn(A2),-(SP)
			Move.L		(SP),-(SP)				; destination
			_SectRgn

; Set up font, etc.
			Move.L		teGrafPort(A3),A0		; pt to GrafPort

			Tst.W		teSize(A3)				; check style flag
			Bmi.S		DontSet					; don't set style		** MBK 6/20/86 **

			Move.L		teFontStuff(A3),txFont(A0)		; set the font/face
			Move.L		teFontStuff+4(A3),txFont+4(A0)	; set the mode/size

DontSet		Move.W		txFont(A0),saveFont(A6)	; save current font
			Move.W		txFace(A0),saveFace(A6)	; save current face
			Move.W		txSize(A0),saveSize(A6)	; save current size
			Pea			saveColor(A6)			; place to save color	** <C182/60ct86/MBK> **

;;	If forRAM THEN
	If (Not ForROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; color QD around?					<C971/RWW112487>
			Bnz.S		@1						; nope								<C971/RWW112487>
			Move.W		teMode(A3),txMode(A0)	; 									<C971/RWW112487>
			_GetForeColor						; 									<C971/RWW112487>
			Bra.S		@2						; 									<C971/RWW112487>
@1			Bsr			GetForeColor			; 									<C971/RWW112487>
@2
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb> 
			Move.W		teMode(A3),txMode(A0)	; do set the mode		** <C815/13feb87/MBK **
			_GetForeColor						; for Ikki				** <C182/6oct86/MBK> **
	Else
			Bsr			GetForeColor			; for Alladin			** <C182/6oct86/MBK> **
	EndIf

			Move.L		teTextH(A3),A0			; get handle size

			_HGetState							; get the text handle's tag
			Move.B		D0,saveTH(A6)			; and save the flags
			_HLock								; and lock it

			_GetHandleSize						; get its size
			Move		D0,teLength(A3) 		; stuff its length

; Clean up the selection (This must be the last guy because of alternate entry)

CleanUpSel
			Move		teLength(A3),D0 		; get the text length

			Move		teSelEnd(A3),D1 		; make sure selEnd is cool
			Sub 		D0,D1					; selEnd-length
			Bls.S		okSelEnd				; if >0 then bad selend
			Move		D0,teSelEnd(A3) 		; set to length if > length
okSelEnd

			Move		teSelStart(A3),D1		; make sure selStart is cool
			Sub 		teSelEnd(A3),D1 		; selStart-selend
			Bls.S		okSelStart				; if >0 then bad selStart
			Sub 		D1,teSelStart(A3)		; set to selend if > selend
okSelStart
			Bsr			SelSort 				; I wish i could fall into it

			Tst.L		D3						; addr of style trap?	** <C105/28aug86/MBK **
			Beq.S		@2						; if not, skip this		** <C105/28aug86/MBK **

			Move.L		D3,A0					; return it in A0		** <C381/5nov86/MBK **
			Lea			inHandle+6(A6),A2		; pt to next param		** <C105/28aug86/MBK **
			Bra.S		endEntry				; that's it				** <C105/28aug86/MBK **

@2			Lea 		inHandle+4(A6),A2		; Point to next to last param
												; (1st on stack after handle)
endEntry
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TEDispatch (...; hTE: TEHandle; teStyl: INTEGER );

; 			** <C105/28aug86/MBK> **

; 			All style procedure and function traps come here (except
; 			TEStylNew) due to a shortage of traps.

; 			** <C207/13oct86/MBK> **

; 			Added special dispatch to StylTextBox.  Have to special case
; 			it since it doesn't go through StdEntry.

; ----------------------------------------------------------------------
TEDispatch
			MoveQ		#1,D0					; tells stdEntry it's a style trap
			Bsr 		StdEntry2				; get addr of procedure
			Jmp			(A0)					; go and never come back!

; ***************************************************************************
; ** <C971/RWW102387>	So I can find routines more easily...
	If &TYPE('&RWWDebug') <> 'UNDEFINED' Then

	Macro
			FindEntry	&rout
			DC.B		'&SUBSTR(&CONCAT(&rout,'............'),1,12)'
			DC.L		&rout-DispLocTable
	EndM

			Export		DispLocTable
DispLocTable
			FindEntry	vChar2Pixel
			FindEntry	vPixel2Char
			FindEntry	XTrimMeasure
			FindEntry	XFindWord
			FindEntry	XFindLine
			FindEntry	XEOLHook
			FindEntry	XDRAWHook
			FindEntry	iTEStylPaste
			FindEntry	iTESetStyle
			FindEntry	iTEReplaceStyle
			FindEntry	iTEGetStyle
			FindEntry	iGetStylHandle
			FindEntry	iSetStylHandle
			FindEntry	iGetStylScrap
			FindEntry	iTEStylInsert
			FindEntry	iTEGetPoint
			FindEntry	iTEGetHeight
			FindEntry	iSetStylScrap
			FindEntry	iTECustomHook
			FindEntry	iTEContinuousStyle
			FindEntry	iSetStylScrap
			FindEntry	iTENumStyles
			DC.L		-1
	EndIf
; ***************************************************************************


; ----------------------------------------------------------------------

; 			Sorts the selStart and selEnd

; 		Entry:
; 			A3 must contain a dereferenced TE object

; 		Exit:
; 			D0 contains a sorted selStart/End as a long
; 			A2 contains a pointer to teSelStart

; ----------------------------------------------------------------------

SelSort
			Lea 		teSelStart(A3),A2		; Point to selstart
			Move.L		(A2),D0 				; load start and end
			Cmp 		(A2),D0 				; see which is bigger
			Bhs.S		@0
			Swap		D0
			Move.L		D0,(A2) 				; swap and store back
@0			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE TECopy( h: TEHandle );

; 			** Modified 6/20/86 by MBK **

; ----------------------------------------------------------------------
TECopy
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Bsr.S		SelSort 				; D0 contains both (end in low order)
			Sub 		(A2),D0 				; A2 points to selStart(A3)
			Move		D0,teScrpLength 		; scraplength=selEnd-selStart

			Move.L		teTextH(A3),A0			; source = text; already locked
			Move.L		(A0),A0 				; dereference
			MoveQ		#0,D0					; clear whole long
			Move		(A2),D0
			Add.L		D0,A0					; offset to selection(see above)
			Move.L		teScrpHandle,A1 		; destination
			Move		teScrpLength,D0 		; nBytes = scrapLength
			_PtrToXHand

; ** <C207/15oct86/MBK> ** Don't wipe out desk scrap for old TERecs in case applications
; 						use it for Undo

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		goEpilog4				; no style, don't wipe out scrap

; Now copy directly to the desk scrap anyway
			SubQ		#4,SP					; room for result		** MBK 6/20/86 **
			_ZeroScrap							; clear the scrap		** MBK 6/20/86 **
			AddQ.L		#4,SP					; ignore result			** MBK 6/20/86 **

			Bsr.S		SelSort 				; D0 contains both (end in low order)
			Bsr.S		CopyStyle				; copy style info				<C971/RWW102887>NO

			Move.L		teTextH(A3),A0			; text handle			** MBK 6/20/86 **
			Move.L		(A0),A0					; deref					** MBK 6/20/86 **
			MoveQ		#0,D0					; clear long word		** MBK 6/20/86 **
; <16May89smb> Must set up A2 to point to selStart(a3) again, since it may be invalid if the 
; teRecord moved during a MyNewHandle call in CopyGuts.
			Lea 		teSelStart(A3),A2		; <16May89smb> point to selStart
			Move		(A2),D0					; start of selection	** MBK 6/20/86 **
			AddA.W		D0,A0					; offset to selection	** MBK 6/20/86 **
			SubQ		#4,SP					; room for result		** MBK 6/20/86 **
			Move.W		teScrpLength,D0			; length of selection	** MBK 6/20/86 **
			Move.L		D0,-(SP)				; push length			** MBK 6/20/86 **
			Move.L		#'TEXT',-(SP)			; type 'TEXT'			** <C381/5nov86/MBK> **
			Move.L		A0,-(SP)				; ptr to selection		** MBK 6/20/86 **
			_PutScrap							; copy to desk scrap	** MBK 6/20/86 **
			AddQ.L		#4,SP					; ignore result			** MBK 6/20/86 **

goEpilog4
			Bra 		epilog4


; ----------------------------------------------------------------------

; 			PROCEDURE CopyStyle

; 			** Added 5/28/86 by MBK **

; 			CopyStyle saves the styles corresponding to the current text
; 			selection to the desk scrap.

; 	Entry:
; 			A3:			Pointer to TERec
; 			D0:			selStart, selEnd

; ----------------------------------------------------------------------
CopyStyle
			MoveM.L		D0/D2-D5/A2/A5,-(SP)	; save stuff

; get ptr to 1st style and # of styles
			Move.W		D0,D1					; save end
			Swap		D0						; selStart in low word
			Cmp.W		D0,D1					; is it an insertion pt?
			Beq.S		@2						; if so, no style to copy

			Bsr.S		CopyGuts				; do the copy

; Lock my scrap handle 'cause PutScrap might try to move it!
			Move.L		A4,A0					; my scrap handle
			_HLock								; lock it

; copy the styles to the desk scrap now
			SubQ.L		#4,SP					; room for result
			Move.L		D4,-(SP)				; size of scrap
			Move.L		#'styl',-(SP)			; scrap type			** <C381/5nov86/MBK> **
			Move.L		(A4),-(SP)				; scrap ptr
			_PutScrap							; copy to desk scrap
			AddQ.L		#4,SP					; remove result code

; don't need this handle anymore
			Move.L		A4,A0					; scrap handle
			_DisposHandle						; get rid of it

@2			MoveM.L		(SP)+,D0/D2-D5/A2/A5	; save stuff

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE CopyGuts

; 			** Separated out from CopyStyle 1/22/87 by MBK **

; 			CopyGuts is called by CopyStyle and iGetStylScrap to save the
; 			styles corresponding to the current text selection.

; 	Entry:
; 			A3:			Pointer to TERec
; 			D0:			selStart
; 			D1:			selEnd

; ----------------------------------------------------------------------
CopyGuts
			Move.W		D0,D5					; save 1st offset
			Bsr			GetCurStyle				; get style at current selection
			Bsr			GetNumStyles			; find # of styles in selection
			Move.W		D0,D2					; save # of styles

; get a temp handle to store the styles in before copying to desk scrap
			MulU		#scrpRecSize,D0			; * size of a scrap style rec
			AddQ.L		#2,D0					; total scrap size
			Move.L		D0,D4					; preserve scrap size
			Bsr			MyNewHandle				; temp handle for style scrap	** <C381/7nov86/MBK> **
			Move.L		A0,A4					; save scrap handle

			Move.L		(A0),A0					; deref
			Move.W		D2,scrpNStyles(A0)		; store # of styles in scrap
			Lea			scrpStyleTab(A0),A1		; pt to array of styles

; ** <C393/10nov86/MBK> ** style ptr may no longer be valid after memory allocation
			Move.W		D5,D0					; get 1st offset				** <C393/10nov86/MBK> **
			Bsr			GetCurStyle				; get style at current selection** <C393/10nov86/MBK> **
			Move.L		A0,A2					; store ptr to current style	** <C393/10nov86/MBK> **

; loop over styles in the selection, copying to temp location
@0			AddQ.L		#4,A1					; skip 1st entry				** <C207/13oct86/MBK> **
			Move.W		styleIndex(A2),D0		; style index
			Bsr			GetStyle				; get the style ptr
			AddQ.L		#2,A0					; skip 1st entry				** <C207/13oct86/MBK> **
			MoveQ		#stRecSize-2,D0			; size of a style rec-2			** <C381/6nov86/MBK> **
			_BlockMove							; copy style to scrap

			MoveQ		#0,D0					; it's a long word				** <C207/13oct86/MBK> **
			Move.W		startChar(A2),D0		; get start offset of this style
			Sub.W		D5,D0					; offset from start of text scrap
			Bhs.S		@1						; made this unsigned			** <C381/6nov86/MBK> **

			MoveQ		#0,D0

@1			Move.L		D0,-(A1)				; store scrap offset
			Add.L		#scrpRecSize,A1			; next position in style array
			AddQ.L		#stStartSize,A2			; next style
			SubQ		#1,D2					; dec the style counter
			Bne.S		@0						; loop if more styles

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TECut( h: TEHandle );

; ----------------------------------------------------------------------
TECut
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Move.L		A4,-(SP)				; duplicate handle twice
			_TECopy 							; copy it
			Move.L		A4,-(SP)
			_TEDelete							; delete it (A3 no good after)

			Bra			goEpilog4				; see you later					<C971/RWW102887>NO

; ----------------------------------------------------------------------

; 			PROCEDURE TEDelete( h: TEHandle );

; ----------------------------------------------------------------------
TEDelete
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Bsr 		HideCaret

			Bsr.S		DelGuts 				; delete the selection
			Bsr			RecalDraw				; recalibrate line starts

			Bsr 		ShowCaret

			Bsr 		SelView 				; insure selection is visible

			Bra			goEpilog4				; 								<C971/RWW102887>NO

; ----------------------------------------------------------------------

; 			PROCEDURE DelGuts

; 			** Modified 6/18/86 by MBK **

; 		Entry:
; 			A3 contains dereferenced handle

; 		Exit
; 			Selstart and selEnd will be fixed up to point to the old selStart
; 			D7 contains delta amount for delete portion

; ----------------------------------------------------------------------
DelGuts
			Bsr			SelSort 				; sort selection				<C971/RWW102887>NO

			Move		D0,D7					; calc delta amount(selEnd in D0)
			Sub 		(A2),D7 				; ...for ReCalLines (A2 ^selStart)
			Beq.S		outGuts 				; skip if null selection

; ** <C971/RWW102987>	Inserted test to change the way backspacing/deleting works.
; If you backspace to the beginning of a style, that style is saved to the null scrap.
; This allows you to type a selection, backspace over it, and retype without
; TextEdit reverting to the previous style.
			Tst.W		teSize(A3)				; is this a styled record?			<C971/RWW102987>
			Bpl.S		@1						; oops, never mind					<C971/RWW102987>

			MoveM.L		D0/D7/A2,-(SP)			; we need D0 and A2 temporarily		<C971/RWW102987>
			Move.W		teSelStart(A3),D0		; find start of block to be yanked	<C971/RWW102987>
			Bsr			GetCurStyle				; find the associated style run		<C971/RWW102987>
			Move.W		teSelStart(A3),D0		; get start of block again			<C971/RWW102987>
			Cmp.W		startChar(A0),D0		; is it the beginning of a style?	<C971/RWW102987>
			Beq.S		@2						; yes, so continue					<C971/RWW102987>

			Bsr			ClearRsrved				; no null selection!				<C971/RWW102987>
			Bra.S		@3						; 									<C971/RWW102987>

@2			Move.W		styleIndex(A0),D0		; fetch index into style table		<C971/RWW102987>
			Bsr			GetStyle				; find associated style table entry	<C971/RWW102987>
			Move.W		#doAll,-(SP)			; build fake frame for SetRsrved	<C971/RWW102987>
			Pea			stFont(A0)				; point at embedded textstyle		<C971/RWW102987>
			Clr.B		-(SP)					; need another word, can't hurt		<C971/RWW102987>
			Move.L		SP,A2					; point A2 at stacked parameters	<C971/RWW102987>
			Bsr			AltSetRsrved			; set null scrap style				<C971/RWW102987>
			AddQ.W		#8,SP					; fix up stack						<C971/RWW102987>

@3			MoveM.L		(SP)+,D0/D7/A2			; retrieve saved registers			<C971/RWW102987>
@1												; 									<C971/RWW102987>

			Move.W		D0,D1					; selEnd				** MBK 6/18/86 **
			Swap		D0						; selStart				** MBK 6/18/86 **
			Bsr.S		DeleteStyle				; del associated styles			<C971/RWW102887>NO

			Bsr 		MungeSetup				; set up params for delete

			Move		D7,-(SP)				; length for delete
			Clr 		-(SP)					; fake long length
			Clr.L		-(SP)					; fake p2
			Clr.L		-(SP)					; fake l2
			_Munger 							; sloppy munger
			AddQ.L		#4,SP					; pop result

			Move.L		teTextH(A3),A0			; RecalDraw expects text to be locked
			_Hlock								; and relock it

			Sub 		D7,teLength(A3) 		; length:=length -(selEnd-selStart)
			Move		(A2)+,(A2)				; selEnd:=selStart

outGuts
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE DeleteStyle

; 			** Added 6/2/86 by MBK **

; 			DeleteStyle checks to see if the TERec has style (txSize = -1),
; 			And if so deletes the style(s) corresponding to the current text
; 			selection.

; 	Entry:
; 			A3:			Ptr to TERec
; 			D0:			selStart
; 			D1:			selEnd

; ----------------------------------------------------------------------
DeleteStyle
			MoveM.L		D0/D2-D6/A2,-(SP)		; save stuff

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@2						; no style so nothing to delete

			Move.W		D0,D5					; store selStart
			Sub.W		D1,D5					; neg length for delete
			Beq.S		@2						; quit if nothing to delete

			Move.W		D0,D3					; save selStart
			SubQ		#1,D0					; pre-decrement
			Bsr			GetCurStyle				; get style at current selection
			Move.L		A0,A2					; store ptr to current style
			Move.W		D0,D6					; save index
			AddQ		#1,D1					; include following style
			Bsr			GetNumStyles			; find # of styles in selection

			SubQ		#1,D0					; don't delete current style

			Move.W		D0,D2					; # of styles
			Add.W		D6,D0					; add index
			Move.W		D0,D6					; save index
			MoveQ		#0,D4					; clear long word			** <C381/6nov86/MBK> **
			Move.W		D2,D4
			LsL.L		#2,D4					; * stStartSize (4)			** <C381/6nov86/MBK> **
			Add.L		D4,A0					; pt to last style to be deleted

			Tst.W		D2						; see if any styles to delete
			Bne.S		@0						; if nothing to delete
			Bsr			RecalStStarts			; reset following style starts
			Bra.S		@2						; and go

@0			Move.W		D3,startChar(A0)		; selStart is new start of last style
			Bsr			RecalStStarts			; reset following style starts

			Cmp.W		startChar(A2),D3		; special case
			Beq.S		@1

			Add.L		#stStartSize,A2			; point to next style
			SubQ		#stStartSize,D4			; 1 less to delete
			SubQ		#1,D2					; don't delete last style
			Beq.S		@2						; nothing to delete

@1			Move.L		A2,A0					; ptr
			Move.W		D2,D0					; count
			Bsr.S		DecStylCount			; decrement style count			<C971/RWW102887>NO

; Delete the runs corresponding to deleted text
			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; dereference
			MoveQ		#0,D0					; clear long word			** <C381/6nov86/MBK> **
			Move.W		nRuns(A0),D0			; current # of styles
			AddQ		#1,D0					; plus 1
			Sub			D6,D0					; minus index
			LsL.L		#2,D0					; * stStartSize (4)			** <C381/6nov86/MBK> **
			Sub.W		D2,nRuns(A0)			; dec the # of styles

			Move.L		A2,A1					; destination of move
			Move.L		A2,A0
			Add.L		D4,A0					; source of move
			_BlockMove

@2			MoveM.L		(SP)+,D0/D2-D6/A2		; restore stuff

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE DecStylCount

; 			** Added 6/2/86 by MBK **

; 			DecStylCount decrements the style count by one after an instance
; 			of the style has been deleted.

; 	Entry:
; 			D0:			# of styles to check
; 			A0:			Pointer to style from which to start
; 			A3:			Ptr to TERec

; ----------------------------------------------------------------------
DecStylCount
			Move.L		A0,A1					; save ptr to style start
			Move.W		D0,D1					; store # styles to check

; get the styleRec corresponding to the index
@0			Move.W		styleIndex(A1),D0		; get index to style
			Bsr			GetStyle				; get pointer to that style
			Tst.W		stCount(A0)				; is the count already 0?
			Beq.S		@1

			SubQ		#1,stCount(A0)			; if not, decrement the count

; see if there are more styles to delete
@1			Add.L		#stStartSize,A1			; point to next style
			SubQ		#1,D1					; dec the counter
			Bne.S		@0						; more to decrement


			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE RecalDraw

; 			** Modified 6/18/86 by MBK **

; 			Calls ReCalLines to recalibrates the line start array and then draws
; 			the "new" part according to selStart

; 		Entry
; 			A4 points to handle
; 			A3 points to dereferenced TE object
; 			D7 contains delta change = oldLength-newLength

; 			** <C207/16oct86/MBK> ** Added code to reset redraw boundaries if the
; 			line height has changed on any line.

; 			** <C381/8nov86/MBK> ** Moved code to decide where redraw must occur
; 			to the routine SetLineHite.

; ----------------------------------------------------------------------
RecalDraw

			MoveQ		#0,D0					; 1st line				** MBK 6/18/86 **
			Move.W		teNLines(A3),D1			; last line				** MBK 6/18/86 **
			Bsr			GetLineHites			; get total height		** MBK 6/18/86 **
			Move.W		D0,-(SP)				; save it				** MBK 6/18/86 **

			Bsr 		ReCalLines				; D2/D4 returned w/dispStart
			Move		D2,D3					; record dispStart

			MoveQ		#0,D0					; 1st line				** MBK 6/18/86 **
			Move.W		teNLines(A3),D1			; last line				** MBK 6/18/86 **
			Bsr			GetLineHites			; get new height		** MBK 6/18/86 **
			Move.W		(SP)+,D1				; get old height
			Cmp.W		D0,D1					; don't erase if same
			Blo.S		noErase					; 	nothing to erase

			Lea			teSelRect(A3),A0		; pt to selection rect
			Add 		teDestRect+top(A3),D1	; new bottom
			Move.W		D1,bottom(A0)

			Add 		teDestRect+top(A3),D0	; new top
			Move.W		D0,top(A0)

			Move.W		#$8002,left(A0) 		; large negative left
			Move		#$7FF0,right(A0) 		; VERY large right(Erase to end)

			Move.L		A0,-(SP)				; point to rect
			_EraseRect

noErase
			MoveQ		#teDraw,D7				; Redraw changed part
			Bra			DoText					; see you later					<C971/RWW102887>NO


; ----------------------------------------------------------------------

; 			PROCEDURE FindWord

; 			Finds a word @ D0 and returns its start and end+1 index in D0,D1
; 			respectively. Note cannot return selStart itself - must look to left

; 			Entry
; 						A3 - dereferenced handle
; 						D0 - current position (i.e. selStart)
; 						D2 - identifier of routine that called FindWord
; 			Exit
; 						D0 - word start
; 						D1 - word end+1

; ----------------------------------------------------------------------

FindWord
			Move.L		teFindWord,-(SP)		; call the FindWord Routine 		<EHB 01Oct85>
			Rts

XFindWord										; here's our FindWord				<EHB 01Oct85>
			Swap		D2						; get constant into high word		<EHB 01Oct85>
			Move.W		D0,D2					; save position in low word 		<EHB 01Oct85>

			Move.W		D0,D1
			Beq.S		RightScan

			Bsr.S		LeftScan				; do left scan 1st

; Right scan, given a char code in D1, this returns the next word break >= D1

RightScan
			BClr		#17,D2					; clear bit 17 (right)				<EHB 01Oct85>
RS1
			Cmp 		teLength(A3),D1 		; see if @ right edge
			Bhs.S		@0						; assume found if at right edge
			Move		D1,A1					; pass index
			Bsr.S		CallBreak
			Bne.S		@0
			AddQ		#1,D1					; try next char
			Bra.S		RS1 					; 									<EHB 01Oct85>
@0
			Rts

; Given a char location in D0, this routine returns a new word break to left of D0

LeftScan
			BSet		#17,D2					; set bit 1 (left)					<EHB 01Oct85>
LS1
			SubQ		#1,D0					; pre decrement
			Move		D0,A1					; pass index
			Bsr.S		CallBreak				; was it a break?
			Bne.S		@0						; if so, skip town

			Tst 		D0						; are we done?
			Beq.S		@1						; if so, skip town
			Bra.S		LS1 					; keep looking
@0
			AddQ		#1,D0					; try next char
@1
			Rts

CallBreak
			MoveM.L 	D0/A0-A1,-(SP)			; save regs
			Move		A1,D0					; pass index in D0
			Move.L		teTextH(A3),A0			; get handle
			Move.L		(A0),A0
			Move.L		teWordBreak(A3),A1		; get routine
			Jsr 		(A1)					; call routine which sets CC's
			MoveM.L 	(SP)+,D0/A0-A1			; restore regs
			Rts

DefWordBrk
; lo16 is used by TE as a constant for clearing the high word of registers
lo16		Equ 		*+2
			And.L		#$0000FFFF,D0			; longize it
			Cmp.B		#$20,0(A0,D0.L) 		; see if <= $20
			Sls 		D0						; return if word break(SP)
			Tst.B		D0
			Rts

; Measures the trimmed string in [D6..D7)

TrimMeasure
			MoveM.L 	D6-D7,-(SP) 			; save regs
			Bsr 		MeasD6D7
			MoveM.L 	(SP)+,D6-D7 			; restore regs
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE StylMeasure

; 			** Added 6/18/86 by MBK **

; 			Measures the word at offset D6-D7, taking the style into account
; 			If this record has style.

; 		Entry:
; 			D6 		Start of word to be measured
; 			D7		End of word to be measured
; 			A3 		dereferenced handle
; 		Exit:
; 			D0		Width of selection

; ----------------------------------------------------------------------
StylMeasure
			MoveM.L		D2-D3/D5/A2,-(SP)

; does this record have style?
			Tst.W		teSize(A3)				; check style flag
			Bmi.S		@2

; No, just measure the whole thing at once
			Move.W		D7,D0					; end offset
			Move.W		D6,D1					; start offset
			Bsr.S		SetUp					; measure whole word			<C971/RWW102887>NO
			Add.W		D6,D1					; offset at end of word
			Bra.S		@6						; that's it						<C971/RWW102887>NO

; Yes, so measure word 1 style at a time
@2			Move.W		D6,D5					; start offset
			Move.W		D6,D3					; start offset
			Move.W		D3,D0					; start
			Bsr			GetCurStyle				; get current style

			Move.L		A0,A2					; save style start ptr
			Move.W		D7,D1					; end
			Bsr			GetNumStyles			; # of styles in selection
			Move.W		D0,D2					; save it

@3			Move.L		A2,A0					; style ptr
			Bsr			SetStyle				; set the style

			Add.L		#stStartSize,A2			; pt to next style
			Move.L		A2,A0					; style ptr
			Move.W		startChar(A0),D0		; end of style
			Cmp.W		D0,D7					; compare to end of selection
			Bhs.S		@4						; okay if greater

			Move.W		D7,D0					; else set to end of selection

@4			Move.W		D3,D1					; start offset
			Move.W		D0,D3					; next time end becomes start

			Move.L		teStylesH(A3),A0		; get handle to style record
			Move.L		(A0),A0					; deref
			Sub.L		A0,A2					; save as an offset

			Bsr.S		SetUp					; measure it					<C971/RWW102887>NO

			Move.L		teStylesH(A3),A0		; get handle to style record
			Move.L		(A0),A0					; deref
			Add.L		A0,A2					; restore style pointer

			Add.W		D1,D5					; accumulate offset
			Tst.W		D0						; pixel width found?
			Bne.S		@5						; quit if so

			SubQ		#1,D2					; dec the style counter
			Bne.S		@3						; keep looping if more styles	<C971/RWW102887>NO

@5			Move.W		D5,D1					; offset

@6			MoveM.L		(SP)+,D2-D3/D5/A2

			Rts


SetUp
			Move.W		D2,-(SP)				; save style count
			Sub.W		D1,D0					; text length
			Move.L		teTextH(A3),A0			; text handle
			Move.L		(A0),A0					; deref
			AddA.W		D1,A0					; text ptr
			Move.W		D4,D1					; pixel width
			MoveQ		#0,D2					; slop
; 			Bsr			Pixel2Char				; measure it
			Bsr			TEHitTestHook			; measure it					<S487/RWW050288>
			Sub.W		D0,D4					; update width
			Swap		D0						; get flag in low byte
			Move.W		(SP)+,D2				; restore count

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE FindLine
; 			** Modified 6/18/86 by MBK **

; 			Finds a line starting at char location in D6.
; 			This first tries to measure the line in word chunks to save time,
; 			but if that fails it will do it character by character.  IF teCROnly
; 			is set it won't measure anything(Assuming dest rect is huge to right)
; 			And just scans for the CR.

; 		Entry
; 			D6 start of line search assumed to be at 1st word?
; 			A3 - dereferenced handle
; 		Exits
; 			D0 with line end after D6

; ----------------------------------------------------------------------

FindLine	Move.L		teFindLine,-(SP)		; push current FindLine routine 	<EHB 01Oct85>
			Rts 								; and call it						<EHB 01Oct85>

XFindLine										; our default FindLine routine		<EHB 01Oct85>
			MoveM.L 	D1-D7/A1-A2,-(SP)		; protect working registers

; Keep going until line width in D4 is used up

			Move		teDestRect+right(A3),D4	; get right edge
			Sub 		teDestRect+left(A3),D4	; get extent
			SubQ		#1,D4					; reduce for caret indent

			Sub.L		A2,A2					; flag not found
			Move		D6,D7					; use D7 for tail, D6 for head

			MoveQ		#0,D3					; clear accumulator		** MBK 6/17/86 **
			MoveQ		#0,D5					; init D5
wordLoop
			Move		D7,D0					; set up start posn 				<EHB 01Oct85>
			MoveQ		#teFromFind,D2			; say findLine is calling			<EHB 01Oct85>
			Bsr			FindWord				; get word end in D1			<C971/RWW102887>NO
			Move		D1,D7					; save end

			Tst.B		teCROnly(A3)			; see if only scan to CR
			Bne.S		@0						; if so, skip the measure

			Bsr			StylMeasure				; measure with style	** MBK 6/17/86 **
			Tst.W		D0						; end of line reached?
			Bne.S		Spilled

; It has yet to spill off the right, so continue on unless char = CR
@0
			Move		D7,D5					; save lastBlank location
			AddQ		#1,A2					; flag as found

			Cmp 		teLength(A3),D7 		; see if < length for right
			Beq.S		foundLine

			Move.L		teTextH(A3),A0			; see if char was a CR
			Move.L		(A0),A0
			And.L		lo16,D7 				; longize it

; ** <C971/RWW110387>	Added this code to support tabs
; 			Cmp.B		#$0D,0(A0,D7.L) 		; well, is it?

			Move.B		0(A0,D7.L),D0			; THESE FOUR LINES REPLACE PREVIOUS	<C971/RWW110387>
			MoveM.L		D1,-(SP)				; we need D1 intact					<C971/RWW110387>
			Bsr			TEEolHook				; 									<C971/RWW110387>
			MoveM.L		(SP)+,D1				; (MoveM doesn't affect CCR!!)		<C971/RWW110387>

			Bne.S		@1						; keep trying if not		** <C381/30oct86/MBK> **

			AddQ		#1,D5					; point after break char	** <C381/30oct86/MBK> **
			Bra.S		foundLine				; and exit					** <C381/30oct86/MBK> **

@1			Move.W		D7,D6
			AddQ		#1,D7					; start with next word
			Bra.S		wordLoop				; get next one					<C971/RWW102887>NO


; D5 contains the last break location so point to next character since break char
; is included on the line.
; If A2 = 0, then it never found a break char

spilled		Move		A2,D0					; did we find something
			Beq.S		@1

			Move.L		teTextH(A3),A0			; get text handle				** <C381/30oct86/MBK> **
			Move.L		(A0),A0 				; dereference					** <C381/30oct86/MBK> **

@0			AddQ		#1,D5					; use next char					** <C381/30oct86/MBK> **
			Cmp.W		teLength(A3),D5			; check text length				** <C381/8nov86/MBK>	**
			Bhs.S		foundLine				; exit if end of text			** <C381/8nov86/MBK>	**

; A CR following non-wrapped blanks should be considered the line break.
; If not, the CR will go on the next line, and we'll get an empty line
; in-between.  This fixes bug LM-RM-98.
; ** <C971/RWW110387>	Added this code to support tabs
; 			Cmp.B		#$0D,0(A0,D5) 			; if last char = CR then...

			Move.B		0(A0,D5),D0				; THESE FOUR LINES REPLACE PREVIOUS	<C971/RWW110387>
			MoveM.L		D1/A0,-(SP)				; (we need D1 AND A0)				<C971/RWW110387>
			Bsr			TEEolHook				; 									<C971/RWW110387>
			MoveM.L		(SP)+,D1/A0				; (MoveM doesn't affect CCR!!)		<C971/RWW110387>

			Bne.S		@2						; if CR, we actually want next char

			AddQ		#1,D5					; use next char
			Bra.S		foundLine
@2
			Cmp.B		#$20,0(A0,D5) 			; if last char = space then...	** <C381/30oct86/MBK> **
			Beq.S		@0						; it's a break					** <C381/30oct86/MBK> **
			Bra.S		foundLine

@1			SubQ		#1,D1					; end of rect intersects this char
			Move.W		D1,D5

foundLine	Move		D5,D0					; return in D0
			MoveM.L 	(SP)+,D1-D7/A1-A2		; restore working registers
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE ReCalLines

; 			** Modified 6/18/86 by MBK **

; 			Recalibrates the line start array and sets dispStart/dispEnd to
; 			correct redraw spot.  Starting with the selection, it figures out
; 			which line the selection is on.  Then it recalibrates the line starts
; 			from there until the delta in D7 is consumed (the word wrap has
; 			petered out).  It returns D2 and D4 to the redraw start and end.
; 			(It should return D3 instead of D2, but for compatibility it uses
; 			D2).

; 		Entry
; 			A4 points to handle
; 			A3 points to dereferenced TE object
; 			D7 contains delta in change = oldLength-newLength
; 		Exit
; 			dispStart(D2) now set to redraw start
; 			dispEnd(D4) set to redraw end
; 		Uses
; 			D5 for handle size (changed by setlinearray)

; ----------------------------------------------------------------------

; ** <C105/3Sep86/MBK> ** Stages 2 and 3 of Recal were totally rewritten for
; 							speed.  I decided the insert and delete cases were
; 							different enough to justify handling them separately.

ReCalLines
			Move.L		teRecal,-(SP)
			Rts
XReCalLines
			Link		A6,#RecalLink
			MoveM.L 	D3/D5-D6/A2,-(SP)		; save regs (SEE .EQU ABOVE)

			Move.W		teNLines(A3),oldNLines(A6)	; save old # of lines		** <C229/28oct86/MBK> **
			Clr.W 		teNLines(A3)	 		; prime nLines:=0

			Clr.W		savedD2(A6)				; default redraw beginning
			Move		teLength(A3),savedD4(A6)	; default redraw end
			Tst.W		teLength(A3)			; any text?
			Beq.S		RecalDone				; if not, nothing to recal		<C971/RWW102887>NO

; D3 contains the start point to recal from, so find the line containing D3
			Lea			teLines(A3),A2			; point to line starts
			MoveQ		#teFromRecal,D2 		; say ReCalLines is calling 		<EHB 01Oct85>
			Move		teSelStart(A3),D0		; put start position in D0			<EHB 01Oct85>
			Bsr			FindWord				; get word around selstart for...<C971/RWW102887>NO
			Move		D0,D3					; comparison

stage1
			Move		(A2)+,D6				; i(start):=lineStarts[line]
			Move		D6,savedD2(A6)			; save away as default redraw start

			Cmp 		(A2),D3 				; while selWord<lineStarts[line+1]
			Blo.S		stage2x 				; if inclusive
			Beq.S		stage2y 				; if at next line start

			AddQ		#1,teNLines(A3) 		; one more line, keep looking for
			Bra.S		stage1					; line containing selStart(D3)

; Return the refresh start in savedD2

stage2x
			Bsr			FindLine				; get line after D6				<C971/RWW102887>NO
			Cmp 		D0,D3					; did the line break change?
			Bhs.S		stageBad				; if so, must redraw whole thing
stageGood										; 									<EHB 05-Nov-85>
			Tst.B		WordRedraw				; should we redraw the whole word?	<EHB 31-Oct-85>
			Bgt.S		stageBad				; => yes, app wants whole word		<EHB 31-Oct-85>
			Blt.S		stage2A 				; => app wants whole line			<EHB 01-Nov-85>

			Move		teSelStart(A3),D3		; return selStart
stageBad
			Tst.W		teJust(A3)				; see what format, for right or
			Bne.S		stage2A 				; centered, must use linestart

			Tst.W		teSysJust				; check text direction	** <C105/14aug86/MBK> **
			Bne.S		stage2A					; not left				** <C105/14aug86/MBK> **

; Special case: redraw line didn't work because stage2x jumped here w/o checking the redraw flag.
			Tst.B		WordRedraw				; should we redraw the whole word?	** <C454/21nov86/MBK> **
			Blt.S		stage2A 				; => app wants whole line			** <C454/21nov86/MBK> **

			Move		D3,savedD2(A6)			; return word start-1
			Beq.S		stage2A
			SubQ		#1,savedD2(A6)
			Bra.S		stage2A

stage2y
			Bsr			FindLine				; get line after D6				<C971/RWW102887>NO
			Cmp 		D0,D3					; did the line break change?
			Bne.S		stageBad				; if so, must redraw whole thing<C971/RWW102887>NO
			Move		D3,savedD2(A6)			; "next" line OK if at beginning
			Bra.S		stageGood				; 								<C971/RWW102887>NO

; 2 new routines for handling stages 2 and 3 of Recal
stage2A		Move.W		D0,D3					; save line start in D3

	If &TYPE('&RWWDebug') <> 'UNDEFINED' Then
			Tst.W		D7						; insertion or deletion?
			Ble.S		@0

; If some characters on a line are replaced by (a fewer number of) CRs
; the deletion algorithm does not work correctly because it is not
; prepared to add new lines.  So now I just call the insertion algorithm
; except for this special case, when character(s) at the beginning of
; the line are being deleted (the insertion algoritm doesn't work
; in this case).  Maybe someday this whole recalibration thing will
; get rewritten!
; Changed this once again. Selstart will equal selEnd whenever TEDelete was called.
; Only call InsertRecal if this was an insertion that was shorter than the selection.

			Move.W		teSelStart(A3),D0
			Cmp.W		teSelEnd(A3),D0
			Bne.S		@0

			Bsr.S		DeleteRecal				; recal for deletions
			Bra.S		reCalDone

	EndIf		; <PMAB381/RWW020488>

@0			Bsr			InsertRecal				; recal for insertions

reCalDone	Bsr			SetLineHite				; reset line heights	** <C229/28oct86/MBK> **
			Move.W		savedD4(A6),D4			; return start and end	** MBK 6/18/86 **
			Move.W		savedD2(A6),D2			; 						** MBK 6/18/86 **

; ** <C971/RWW102287>	Rudy D. memorial lineStarts hack.
; 					Force TERecord to be proper length.
cutBackSlop	Equ			8

			Move.L		A4,A0					; How fat is TERecord now?			<C971/RWW102987>
			_GetHandleSize						; 									<C971/RWW102987>
			Tst.L		D0						; check for error					<C971/RWW102987>
			Bpl.S		@2
			_SysError							; fly away if system error			<C971/RWW102987>

@2			Sub.L		#teRecSize,D0			; lose header						<C971/RWW102987>
			LsR.L		#1,D0					; account for word sized table		<C971/RWW102987>
			And.L		#$7FFF,D0				; gotta be fewer than 32K lines		<C971/RWW102987>
			Sub.W		teNLines(A3),D0			; blow off cutback					<C971/RWW102987>
			Bz.S		@1						; didn't change at all				<C971/RWW102987>
			Bmi.S		@1						; got larger.  Munger handled it	<C971/RWW102987>
			Cmp.W		#cutBackSlop,D0			; is difference less than slop		<C971/RWW102987>
			Blo.S		@1						; Yes, so don't bother memory mgr	<C971/RWW102987>

			MoveQ		#0,D0					; Gotta talk longs, here			<PMAB345/C990/RWW121687>
			Move.W		teNLines(A3),D0			; Fetch number of lines				<PMAB345/C990/RWW121687>

			LsL.L		#1,D0					; account for word offset			<C971/RWW102287>
			Add.L		#teRecSize,D0			; Add in rest of record				<C971/RWW102287>
			Move.L		A4,A0					; TEHandle is what we're resizing	<C971/RWW102287>
			Bsr			MySetHandleSize			; Go do it							<C971/RWW102287>
@1												; 									<C971/RWW102287>

			MoveM.L 	(SP)+,D3/D5-D6/A2		; restore regs
			Unlk		A6

			Rts 								; see you later

	If &TYPE('&RWWDebug') <> 'UNDEFINED' Then
; ** <C105/3Sep86/MBK> ** Stages 2 and 3 for deletion only

DeleteRecal
			Move.L		teTextH(A3),A0			; text handle
			Move.L		(A0),A1					; deref into A1

dStage2
; If the width of a single character > the width of the window, Recal keeps
; finding the same line (line 1) forever.  If this happens, don't keep trying
; to wrap, just advance to the next character.

			Cmp.W		D6,D3					; same as old value?		** <C440/18nov86/MBK> **
			Bne.S		@0						; ok if not					** <C440/18nov86/MBK> **
			AddQ		#1,D3					; else advance to next char	** <C440/18nov86/MBK> **
@0
			Cmp 		teSelEnd(A3),D3 		; not ready for stage 3 if not yet
			Bls.S		dSkip3					; past selEnd

			Move.L		A2,savePtr(A6)			; save ptr for move up

			Move.W		(A2),D0					; old line start
			Sub 		D3,D0	 				; oldStart - newStart
			Cmp 		D0,D7 					; compare to delta
			Beq.S		dStage3

; ** <C971/RWW110387>	Added this code to support tabs
; 			Cmp.B		#$0D,-1(A1,D3)			; get the last char

			Move.B		-1(A1,D3),D0			; THESE TWO LINES REPLACE PREVIOUS	<C971/RWW110387>
			Bsr			TEEolHook				; 									<C971/RWW110387>

			Bne.S		dSkip3					; if CR stage 2 is over

; look for the old value of this line
			Move.L		A2,A0
			Move.W		D3,D0					; line start + delta
			Add.W		D7,D0

@1			Cmp.W		(A0)+,D0				; must be a match
			Bhi.S		@1						; made this unsigned	** <C381/6nov86/MBK> **

			SubQ		#2,A0					; got over-incremented
			Move.L		A0,savePtr(A6)			; save ptr for move up
			Bra.S		dStage3
dSkip3
; update the table with new start
			AddQ		#1,teNLines(A3)			; inc # of lines
			Move		D3,(A2)+				; lines[nLines]:=i
			Move		D3,D6					; now start with the next line

			Cmp 		teLength(A3),D6 		; while i < length do
			Bhs.S		endDRecal			

			Bsr			FindLine				; get line after D6				<C971/RWW102887>NO
			Move		D0,D3					; findline returns in D0
			Bra.S		dStage2					; if so, never do background

; Fill out following line offsets with delta and return in D4 the redraw end
dStage3
			Move.L		A2,A0

			Move.L		savePtr(A6),A0			; source ptr
			Cmp.L		A2,A0					; same as dest ptr?
			Beq.S		@3						; if so, no lines deleted

			Move.W		teLength(A3),D3			; else, redraw everything

@3			Move		D3,savedD4(A6)			; found it, record in dispEnd

dStage3A
; update the table with new start
			AddQ		#1,teNLines(A3) 		; increment # lines
			Move.W		(A0)+,D0
			Sub 		D7,D0	 				; lines[nLines]:=lines[nLines]-delta

			Move.W		D0,(A2)
			Move		(A2)+,D6				; see if done
			Cmp 		teLength(A3),D6 		; while i < length do
			Blo.S		dStage3A

endDRecal	Rts

	EndIf		; <PMAB381/RWW020488>


; ** <C105/3Sep86/MBK> ** Stages 2 and 3 for insertion only
defBufSize	Equ			256						; initial size of temp line start buffer

InsertRecal
			MoveM.L		D2/D4,-(SP)				; save stuff

			MoveQ		#0,D5					; line start counter
			Move.W		teSelEnd(A3),D4

	If &TYPE('&RWWDebug') = 'UNDEFINED' Then
			Tst.W		D7						; Only do "subtraction" if negative		<PMAB381/RWW020488>
			Bpl.S		@05						; 										<PMAB381/RWW020488>
	EndIf

			Sub.W		D7,D4					; selEnd + delta
@05

; ** <C393/10nov86/MBK> ** MyNewHandle unlocks the TEHandle for memory allocation and resets
; 							the A3 ptr, so the A2 ptr must also be reset
			Sub.L		A3,A2					; save A2 as an offset			** <C393/10nov86/MBK> **

			Move.L		#defBufSize,D0			; don't want to reset too often	** <C381/6nov86/MBK> **
			Move.L		D0,D2					; save initial handle size
			Bsr			MyNewHandle				; temp handle for line starts	** <C381/7nov86/MBK> **
			_HLock								; play it safe
			Move.L		(A0),A1					; save ptr
			Move.L		A0,startHndl(A6)		; save handle

			Add.L		A3,A2					; restore A2 as a ptr			** <C393/10nov86/MBK> **
			Move.L		A2,savePtr(A6)			; current line start ptr

iStage2
; If the width of a single character > the width of the window, Recal keeps
; finding the same line (line 1) forever.  If this happens, don't keep trying
; to wrap, just advance to the next character.
			Cmp.W		D6,D3					; same as old value?		** <C440/18nov86/MBK> **
			Bne.S		@0						; ok if not					** <C440/18nov86/MBK> **
			AddQ		#1,D3					; else advance to next char	** <C440/18nov86/MBK> **
@0
			Cmp 		D4,D3 					; not ready for stage 3 if not yet
			Bls.S		iSkip3					; past selEnd

			Move.L		teTextH(A3),A0			; get text handle
			Move.L		(A0),A0					; deref

; ** <C971/RWW110387>	Added code to support tabs
; 			Cmp.B		#$0D,-1(A0,D3)			; get the last char

			Move.B		-1(A0,D3),D0			; THESE TWO LINES REPLACE PREVIOUS	<C971/RWW110387>
			Bsr			TEEolHook				; 									<C971/RWW110387>

			Bne.S		@3						; keep going if not CR

			Move.L		A2,A0					; set current ptr
			Move.W		D3,D0					; get line start
			Add.W		D7,D0					; minus delta (D7 is neg)

; find the old value of this line start for moving down remaining line starts
@1			Cmp.W		(A0)+,D0
			Bhi.S		@1						; made this unsigned	** <C381/6nov86/MBK> **

			SubQ		#2,A0					; got over-incremented
			Move.L		A0,savePtr(A6)			; save it
			Bra.S		iStage3					; on to stage 3

@3
; D5 may be greater than the old number of lines, so skip the
; delta check if so.  This was a really obscure bug which only
; hurt us when D0 happened to be equal to D7.
			MoveQ		#0,D0					; clear entire register
			Move.W		oldNLines(A6),D0		; get old # of lines
			Add.W		D0,D0					; double for word entries
			Cmp.L		D0,D5					; have we exceeded the length of the array?
			Bhs.S		iSkip3					; skip delta check if so

			Move.W		0(A2,D5.L),D0			; get old start
			Sub 		D3,D0	 				; oldStart - newStart

			Cmp 		D0,D7 					; compare to delta
			Bne.S		iSkip3					; keep trying if not same

			Add.L		D5,savePtr(A6)			; set old start for move down
			Bra.S		iStage3
iSkip3
; increase sizes of temporary arrays if needed
			Cmp.L		D5,D2					; time to increase sizes?
			Bgt.S		@0

			Move.L		startHndl(A6),A0		; temp line starts handle
			_HUnlock
			Add.L		#defBufSize,D2			; inc size for line starts	** <C381/6nov86/MBK> **
			Move.L		D2,D0
			Sub.L		(A0),A1					; make ptr an offset
			Bsr			MySetHandleSize			; reset handle size			** <C381/7nov86/MBK> **
			_HLock
			Add.L		(A0),A1					; make the offset a ptr again

@0			Move		D3,(A1)+				; lines[nLines]:=i
			Move		D3,D6					; now start with the next line
			AddQ		#1,teNLines(A3) 		; increment # lines
			AddQ.L		#2,D5

			Cmp 		teLength(A3),D6 		; while i < length do
			Blo.S		@1						; keep finding lines		** <C229/28oct86/MBK> **

			Move.W		oldNLines(A6),D0		; get old # of lines		** <C229/28oct86/MBK> **
			AddQ.W		#1,D0					; plus 1 to pt to end		** <C229/28oct86/MBK> **
			Add.W		D0,D0					; double for word entries	** <C229/28oct86/MBK> **
			Lea			teLines(A3,D0),A0		; plus base address			** <C229/28oct86/MBK> **
			Move.L		A0,savePtr(A6)			; save it for replace		** <C229/28oct86/MBK> **
			Bra.S		iStage3A				; go munge					** <C229/28oct86/MBK> **

@1			Bsr			FindLine				; get line after D6				<C971/RWW102887>NO
			Move		D0,D3					; findline returns in D0
			Bra			iStage2					; if so, never do background	<C971/RWW102887>NO

; Fill out following line offsets with delta and return in D4 the redraw end
iStage3
			Move		D3,savedD4(A6)			; found it, record in dispEnd

; Still need to munge if D5 is 0, in case something was inserted over a CR.
; Line which skipped munging if D5 = 0 was deleted.
			Move.L		savePtr(A6),D0
			Sub.L		A2,D0					; change in # of lines?
			Sub.L		D5,D0
			Beq.S		iStage3A

			Move.W		teLength(A3),D3			; if so, must display all

iStage3A	Move		D3,savedD4(A6)			; found it, record in dispEnd

			Move.L		A4,A0
			_HUnLock							; unlock TEHandle
			SubQ.L		#4,SP					; room for ret value
			Move.L		A4,-(SP)				; TEHandle
			Move.L		A2,D0
			Sub.L		A3,D0					; offset to line preceding insert
			Move.L		D0,-(SP)
			Move.L		#0,-(SP)				; Nil ptr

			Move.L		savePtr(A6),D0			; end of insertion
			Sub.L		A2,D0					; - beg of insertion
			Move.L		D0,-(SP)
			Move.L		startHndl(A6),A0
			Move.L		(A0),-(SP)				; ptr to new line starts
			Move.L		D5,-(SP)				; length of insertion
			Sub.L		A3,A2					; save as offset
			_Munger	; (TEHandle, preInsertPoint, NIL, selectionLen, newLineStarts, insertLen);
			AddQ.L		#4,SP					; don't care
			Move.L		A4,A0
			_HLock								; relock TEHandle
			Move.L		(A4),A3					; deref
			Add.L		A3,A2					; restore as ptr

			Add.L		D5,A2					; adjust ptr for move down

sameLine	Move.L		startHndl(A6),A0		; get rid of line starts handle
			_DisposHandle

			Cmp 		teLength(A3),D6 		; if i >= length quit
			Bhs.S		endIRecal			
iStage3B
; update the table with new start
			AddQ		#1,teNLines(A3) 		; increment # lines
			Sub 		D7,(A2)	 				; lines[nLines]:=lines[nLines]-delta

			Move		(A2)+,D6				; see if done
			Cmp 		teLength(A3),D6 		; while i < length do
			Blo.S		iStage3B

endIRecal	MoveM.L		(SP)+,D2/D4				; other stuff
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE SetLineHite

; 			** Added 6/18/86 by MBK **

; 			SetLineHite takes the maximum height for the current line
; 			(which was determined in FindLine) and stores it in the
; 			array of maximum line heights.

; 			** <C229/28oct86/MBK> ** Changed to reset all heights at end of recal

; 		Entry:
; 			A4 is pointing into array in which to insert line heights and
; 				ascents

; ----------------------------------------------------------------------
SetLineHite
			MoveM.L		D2-D5/A2/A4,-(SP)		; save registers

			Tst.W		teSize(A3)				; record with style?
			Bpl			endSetLH				; quit if not

			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; deref
			Move.L		lhTab(A0),A0			; line heights array
			_GetHandleSize						; get current size
			Move.W		D0,D3					; save size in D3
			AsR.W		#2,D3					; get # of lines

			MoveQ		#0,D0					; clear whole reg
			Move.W		teNLines(A3),D0			; get # of lines
			AddQ.L		#1,D0					; + 1 for last entry
			LsL.L		#2,D0					; for 2 integers
			Bsr			MySetHandleSize			; reset handle size				** <C381/7nov86/MBK> **

			Move.L		teStylesH(A3),A1		; handle to style info			** <C381/6nov86/MBK> **
			Move.L		(A1),A1					; deref							** <C381/6nov86/MBK> **
			Move.L		lhTab(A1),A4			; line heights array
			Move.L		(A4),A4					; deref

			Tst.W		teLength(A3)			; any text?
			Bne.S		@0						; no default needed if so		** <C381/6nov86/MBK> **

; If all text was deleted, set line height according to only remaining style.
			Move.W		runs+2(A1),D0			; index to 1st style			** <C440/19nov86/MBK> **
			Bsr			GetStyle				; get ptr to 1st style			** <C440/19nov86/MBK> **
			Move.W		stHeight(A0),(A4)+		; store line height				** <C440/19nov86/MBK> **
			Move.W		stAscent(A0),(A4)		; store the ascent				** <C440/19nov86/MBK> **
			Bra			endSetLH				; and quit						** <C440/19nov86/MBK> **

@0			Move.L		styleTab(A1),A0			; styles array
			Move.L		(A0),A0					; deref
			Lea			runs(A1),A1				; pt to style runs
			Lea			teLines(A3),A2			; pt to line starts
			MoveQ		#0,D1					; set max
			MoveQ		#0,D2					; set starting line #
			Move.L		#-1,D4					; starting redraw line			** <C381/8nov86/MBK> **
			Move.W		(A4),D5					; save old value				** <C381/8nov86/MBK> **

setLoop		Move.W		styleIndex(A1),D0		; index to current style
			MulU		#stRecSize,D0			; multiply index by size of record
			Cmp.W		stHeight(A0,D0.L),D1	; compare to current max		** <C381/6nov86/MBK> ** made D0 long
			Bge.S		@1						; already have max

			Move.W		stHeight(A0,D0.L),D1	; else save as new max			** <C381/6nov86/MBK> ** made D0 long
			Cmp.W		D2,D3					; is this a new entry?
			Ble.S		@0						; just set it if so

			Tst.W		(A4)					; else, see if it should be set
			Bmi.S		@1						; if neg don't reset

@0			Move.W		D1,(A4)					; else set height
			Move.W		stAscent(A0,D0.L),2(A4)	; set ascent					** <C381/6nov86/MBK> ** made D0 long

@1			Move.W		2(A2),D0				; get next line start
			Cmp.W		stStartSize(A1),D0		; cmp to style start
			Blo.S		@3						; made this unsigned			** <C381/6nov86/MBK> **
			Beq.S		@2						; next style

			AddQ.L		#stStartSize,A1			; pt to next style
			Bra.S		setLoop					; keep checking this line

@2			AddQ.L		#stStartSize,A1			; pt to next style
@3			AddQ.L		#2,A2					; pt to next line
			Tst.L		D4						; line to start redraw from		** <C381/8nov86/MBK> **
			Bpl.S		@4						; don't reset it				** <C381/8nov86/MBK> **

			Cmp.W		(A4),D5					; compare to old max			** <C381/8nov86/MBK> **
			Beq.S		@4						; ok if same					** <C381/8nov86/MBK> **

			MoveQ		#0,D4					; clear neg value in hi word	** <C381/8nov86/MBK> **
			Move.W		D2,D4					; store line # for redraw		** <C381/8nov86/MBK> **

@4			AddQ.L		#4,A4					; next line height entry
			Move.W		(A4),D5					; save old value				** <C381/8nov86/MBK> **
			MoveQ		#0,D1					; reset max
			AddQ		#1,D2					; inc counter
			Cmp.W		teNLines(A3),D2			; check counter
			Blo.S		setLoop					; loop if more lines			** <C381/6nov86/MBK> ** changed BNE to BCS

			Move.L		-4(A4),(A4)				; last dummy entry

			Tst.L		D4						; change in heights?			** <C381/8nov86/MBK> **
			Bmi.S		endSetLH				; quit if not					** <C381/8nov86/MBK> **

			Move.W		teLength(A3),savedD4(A6)	; must redraw to bottom		** <C381/8nov86/MBK> **
			Add.W		D4,D4					; double the line #				** <C381/8nov86/MBK> **
			Move.W		teLines(A3,D4),D0		; get start of line				** <C381/8nov86/MBK> **
			Cmp.W		savedD2(A6),D0			; don't reset if new start 		** <C381/8nov86/MBK> **
			Bhs.S		endSetLH				; 	is greater than old start	** <C381/8nov86/MBK> **

			Move.W		D0,savedD2(A6) 			; store as new display start 	** <C381/8nov86/MBK> **

endSetLH	MoveM.L		(SP)+,D2-D5/A2/A4		; restore registers

			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE ShowCaret
; 			PROCEDURE HideCaret
; 			PROCEDURE DrawCaret
; 			PROCEDURE EraseCaret

; 		Entry:
; 			A3 contains dereferenced handle

; ----------------------------------------------------------------------
ShowCaret
			Tst.B		teActive(A3)			; do nothing if not active
			Beq.S		noDrawIt				; 								<C971/RWW102887>NO

			Move		teSelStart(A3),D0		; see if should be turned on
			Cmp 		teSelEnd(A3),D0
			Bne.S		noDrawIt				; if selection <> 0 then escape
			ST			teCarAct(A3)			; activate caret

DrawCaret
			Tst.B		teCarOn(A3) 			; see if caret is on
			Bne.S		noDrawIt				; don't draw it if so
			ST			teCarOn(A3) 			; caret marked on
ForceCaret
			Bra.S		DrawIt					; force a redraw

HideCaret
			Tst.B		teActive(A3)			; do nothing if not active
			Beq.S		noDrawIt				; 								<C971/RWW102887>NO

			SF			teCarAct(A3)			; deactivate caret

EraseCaret
			Tst.B		teCarOn(A3) 			; see if caret is on
			Beq.S		noDrawIt				; don't draw it if so
			SF			teCarOn(A3) 			; caret marked on

; Must be called with sorted selStart and selEnd
DrawIt
			MoveM.L 	D0-D7,-(SP)

			Move		teSelStart(A3),D3		; dispStart:=selStart
			Move		D3,D4					; dispEnd:=same

			MoveQ		#teLoc,D7				; does nothing except moves pen
			Bsr 		DoText					; draw the caret

			Move.L		teCarHook(A3),D0		; do the inversion via hook if there

; Call new procedure for caret highlighting, so that color highlighting
; won't be used.

;;	If forRAM THEN
	If (NOT ForROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; color QD around?					<C971/RWW112487>
			Bnz.S		@1						; nope								<C971/RWW112487>
			Bsr			CaretHook				; 									<C971/RWW112487>
			Bra.S		@2						; 									<C971/RWW112487>
@1			Bsr			InvertHook				; 									<C971/RWW112487>
@2
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb>
			Bsr			CaretHook				; 								<C971/RWW102887>NO
	Else
			Bsr			InvertHook				; 								<C971/RWW102887>NO
	EndIf

			MoveM.L 	(SP)+,D0-D7
noDrawIt
			Rts
; ----------------------------------------------------------------------

; 			PROCEDURE TEActivate( h: TEHandle )
; 			PROCEDURE TEDeActivate( h: TEHandle )

; ----------------------------------------------------------------------
TEActivate
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Tst.B		teActive(A3)			; see if already active
			Bne.S		goGoHome

			Move		teSelStart(A3),D0		; Only enable the caret
			Cmp 		teSelEnd(A3),D0
			Bne.S		@1
			ST			teCarAct(A3)			; activate caret/don't show yet
@1
			ST			teActive(A3)			; flag as active

			Bsr 		Hilite

goGoHome
			Bra.S		goHome

TEDeactivate
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Tst.B		teActive(A3)			; see if already inactive
			Beq.S		goHome

			Bsr.S		HideCaret				; hide the caret
			Bsr 		HiLite					; Remove old selection
			SF			teActive(A3)			; flag as inactive

			Bra.S		goHome

; ----------------------------------------------------------------------

; 			PROCEDURE TEIdle( h: TEHandle )

; ----------------------------------------------------------------------
TEIdle
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			Tst.B		teCarAct(A3)			; see if active
			Beq.S		goHome

			SubQ		#4,SP					; make room for result
			_TickCount							; Get current time
			Move.L		(SP)+,A0				; use A0 for auto extend

			Cmp.L		teCarTime(A3),A0		; see if done
			Blo.S		goHome

			Add.L		caretTime,A0			; next time
			Move.L		A0,teCarTime(A3)

	If &TYPE('&RWWDebug') <> 'UNDEFINED' Then
			Bsr			DrawIt					; flip the caret
	Else
			Bsr.S		DrawIt					; flip the caret
	EndIf
			Not.B		teCarOn(A3) 			; flip the flag

goHome
			Bra 		epilog4

; ----------------------------------------------------------------------

; 			PROCEDURE TEPaste( h: TEHandle );

; ----------------------------------------------------------------------
TEPaste
			Bsr 		StdEntry

			MoveQ		#0,D7					; flag says normal paste
			Bsr.S		DoPaste					; 								<C971/RWW102887>NO

			Bra.S		goHome					; {epilog4}						<C971/RWW102887>NO


DoPaste

; ** <C207/15oct86/MBK> ** Don't wipe out desk scrap for old TERecs in case applications
; 						use it for Undo
			Tst.W		teSize(A3)				; record with style?
			Bpl.S		@2						; paste from TEscrap if not

; allocate a new handle for the text scrap contents
			MoveQ		#0,D0					; min size 				** MBK 6/20/86 **
			Bsr			MyNewHandle				; get a temp handle		** <C381/7nov86/MBK> **
			Move.L		A0,D6					; save the handle		** MBK 6/20/86 **
			Move.L		A0,-(SP)				; push it				** MBK 6/20/86 **

; copy desk scrap to my temp scrap
			SubQ.L		#4,SP					; room for VAR			** MBK 6/20/86 **
			Move.L		SP,A1					; save this address		** MBK 6/20/86 **
			SubQ.L		#4,SP					; make room for result	** MBK 6/20/86 **
			Move.L		A0,-(SP)				; push new handle		** MBK 6/20/86 **
			Move.L		#'TEXT',-(SP)			; scrap type			** <C381/5nov86/MBK> **
			Move.L		A1,-(SP)				; push address			** MBK 6/20/86 **
			_GetScrap							; get desk scrap		** MBK 6/20/86 **
			Move.L		(SP)+,D0				; error code			** MBK 6/20/86 **
			AddQ.L		#4,SP					; don't care 			** MBK 6/20/86 **
			Tst.L		D0						; error?				** MBK 6/20/86 **
			Ble.S		@1						; no text scrap			** MBK 6/20/86 **

			Move.L		D0,D5					; length of scrap		** MBK 6/20/86 **
			Move.L		D6,A0					; 						** MBK 6/20/86 **

			_HLock								; lock text scrap		** MBK 6/20/86 **
			Move.L		(A0),D6					; ptr to scrap			** MBK 6/20/86 **

			Bsr.S		PasteGuts				; go paste the scrap			<C971/RWW102887>NO

@1			Move.L		(SP)+,A0				; temp scrap handle		** MBK 6/20/86 **
			_DisposHandle						; get rid of it			** MBK 6/20/86 **
			Bra.S		@3

; ** <C207/15oct86/MBK> ** paste from old TEScrp, for old TERecs only
@2			Move.L		teScrpHandle,A0 		; insertion = scrap
			_HLock								; lock it
			Move.L		(A0),D6 				; now dereference
			MoveQ		#0,D5					; clear whole reg
			Move		teScrpLength,D5 		; insertion length

			Bsr.S		PasteGuts				; go paste the scrap

			Move.L		teScrpHandle,A0 		; insertion = scrap
			_HUnLock							; unlock it

@3			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE iTEStylPaste( h: TEHandle );

; 			** Added 6/20/86 by MBK **

; 			TEStylePaste pastes the 'styl' scrap as well as the 'TEXT'
; 			scrap.  TEPaste, on the other hand, simply extends the current
; 			style in the text to include the pasted text.  Both work
; 			the old way for records without style.

; ----------------------------------------------------------------------
iTEStylPaste
			MoveQ		#1,D7					; flag says normal paste
			Bsr.S		DoPaste					; 								<C971/RWW102887>NO

			MoveQ		#6,D0
			Bra			StdExit2

; ----------------------------------------------------------------------

; 			PROCEDURE PstRsrved;
; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 			selection is NIL in iTESetStyle.  I store it in the scrap
; 			format so that it can easily be inserted using PstStylGuts.
; 			This procedure is called to paste the reserved style if there
; 			is one, and otherwise just to extend the current style.
; ----------------------------------------------------------------------

PstRsrved
			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; deref
			Move.L		nullStyle(A0),A0		; get reserved handle
			Move.L		(A0),A0					; deref
			Move.L		nullScrap(A0),A1		; get handle to scrap for null selection

			Move.L		A1,-(SP)				; save for unlocking later

			Move.L		(A1),A0					; deref
			Tst.W		scrpNStyles(A0)			; is there a style?
			Beq.S		@0						; do extend if not
			MoveM.L		D3/A4,-(SP)
			Move.L		A1,A4					; put scrap handle in A4

; Gotta lock down null scrap!
			Move.L		A1,A0
			_HLock

			MoveQ		#0,D3					; clear whole register
			Move.W		teSelStart(A3),D3		; PstStylGuts wants this
			Bsr			PstStylGuts				; go paste it
			MoveM.L		(SP)+,D3/A4
			Bra.S		@1

@0			Bsr			ExtendStyle				; just extend
@1
; Unlock previously locked null scrap
			Move.L		(SP)+,A0
			_HUnlock

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE PasteGuts


; 		Entry:
; 			D7 = 0, if ExtendStyle should be used to update style table
; 				 1, if PasteStyle should be used to update style table
; 			D5 = insert length after the delete
; 			D6 = pointer to text to insert

; ----------------------------------------------------------------------

PasteGuts
; The following routines cannot trash D5/D6
			Move.W		D7,-(SP)				; save flag
			Bsr			HideCaret				; 								<C971/RWW102887>NO
			Bsr			HiLite					; remove selection				<C971/RWW102887>NO

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@1						; no, skip style paste
			Tst.W		(SP)					; paste or extend?
			Beq.S		@0

			Bsr.S		PasteStyle				; paste associated style		<C971/RWW102887>NO
			Bra.S		@1						; no, skip style paste

@0			Bsr.S		PstRsrved				; get the style					<C971/RWW102887>NO

@1			Bsr			SelSort 				; sort select (A2 ^selStart/End)<C971/RWW102887>NO

			Move		D0,D7					; calc delta amount(selEnd in D0)
			Sub 		(A2),D7 				; ...for ReCalLines (A2 ^selStart)

			Bsr			MungeSetup				; setup for the paste replace

			Move		D7,-(SP)				; length for delete
			Clr 		-(SP)					; fake long length
			Move.L		D6,-(SP)				; pointer to insert = p2
			Move.L		D5,-(SP)				; length to insert = l2
			_Munger 							; use sloppy munger
			AddQ.L		#4,SP					; pop result

			Move.L		teTextH(A3),A0			; get text handle
			_Hlock								; and relock it

			Sub 		D7,teLength(A3) 		; length:=length -(selEnd-selStart)
			Add 		D5,teLength(A3) 		; adjust length by insert amount
			Sub 		D5,D7					; adjust delta amount for ReCalLines

			Bsr 		RecalDraw				; redo the line stuff

			Lea 		teSelStart(A3),A0		; point to selStart
			Add 		D5,(A0) 				; selStart:=selstart + insert amount
			Move		(A0)+,(A0)				; selEnd:=selStart

			Bsr			ShowCaret				; 								<C971/RWW102887>NO

			Bsr 		SelView 				; insure selection is visible

			AddQ.L		#2,SP					; remove flag from stack
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE PasteStyle

; 			** Added 5/28/86 by MBK **

; 			PasteStyle inserts the style scrap into the TERec style array
; 			If txSize is set to -1 (otherwise this is considered a record
; 			without style).

; 		Entry:
; 			D5:			length of pasted text
; 			A3:			ptr to TERec


; ----------------------------------------------------------------------
PasteStyle
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		EndPStyl				; only like stylish records		<C971/RWW102887>NO

			MoveM.L		D2-D6/A2/A4,-(SP)		; save stuff

			Bsr			SelSort					; get selStart, selEnd
			Move.W		D0,D4					; selEnd
			Swap		D0
			MoveQ		#0,D3					; make sure all clear		** <C207/13oct86/MBK> **
			Move.W		D0,D3					; selStart

; allocate a new handle for the styl scrap contents
			MoveQ		#0,D0					; min size
			Bsr			MyNewHandle				; get a temp handle			** <C381/7nov86/MBK> **
			Move.L		A0,A4					; store the handle
			Move.L		A0,-(SP)				; save the handle

; copy desk scrap to my temp scrap
			SubQ.L		#4,SP					; room for VAR
			Move.L		SP,A1					; save this address
			SubQ.L		#4,SP					; make room for result
			Move.L		A0,-(SP)				; push new handle
			Move.L		#'styl',-(SP)			; scrap type				** <C381/5nov86/MBK> **
			Move.L		A1,-(SP)				; don't care what this is
			_GetScrap							; get desk scrap
			Move.L		(SP)+,D0				; error code
			AddQ.L		#4,SP					; don't care
			Tst.L		D0						; style found?
			Bpl.S		@0						; there was a style in scrap!

			Bsr			PstRsrved				; get the style
			Bra.S		@4						; extend current style			<C971/RWW102887>NO

; 'styl' scrap was found, delete styles formerly associated with the selection
@0			Move.L		A4,A0
			_HLock								; lock scrap handle while deleting
			Move.W		D3,D0					; selStart
			Move.W		D4,D1					; selEnd
			Bsr			DeleteStyle				; delete associated styles

			Bsr.S		PstStylGuts				; do the paste

; get rid of temp scrap handle
@4			Move.L		(SP)+,A0				; temp scrap handle
			_DisposHandle						; get rid of it

			MoveM.L		(SP)+,D2-D6/A2/A4		; restore stuff

EndPStyl	Rts


; ----------------------------------------------------------------------

; 			PROCEDURE PstStylGuts

; 			** Separated out from PasteStyle 23jan87 by MBK **

; 			PstStylGuts inserts the style info pointed at by the A4
; 			handle into the TERec style array.

; 		Entry:
; 			D3:			selStart (high word must be clear!)
; 			D5:			length of pasted text
; 			A3:			ptr to TERec
; 			A4:			handle to style info


; ----------------------------------------------------------------------

PstStylGuts
; set up ptr to where new styles will be inserted
			Move.W		D3,D0					; get selStart
			SubQ		#1,D0					; pre-decrement
			Bsr			GetCurStyle				; get current style
			Move.W		D0,D4					; index to current style
			Move.L		(A4),A4					; dereference
			Move.W		scrpNStyles(A4),D2		; get # of styles in scrap
			Lea			scrpStyleTab(A4),A4		; ptr to style array
			Move.W		D3,D0					; selStart

			Bne.S		@0						; dup if not 0
			Tst.W		D2						; make sure num styles <> 0
			Beq.S		@05
			SubQ		#1,D4					; adjust index for this style
			Bra.S		@05

@0			Bsr			DupStyle				; make copy of style if needed
			Add.L		#stStartSize,A0			; pt to next style
@05
			Add.W		D2,D4					; save index to last style
			Bsr.S		MakeRoom				; make room in array			<C971/RWW102887>NO
			Move.L		A0,A2					; updated ptr
			Move.L		teStylesH(A3),A0		; lock handle because
			_HLock								; you'll be munging

; loop over styles in scrap, adding them to styles array if not there already
@1			Move.L		scrpStartChar(A4),D1	; get scrap start offset	** <C207/13oct86/MBK> **
			Add.L		D3,D1					; plus current offset		** <C207/13oct86/MBK> **

			Cmp.L		#$FFFF,D1				; offset cannot be > 64K	** <C381/6nov86/MBK> **
			Bhi.S		@3						; if it is don't add it		** <C207/13oct86/MBK> **

			Move.W		D1,-(SP)				; save offset				** <C207/13oct86/MBK> **
			Move.L		A4,A0					; ptr to stuff that counts

; The count is a longint in the scrap style table, so I should be adding
; 2 to point to where a regular style record would be pointing. Otherwise,
; FindStyle will not find this style in the table.
			AddQ.L		#2,A0

			Bsr			FindStyle				; look for it

			Tst.L		D0						; do we have it already?
			Bne.S		@2						; yes

			Move.L		A4,A0
			AddQ.L		#2,A0					; skip high word			** <C207/13oct86/MBK> **
			Bsr			AddStyle				; else, add it

			Move.W		#1,stCount(A1)			; A1 is still pointing to style entry

; in either case insert new style descriptor in runs array
@2			Move.W		(SP)+,D1				; restore offset
			Move.W		D1,(A2)+				; store style start
			Move.W		D0,(A2)+				; store style index

@3			Add.L		#scrpRecSize,A4			; pt to next scrap style
			SubQ.W		#1,D2					; dec style counter (make word len!)	<PMAB381/RWW020488>
			Bne.S		@1						; keep looping if more
			SubQ		#stStartSize,A2

; add size of pasted text to all following style starts
			Move.L		teStylesH(A3),A0		; handle to style info
			_HUnlock							; ok to unlock it now
			Move.L		A2,A0					; ptr to last style
			Move.W		D4,D0					; index to last style
			Bsr			RecalStStarts			; inc following style starts
			Bsr			ConcatStyles			; allow no duplications	** <C182/2oct86/MBK> **

			Bsr			ClearRsrved				; clear reserved handle

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE MakeRoom

; 			** Added 6/19/86 by MBK **

; 			MakeRoom moves down the contents of the runs array
; 			to make room for new entries.

; 		Entry:
; 			D2:			# of new entries
; 			A0:			ptr from which to move
; 		Exit:
; 			A0:			new ptr value (after resizing)

; ----------------------------------------------------------------------
MakeRoom
			MoveM.L		D2-D3/A2,-(SP)

			Move.L		A0,A2					; ptr from which to move
			Move.L		teStylesH(A3),A0		; style runs
			_HUnlock							; do this before setting D0

			Move.L		(A0),A1
			MoveQ		#1,D0					; + 1 for dummy end			** <C381/6nov86/MBK> **
			Add.W		nRuns(A1),D0			; current # of style runs	** <C381/6nov86/MBK> **
			Add.W		D2,nRuns(A1)			; new # of styles
			LsL.L		#2,D0					; * stStartSize				** <C381/6nov86/MBK> **
			Move.L		D0,D3					; preserve size for block move
			Add.L		#stBaseSize,D0			; add rest of handle size	** <C381/7nov86/MBK> **

			Lea			runs(A1),A1				; pt to start of style runs
			Sub.L		A1,A2					; preserve ptr as an offset	** <C381/6nov86/MBK> **
			Sub.L		A2,D3					; amount to be moved down
			Ext.L		D2						; make it a long			** <C381/6nov86/MBK> **
			LsL.L		#2,D2					; * stStartSize				** <C381/6nov86/MBK> **
			Add.L		D2,D0					; new size of block
			Bsr			MySetHandleSize			; reset handle size			** <C381/7nov86/MBK> **

			Move.L		(A0),A1					; dereference
			Lea			runs(A1),A1				; pt to start of style runs
			Add.L		A2,A1					; source					** <C381/6nov86/MBK> **
			_HLock								; assume locked state		** <C381/7nov86/MBK> **
			Move.L		A1,A0
			Add.L		D2,A1					; destination
			Move.L		D3,D0					; length
			_BlockMove							; make room


			MoveM.L		(SP)+,D2-D3/A2

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE DupStyle

; 			** Added 6/11/86 by MBK **

; 			DupStyle makes a duplicate copy of the current style ptr
; 			If no new style starts at the current cursor position.
; 			This is used when the style is about to be broken up by
; 			newly inserted styles (such as from TEStylePaste).

; 		Entry:
; 			D0:			selStart
; 			A0:			ptr to current style

; ----------------------------------------------------------------------
DupStyle
			Move.L		D2,-(SP)

			Move.L		A0,A1

			Add.L		#stStartSize,A0			; pt to next
			Cmp.W		startChar(A0),D0		; does a new style start here?
			Beq.S		@0						; if so, no need to dup

			Move.W		D0,-(SP)
			MoveQ		#1,D2					; one style to insert
			Bsr.S		MakeRoom				; make room for it				<C971/RWW102887>NO
			Move.L		A0,A1					; copy it
			SubQ		#stStartSize,A1			; point to prev style
			Move.W		(SP)+,startChar(A0)		; get style start
			Move.W		styleIndex(A1),D0		; get style's index		** <C381/7nov86/MBK> **
			Move.W		D0,styleIndex(A0)		; copy style index		** <C381/7nov86/MBK> **

; ** <C381/7nov86/MBK> ** obscure bug found by Andy H.; DupStyle should inc the stCount
			Bsr			GetStyle				; get the style			** <C381/7nov86/MBK> **
			AddQ		#1,stCount(A0)			; and inc the count

@0			Move.L		(SP)+,D2
			Move.L		A1,A0

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE FindStyle

; 			** Added 5/29/86 by MBK **

; 			FindStyle looks for a style in the style array matching the
; 			style pointed at by A0.

; 	Entry:
; 			A0:			ptr to style being sought
; 			A3:			TEHandle
; 	Exit:
; 			D0(High):	1 if style was found, 0 otherwise
; 			D0(Low):	style index if style is found, 0 otherwise
; 			A0:			ptr to entry in style array if style is found,
; 						No change otherwise

; ----------------------------------------------------------------------
FindStyle
			Move.L		D2,-(SP)				; save stuff

; get ptr to 1st style in text
			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1					; dereference
			Move.W		nStyles(A1),D2			; get # of styles in text
			Move.L		styleTab(A1),A1			; handle to styles array
			Move.L		(A1),A1					; dereference
			Lea			stFont(A0),A0			; set ptr to relevent data
			Move.W		D2,D1					; init to # of styles

; loop over styles comparing to the one being sought
@0			Tst.W		stCount(A1)				; is this style being used?
			Beq.S		@1						; doesn't count if not

			Bsr.S		CompareStyles			; do the styles match?			<C971/RWW102887>NO
; 			Tst.W		D0						; REDUNDANT!					<PMAB381/RWW020488>
			Beq.S		@2						; go if you have a match

@1			Add.L		#stRecSize,A1			; point to next style
			SubQ		#1,D1					; dec counter
			Bne.S		@0						; keep trying

			MoveQ		#0,D0					; clear flag to indicate not found
			Bra.S		@3

; a matching style was found, set flag and style index
@2			MoveQ		#1,D0					; indicates style found			** <C381/6nov86/MBK> **
			Swap		D0						; faster than MOVE.L #$10000,D0	** <C381/6nov86/MBK> **
			Sub.W		D1,D2					; get the difference
			Move.W		D2,D0					; return index in D0(Low)
			AddQ.W		#1,stCount(A1)			; inc the count
			Move.L		A1,A0					; return ptr in A0

@3			Move.L		(SP)+,D2				; restore stuff

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE CompareStyles

; 			** Added 5/29/86 by MBK **

; 			CompareStyles compares two styles byte by byte.

; 	Entry:
; 			A0:			ptr to one style
; 			A1:			ptr to another style
; 	Exit:
; 			D0:			non-zero if styles don't match, 0 if they do

; ----------------------------------------------------------------------
CompareStyles
			MoveM.L		A0-A1,-(SP)				; save ptrs

			Lea			stFont(A1),A1			; set ptr to relevent data
			Move.L		#styleSize,D0			; get size of style descriptor
@0			CmpM.B		(A0)+,(A1)+				; compare a byte
			Bne.S		@1						; quit if not equal
			SubQ		#1,D0					; else dec the counter
			Bne.S		@0						; keep comparing if not 0

@1			MoveM.L		(SP)+,A0-A1				; restore ptrs

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE AddStyle

; 			** Added 5/30/86 by MBK **

; 			AddStyle adds a new style to the styles array.

; 	Entry:
; 			A0:			ptr to style to be added
; 			A3:			TEHandle
; 	Exit:
; 			D0:			style index

; ----------------------------------------------------------------------
AddStyle
			MoveM.L		D2-D3/A2,-(SP)

; Get # of styles and handle to them
			Move.L		teStylesH(A3),A1		; get handle to style info
			Move.L		(A1),A2					; dereference
			Move.W		nStyles(A2),D0			; get # of styleRecs
			Move.W		D0,D3					; save it
			Move.L		styleTab(A2),A1			; handle to styleRecs
			Move.L		(A1),A1					; dereference

; If a style has a count of 0, its location may be reused by the new style
@0			Tst.W		stCount(A1)				; style being used?
			Beq.S		@1						; if not, it can be reused

			Add.L		#stRecSize,A1			; else, pt to next style rec
			SubQ		#1,D0					; dec the counter
			Bne.S		@0						; keep trying

; No empty slots found, so create room at the end
			Move.L		A0,-(SP)				; save ptr to new style
			AddQ		#1,nStyles(A2)			; inc # of styleRecs
			Move.L		styleTab(A2),A0			; handle to styleRecs
			_GetHandleSize						; how big is it?
			Move.L		D0,D2					; save size
			Add.L		#stRecSize,D0			; inc size by 1 record

; ** <C381/6nov86/MBK> ** didn't need to reset A0 again since GetHandleSize doesn't trash it
			Move.L		A0,A2					; handle to styleRecs		** <C381/6nov86/MBK> **
			Bsr			MySetHandleSize			; reset handle size			** <C381/7nov86/MBK> **
			Move.L		(SP)+,A0				; restore ptr to new style

			Move.L		(A2),A1					; dereference
			Add.L		D2,A1					; add record at end
			MoveQ		#0,D0					; will be using last slot

@1			Sub.W		D0,D3					; get the index
			Move.L		#stRecSize,D0			; size of record
			_BlockMove							; copy it to styleRec array

			Move.W		D3,D0					; return the index

			MoveM.L		(SP)+,D2-D3/A2

			Rts


; A3 the standard record w/selstart for the offset
; trashes A1
; leaves stack setup to l1

MungeSetup
			Move.L		(SP)+,A1				; get local RTS

			Move.L		teTextH(A3),A0			; get text handle
			_HUnlock

			SubQ.L		#4,SP					; room for result
			Move.L		A0,-(SP)				; push handle
			Move		teSelstart(A3),-(SP)	; start index for insert
			Clr 		-(SP)					; fake long for index
			Clr.L		-(SP)					; fake p1

			Jmp 		(A1)


; ----------------------------------------------------------------------

; 			PROCEDURE InsRsrved;

; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 			selection is NIL in iTESetStyle.  I store it in the scrap
; 			format so that it can easily be inserted using PstStylGuts.
; 			This procedure is called to insert the reserved style if there
; 			is one, and otherwise just to extend the current style.
; ----------------------------------------------------------------------
InsRsrved
			Tst.W		D5						; anything being inserted?
			Beq.S		@1						; quit if not
			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; deref
			Move.L		nullStyle(A0),A0		; get reserved handle
			Move.L		(A0),A0					; deref
			Move.L		nullScrap(A0),A1		; get handle to scrap for null selection
			Move.L		(A1),A0					; deref
			Tst.W		scrpNStyles(A0)			; is there a style?
			Beq.S		@0						; do extend if not
			MoveM.L		D3/A4,-(SP)
			Move.L		A1,A4					; put scrap handle in A4
			MoveQ		#0,D3					; clear whole register
			Move.W		teSelStart(A3),D3		; PstStylGuts wants this
			Bsr			PstStylGuts				; go paste it
			MoveM.L		(SP)+,D3/A4
			Bsr			ClearRsrved				; selection is different now
			Bra.S		@1

@0			Move.W		teSelStart(A3),D0		; get selStart
			SubQ		#1,D0					; pre-decrement
			Bsr			GetCurStyle				; get current style
			Bsr			RecalStStarts			; adjust start points

@1			Rts

; ----------------------------------------------------------------------

; 			PROCEDURE InsGuts

; 			** Modified 6/18/86 by MBK **

; 			Takes the text pointed to by D6 of length D5 and inserts it
; 			at selStart.  It then adjusts teLength by the inserted length.
; 			It also adjusts D7, the delta accumulator for RecalLines.

; 		Entry:
; 			D5 length of text
; 			D6 pointer to text
; 			D7 pending delta amount for recalLines
; 		Exit:
; 			D7 Adjusted by insert amount

; ----------------------------------------------------------------------
InsGuts
			Bsr.S		MungeSetup				; setup for the insert			<C971/RWW102887>NO

			Clr.L		-(SP)					; fake l1
			Move.L		D6,-(SP)				; pointer to insert = p2
			Move.L		D5,-(SP)				; length to insert = l2
			_Munger 							; use sloppy munger
			AddQ.L		#4,SP					; pop result

			Move.L		teTextH(A3),A0			; get text handle
			_Hlock								; and relock it

			Add 		D5,teLength(A3) 		; adjust length by insert amount
			Sub 		D5,D7					; adjust delta amount for ReCalLines

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; no, you're done		** MBK 6/18/86 **

			Bsr.S		InsRsrved				; insert the style				<C971/RWW102887>NO
@0
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TEInsert( pText: PTR; l: LONGINT; h: TEHandle );

; 			This inserts the passed text/length just before the selection
; 			but doesn't touch the scrap.  The selection too is "untouched"
; 			because it is offset by the inserted amount to point to the same
; 			range.  Just after a TENew this can be used as a replacement for
; 			the old TESetText because the slection and length are all zero.

; ----------------------------------------------------------------------
TEInsert
			Bsr 		StdEntry

			Bsr			HideCaret				; 								<C971/RWW102887>NO
			Bsr			HiLite					; remove selection				<C971/RWW102887>NO

			MoveQ		#0,D7					; delta = 0(No deletion)
			MoveM.L 	(A2)+,D5-D6 			; A2 points to l param
			Bsr.S		insGuts 				; go insert the scrap

			Bsr 		RecalDraw				; redo the line stuff

			Add 		D5,teSelStart(A3)		; selStart:=selstart + insert amount
			Add 		D5,teSelEnd(A3) 		; selEnd:=selEnd + insert amount

			Bsr 		ShowCaret
			Bsr			HiLite					; restore selection				<C971/RWW102887>NO

epilog12	MoveQ		#12,D0
			Bra 		StdExit

; ----------------------------------------------------------------------

; 			PROCEDURE TEKey( key: CHAR; h: TEHandle );

; 			** Modified 6/18/86 by MBK **

; ----------------------------------------------------------------------
TEKey
			Bsr			StdEntry				; 								<C971/RWW102887>NO

			ST			teLftCaret(A3)			; jam caret to left
			_ObscureCursor						; nice knowing you cursor

			Move.W		(A2),D1 				; store char away
			Cmp.B		#$08,D1 				; is it a backspace?
			Beq.S		backSpace

; Cursor Key support - Added from 'Lonely Hearts' patch 14Jan86

; left: If selStart isn't 0 it decrements it and places the caret there
; right:		Increments selEnd and places caret there
; up:	simulates a click one line above current selStart point
; down: simulates a click one line below current selStart point

			MoveQ		#1,D2					; assume going down

			MoveQ		#$1F,D0 				; range $1C-$1F
			Sub.B		D1,D0					; get key code
			Blt.S		@0

			Beq.S		downArrow				; is it a cursor key?
			SubQ.B		#1,D0
			Beq.S		upArrow
			SubQ.B		#1,D0
			Beq.S		rightArrow
			SubQ.B		#1,D0
			Beq.S		leftArrow
@0
			Bra.S		PasteChar				; => go paste in the character


upArrow
			MoveQ		#-1,D2					; going up
downArrow
			Move		D2,-(SP)				; save D2

			Move		teSelStart(A3),D3		; pass selStart=selEnd
			Move		D3,D4
			MoveQ		#-2,D7					; position pen to caret
			Bsr 		DoText					; the port ret. in A0

			Move		(SP)+,D2				; restore D2

			Bsr			FindLineHite			; get current line hite		** MBK 6/18/86 **

			MulS		D1,D2					; get delta -- a SIGNED 16-bit value<09Dec85 JTC>
			Move.L		teSelRect(A3),teSelPoint(A3)	; pass caret point
			Add 		D2,teSelPoint(A3)		; adjust v value
			Bsr 		DoFind					; the port ret. in A0

			ST			teLftCaret(A3)			; force clean clicks

			Bra.S		leftRight				; setselect'll force autoscroll

rightArrow
			Move		teSelEnd(A3),D6 		; get start
			AddQ		#1,D6					; going down
			Bra.S		leftRight
leftArrow
			Move		teSelStart(A3),D6		; get start
			Beq.S		leftRight
			SubQ		#1,D6					; going to left
leftRight
			Ext.L		D6						; D6 comes back char loc
			Move.L		D6,-(SP)				; pass start
			Move.L		D6,-(SP)
			Move.L		A4,-(SP)
			_TESetSelect

			Bsr 		DrawCaret				; force caret ON
			Bra.S		Epilog6

PasteChar

; Go paste the character

			Move.L		A2,D6					; point to the character
			AddQ		#1,D6					; character in lower half
			MoveQ		#1,D5					; one long

			MoveQ		#0,D7					; want to call ExtendStyle
			Bsr 		PasteGuts

			Bra.S		epilog6
backSpace
			Move		teSelStart(A3),D0		; see if null selection
			Cmp 		teSelEnd(A3),D0
			Bne.S		cutit

; since there's no selection eat characters to the left.

			Tst 		D0						; see if at extreme left
			Beq.S		epilog6 				; skip if so

			Bsr 		HideCaret				; remove the caret
			SubQ		#1,teSelStart(A3)		; adjust selection

cutit
			Move.L		A4,-(SP)				; pass the handle
			_TEDelete							; and cut it (A3 no good after)

epilog6 	MoveQ		#6,D0
			Bra 		StdExit


; ----------------------------------------------------------------------

; 			PROCEDURE ExtendStyle

; 			** Added 6/6/86 by MBK **

; 			Handles deletion or extension of styles.

; 	Entry:
; 			D5 	length of text being inserted (preserved)

; ----------------------------------------------------------------------
ExtendStyle
			Move.W		D5,-(SP)				; save length

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@1						; quit if not

; get selStart, selEnd and see if it's an insertion pt

			Bsr			SelSort					; sorts selStart, selEnd
			Move.W		D0,D1					; selEnd
			Swap		D0						; selStart in low byte now
			Cmp.W		D0,D1					; is it an insertion pt?
			Beq.S		@0						; no styles to delete if so

; If insertion is replacing a selection, you want to use the style of the
; first character of the selection (whereas if it's an insertion pt, you
; use the previous character's style).

			SubQ		#1,D5					; dec insertion length
			AddQ		#1,D0					; pt to next char

			Bsr			DeleteStyle				; else, delete excess styles

@0			Tst.W		D5						; anything to insert?
			Beq.S		@1						; you're done if not

			SubQ		#1,D0					; pre-decrement
			Bsr			GetCurStyle				; else get current style
			Bsr			RecalStStarts			; update style starts

@1			Move.W		(SP)+,D5				; restore length

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE FindLineHite

; 			** Added 6/16/86 by MBK **

; 			Finds the given line and returns its line height.

; 	Entry:
; 			D3 	selStart
; 	Exit:
; 			D1 	height of this line

; ----------------------------------------------------------------------
FindLineHite
			Move.L		A2,-(SP)				; save A2

			Lea			teLines(A3),A2			; pt to start of linestarts
			Move.W		D3,D0					; offset
			Bsr			GetLine					; get line that it's on
			Bsr			PtrToLine				; get line # from A2

; Get maximum height on this line from the array
			Bsr			GetHite					; get height of this line

			Move.L		(SP)+,A2				; restore A2

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TESetJust( just: INTEGER; h: TEHandle	);

; 			Sets the justify mode. DOESN'T redraw.  Lovely code...

; ----------------------------------------------------------------------
TESetJust
			Bsr 		StdEntry

			Move		(A2),teJust(A3) 		; set the style

			Bra.S		epilog6					; 								<C971/RWW102887>NO


; ----------------------------------------------------------------------

; 			PROCEDURE Refresh

; 			Redraws the lines intersected verticals top in D0, bottom in D1

; ----------------------------------------------------------------------

Refresh
			MoveQ		#0,D3					; min/max redraw pins in DoDraw
			MoveQ		#-1,D4
			Bsr 		PinA0Rect				; pass A0 rect to Pin code

			MoveQ		#teDraw,D7				; drawit
			Bsr 		DoText

			Bsr 		HiLite					; reshow selection

			Tst.B		teCarOn(A3) 			; force a redraw if caret is on
			Beq.S		handyReturn 			; if off skip it
			Bra 		ForceCaret				; implied return


; ----------------------------------------------------------------------

; 			PROCEDURE TEScroll( dh, dv: INTEGER; h: TEHandle )

; 			Scrolls the dest rect "under" the view rect to give the caller
; 			scrolling ability.  A call of ( 0, -lineheight, h) would scroll up
; 			one line, because dest rect is offset by the passed (dh,dv).  The
; 			resultant update region is redrawn

; ----------------------------------------------------------------------
TEScroll
			Bsr 		StdEntry

			Bsr 		HideCaret

			Move.L		(A2)+,D3				; get dv,dh pair
			Bsr.S		Scroll
epilog8
			MoveQ		#8,D0
			Bra 		StdExit

; Amount to scroll in D3

Scroll
			Tst.L		D3						; escape if nothing there
			Beq.S		ActCaret				; fix errant HideCaret (and RtsÉ)	<C971/RWW110587>

			Pea 		teDestRect(A3)			; pass the dest rectangle
			Move.L		D3,-(SP)				; pass dh, dv
			_OffsetRect

			SubQ		#4,SP					; make room for temp region
			_NewRgn 							; get it
			Move.L		(SP)+,A2				; save its handle

			Pea 		teViewRect(A3)			; pass rect to scroll
			Move.L		D3,-(SP)				; pass dh, dv
			Move.L		A2,-(SP)				; pass the temp region
			_ScrollRect

			Bsr.S		ActCaret				; just activate, don't draw		<C971/RWW102887>NO

			Move.L		A2,-(SP)				; clip to it update rgn
			_SetClip

			Move.L		(A2),A0 				; point to region
			Lea 		rgnBBox(A0),A0
			Bsr.S		Refresh 				; and redraw those lines

			Move.L		A2,-(SP)				; get rid of temp region
			_DisposRgn
@0
handyReturn
			Rts


; ** <C207/14oct86/MBK> ** Don't draw caret yet, just activate it
ActCaret	Tst.B		teActive(A3)			; do nothing if not active
			Beq.S 		@0						; 								<C971/RWW102887>NO

			Move		teSelStart(A3),D0		; see if should be turned on
			Cmp 		teSelEnd(A3),D0
			Bne.S		@0						; if selection <> 0 then escape
			ST			teCarAct(A3)			; replaced ShowCaret

@0			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE TEPinScroll( dh, dv: INTEGER; h: TEHandle )

; 			** Modified 6/18/86 by MBK **

; 			Scrolls the dest rect "under" the view rect to give the caller
; 			scrolling ability.  A call of ( 0, -lineheight, h) would scroll up
; 			one line, because dest rect is offset by the passed (dh,dv).  The
; 			resultant update region is redrawn.  This version pins the scroll
; 			amount to the destRect/nLines

; ----------------------------------------------------------------------
TEPinScroll
			Bsr 		StdEntry

			Bsr 		HideCaret

			Move		(A2),D0 				; get dV
			Bpl.S		@1						; pin top

			Move.W		teNLines(A3),D1			; last line				** MBK 6/18/86 **
			Move.W		teLength(A3),D0			; last char				**<C207/14oct86/MBK> **
			Tst.W		D0						; anything in file?		**<C207/14oct86/MBK> **
			Beq.S		@0						; skip test if not		**<C207/14oct86/MBK> **

			Move.L		teTextH(A3),A0			; text handle			**<C207/14oct86/MBK> **
			Move.L		(A0),A0					; dereference			**<C207/14oct86/MBK> **
			Cmp.B		#$0D,-1(A0,D0)			; file end with CR?		**<C207/14oct86/MBK> **
			Bne.S		@0						; end of file if not	**<C207/14oct86/MBK> **

			AddQ		#1,D1					; else 1 more line		**<C207/14oct86/MBK> **

@0			MoveQ		#0,D0					; 1st line				** MBK 6/18/86 **
			Bsr			GetLineHites			; compile max hites		** MBK 6/18/86 **
			Move.W		D0,D1					; hite from 1st to last	** MBK 6/18/86 **
			Move.W		(A2),D0					; restore D0			** MBK 6/18/86 **

			Add 		teDestRect+top(A3),D1	; get destRect.top

			Sub 		teViewRect+bottom(A3),D1	; a diff. viewRect.bottom
			Ble.S		@2						; dest already gone...
			Add 		D1,D0					; see what delta does
			Bpl.S		pinH

			Bra.S		@2						; should be subtracted because it's negative

@1
			Move		teDestRect+top(A3),D1	; add destRect.top
			Sub 		teViewRect+top(A3),D1	; diff. viewRect.top
			Bpl.S		@2						; already bad

			Add 		D1,D0
			Bmi.S		pinH
@2
			Sub 		D0,(A2) 				; adjust scroll
pinH
			Move		2(A2),D0				; get dH
			Bpl.S		@1						; pin top
			Move		teDestRect+right(A3),D1	; add destrect.right
			Sub 		teViewRect+right(A3),D1	; a diff. viewRect.right
			Ble.S		@2						; already past, cancel scroll
			Add 		D1,D0
			Bpl.S		pinDone
			Add 		D0,2(A2)				; adjust scroll
			Bra.S		pinDone
@1
			Move		teDestRect+left(A3),D1	; add destRect.left
			Sub 		teViewRect+left(A3),D1	; diff. viewRect.left
			Bpl.S		@2						; already past, cancel scroll
			Add 		D1,D0
			Bmi.S		pinDone
@2
			Sub 		D0,2(A2)				; adjust scroll
pinDone

			Move.L		(A2)+,D3				; get dv,dh pair
			Bsr 		Scroll					; and go scroll it

			Bsr			ActCaret				; just activate, don't draw	** <C207/14oct86/MBK> **

			Bra 		epilog8


; ----------------------------------------------------------------------

; 			PROCEDURE TESelView( hTe: TEHandle );

; 			** Modified 6/18/86 by MBK **

; 			Insures the selection is in view rect.  SelView is a local
; 			copy of it

; ----------------------------------------------------------------------

TESelView
			Bsr 		StdEntry					; doo dah...

			Bsr.S		SelView 				; go do it

			Bra 		epilog4

; local cover (A4/A3 pointing to usual record)
SelView

; <PMAB381/RWW020488>
; 	Changed from teFlags to new whizzy position in TEDispatchRec
; 			BTst		#tefAutoPos,teFlags(A3) ; scrolling allowed?
			Move.L		teDispatchH(A3),A0
			Move.L		(A0),A0
			Move.L		newTEFlags(A0),D0
			BTst		#0,D0
			Beq.S		@0						; if not, must skip

			Bsr 		SelSort 				; sort selection

			Move		teSelStart(A3),D3		; dispStart:=selStart
			Move		D3,D4					; dispEnd:=same
			MoveQ		#teLoc,D7				; does nothing except moves pen
			Bsr 		DoText					; position for the caret

			Move.L		teSelRect+topLeft(A3),D7	; save penloc in D7

			Lea 		tempRect+8,A2			; place for working rect
			Lea 		teViewRect+8(A3),A0 	; source
			Move.L		-(A0),-(A2)
			Move.L		-(A0),-(A2)

			Move		teSelStart(A3),D3		; dispStart:=selStart	** <C95/4aug86/MBK> **
			Bsr			FindLineHite			; get height of line	** <C95/4aug86/MBK> **
			Sub 		D1,bottom(A2)
			SubQ		#1,right(A2)			; room for caret

			SubQ		#2,SP
			Move.L		D7,-(SP)				; pass selStart location
			Move.L		A2,-(SP)				; pass adjust viewRect
			_PtInRect
			Tst.B		(SP)+
			Bne.S		@0						; if visible, then OK

			Move.L		(A2)+,-(SP) 			; get adjusted viewRect.topLeft

			Move.L		(A2),-(SP)				; get adjusted viewRect.botRight
			Move.L		-(A2),-(SP) 			; subtract adjusted topLeft
			Pea 		4(SP)
			_SubPt
			Pea 		4(SP)					; add top to delta
			_AddPt
			Move.L		D7,-(SP)				; subtract penloc
			Pea 		4(SP)					; to "center" pen if possible
			_SubPt
			Move.L		A4,-(SP)

			_TEPinScroll 						; s/b a trap		** <C381/6nov86/MBK> **

@0
			Rts 								; adios


; ----------------------------------------------------------------------

; 			PROCEDURE TEAutoView( auto: BOOLEAN; hTe: TEHandle );

; 			Sets the autoview bit according to the boolean

; ----------------------------------------------------------------------

TEAutoView
			Bsr 		StdEntry					; doo dah...

			Move.L		teDispatchH(A3),A0		; <PMAB381/RWW020488>
			Move.L		(A0),A0					; <PMAB381/RWW020488>
			Move.L		newTEFlags(A0),D0		; <PMAB381/RWW020488>

			Tst.B		(A2)+					; was it true
			Beq.S		@0

; 			BSet		#tefAutoPos,teFlags(A3) ; allow scrolling
			BSet		#0,D0					; <PMAB381/RWW020488>
			Bra.S		@1
@0
; 			BClr		#tefAutoPos,teFlags(A3) ; allow scrolling
			BClr		#0,D0
@1
			Move.L		D0,newTEFlags(A0)
			Bra 		epilog6


; ----------------------------------------------------------------------

; 			PROCEDURE DefClikProc

; 			Default click proc for scrolling - does a pinned autoscroll of
; 			the destRect to match the viewrect.
; 		Entry:
; 			A3 pointing to the dereferenced text edit record
; 			A6 pointing to the standard stack frame
; 			thePort set, etc.
; 		Exits:
; 			CC's set <> 0

; ----------------------------------------------------------------------


DefClikProc
			MoveM.L 	D0-D7/A0-A4,-(SP)		; save ALL regs

; 			BTst		#tefAutoPos,teFlags(A3) ; scrolling allowed?
			Move.L		teDispatchH(A3),A0		; <PMAB381/RWW020488>
			Move.L		(A0),A0					; <PMAB381/RWW020488>
			Move.L		newTEFlags(A0),D0		; <PMAB381/RWW020488>
			BTst		#0,D0					; <PMAB381/RWW020488>
			
			Beq.S		doneAuto				; if not, must skip

			Lea 		teViewRect+8(A3),A0 	; point to view rect
			Lea 		tempRect+8,A2			; copy into tempRect
			Move.L		-(A0),-(A2)
			Move.L		-(A0),-(A2)

			SubQ		#4,SP					; room for pt
			Move.L		SP,-(SP)
			_GetMouse
			Move		(SP)+,D6				; get V coordinate
			Move		(SP)+,D7				; get H coordinate

			MoveQ		#0,D4					; horz scroll amt
			Move		teLineHite(A3),D1		; vert scroll amt
			Bpl.S		@1						; use if not negative				** <C207/13oct86/MBK> **

			Move.W		D6,D0					; find D6 line						** <C207/13oct86/MBK> **
			Cmp.W		teDestRect+bottom(A3),D0	; pt below the rect?				** <C207/13oct86/MBK> **
			Ble.S		@0						; okay if less or same				** <C207/13oct86/MBK> **

			Move.W		teDestRect+bottom(A3),D0	; else reset to bottom				** <C207/13oct86/MBK> **

@0			Bsr			PtToLine				; try to find its line #			** <C207/13oct86/MBK> **
			Bge.S		doneAuto				; no scroll if line doesn't exist	** <C207/13oct86/MBK> **

			Bsr			GetHite					; else get its height

@1			Cmp 		(A2)+,D6				; subtract top of viewRect
			Blt.S		scrollUp				; scroll up

			Cmp 		(A2)+,D7				; subtract left of viewRect
			Blt.S		scrollLeft				; scroll left

			Cmp 		(A2)+,D6				; subtract bottom of viewRect
			Bgt.S		scrollDown				; scroll down

			Cmp 		(A2)+,D7				; subtract right of viewRect
			Bgt.S		scrollRight 			; scroll right
doneAuto
			MoveQ		#1,D0					; cc's <> 0
			MoveM.L 	(SP)+,D0-D7/A0-A4		; restore ALL regs
			Rts

scrollDown
			Neg 		D1						; flip direction
scrollUp
			Bra.S		scrollEm

scrollRight
			Neg 		D1						; flip direction
scrollLeft
			Exg 		D4,D1					; switch axes
scrollEm

; Finally do the scroll

			Move		D4,-(SP)				; pass dh
			Move		D1,-(SP)				; pass dv
			Move.L		8(A6),-(SP) 			; tehandle

			_TEPinScroll 						; _TEPinScroll		** <C381/6nov86/MBK> **

			Bra.S		doneAuto				; 								<C971/RWW102887>NO


; ----------------------------------------------------------------------

; 			PROCEDURE GetCurStyle

; 			** Added 6/5/86 by MBK **

; 			Gets the current style; in other words, it finds the 1st style
; 			descriptor preceding the current selection.

; 	Entry:
; 			D0 	selection start (whose style we wish to find)

; 	Exit:
; 			D0 	index into runs array of current style
; 			A0	ptr into runs array to current style

; ----------------------------------------------------------------------
GetCurStyle
			MoveM.L		D1-D4,-(SP)

; get low and high indeces, and ptr to array for binary search
			AddQ		#1,D0					; don't get preceding style
			Move.W		D0,D2					; save the key (sel start)
			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; deref
			Move.W		nRuns(A0),D1			; high index
			Lea			runs(A0),A0				; pt to runs array
			MoveQ		#0,D0					; low index

; start of binary search loop
@0			Cmp.W		D0,D1					; are indeces the same?
			Beq.S		@3						; we're done if so

			Move.W		D1,D3
			Add.W		D0,D3					; low + high
			LsR.W		#1,D3					; divide by 2
			MoveQ		#0,D4					; clear the long word	** <C381/6nov86/MBK> **
			Move.W		D3,D4					; middle
			LsL.L		#2,D4					; mult by stStartSize	** <C381/6nov86/MBK> **
			Cmp.W		0(A0,D4),D2				; do we have a match?
			Beq.S		@2						; we're done if so
			Bls.S		@1						; range is low to mid

; no change in high; low gets middle + 1
			Move.W		D3,D0					; low := middle + 1
			AddQ		#1,D0
			Bra.S		@0						; try again

; no change in low; high gets middle
@1			Move.W		D3,D1					; else high := middle
			Bra.S		@0						; try again

@2			Move.W		D3,D0					; store answer in D0

; return ptr into runs array and index to the styleRec
@3			Tst.W		D0
			Beq.S		@4						; special case of 1st style

			SubQ		#1,D0					; point to prev style

@4			MoveQ		#0,D1					; clear the long word	** <C381/6nov86/MBK> **
			Move.W		D0,D1
			LsL.L		#2,D1					; mult by stStartSize	** <C381/6nov86/MBK> **
			Add.L		D1,A0					; ptr to style start

			MoveM.L		(SP)+,D1-D4

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE GetNumStyles

; 			** Added 5/28/86 by MBK **

; 			GetNumStyles counts the number of styles in the current
; 			selection range in the text.

; 	Entry:
; 			D1:			selEnd
; 			A0:			ptr to current style in runs array

; 	Exit:
; 			D0:			# of styles within current selection

; ----------------------------------------------------------------------
GetNumStyles
			Move.L		A0,-(SP)				; save ptr

			Move.L		teStylesH(A3),A1		; handle to style info
			Move.L		(A1),A1					; dereference
			MoveQ		#0,D0					; clear whole register		** <C381/6nov86/MBK> **
			Move.W		nRuns(A1),D0			; # of style starts
			Lea			runs(A1),A1				; pt to style starts
			LsL.L		#2,D0					; * stStartSize				** <C381/6nov86/MBK> **
			Add.L		D0,A1					; pt to last style start
			MoveQ		#0,D0					; init the counter

; keep checking style starts till one is >= selEnd (eventually it MUST be)
@0			Add.L		#stStartSize,A0			; point to next style record
			AddQ		#1,D0					; at least 1 style

			Cmp.L		A0,A1					; reached the end?
			Beq.S		@1						; quit if so

			Cmp.W		startChar(A0),D1		; is style within selection?
			Bhi.S		@0						; made this unsigned	** <C381/6nov86/MBK> **

@1			Move.L		(SP)+,A0

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE GetStyle

; 			** Added 5/29/86 by MBK **

; 			GetStyle returns a pointer to the style found at the given
; 			index into the style array.

; 	Entry:
; 			D0:			style index
; 			A3:			Ptr to TERec
; 	Exit:
; 			A0:			style pointer

; ----------------------------------------------------------------------
GetStyle
			MulU		#stRecSize,D0			; multiply index by size of record
			Move.L		teStylesH(A3),A0		; get style handle
			Move.L		(A0),A0					; dereference
			Move.L		styleTab(A0),A0			; handle to styles array
			Move.L		(A0),A0					; dereference
			Add.L		D0,A0					; point to style descriptor

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE RecalStStarts

; 			** Added 5/23/86 by MBK **

; 			Recomputes the starting offsets of each style in the text
; 			following the current one.  It adds the length of the newly
; 			inserted text to each offset following the insertion point.

; 		Entry:
; 			D0 index to current style in runs array
; 			D5 length of inserted text
; 			A0 pointer to the current style in runs array

; ----------------------------------------------------------------------
RecalStStarts
			Move.L		teStylesH(A3),A1		; get handle to style info
			Move.L		(A1),A1					; deref
			Move.W		nRuns(A1),D1			; get # of style starts
			Sub.W		D0,D1					; subtract current index
			Bls.S		@1						; made this unsigned	** <C381/6nov86/MBK> **

; add length of inserted text to all following style starts
@0			Add.L		#stStartSize,A0			; point to next style record
			Add.W		D5,startChar(A0)		; add length to starting offset
			SubQ		#1,D1					; dec the counter
			Bne.S		@0

@1
			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE SetRsrved;

; 			** <C851/14Apr87/MBK> **

; 			I changed teReserved to a handle to the following structure:
; 				Record
; 					newReserved : LONGINT;
; 					nullScrap	: stScrpHandle;
; 				End;
; 			nullScrap is used to store a style which is set when the
; 				selection is NIL in iTESetStyle.  I store it in the scrap
; 				format so that it can easily be inserted using PstStylGuts.
; 				This procedure is called to set the style to whatever the user
; 				has input to iTESetStyle.

; 			On entry, SetRsrved expects A2 to be pointing to something
; 				that looks like this:
; 					flag.B TextStylePtr.L mode.W
; 				The flag is not accessed and can just be a hole if desired.
; ----------------------------------------------------------------------
SetRsrved
			Move.W		teSelStart(A3),D0		; get selection start
			Cmp.W		teSelEnd(A3),D0			; same as selEnd?
			Bne			lvSetRsrved				; quit if not

AltSetRsrved									; 									<C971/RWW102987>
			Move.L		teStylesH(A3),A1		; get style handle
			Move.L		(A1),A1					; deref
			Move.L		nullStyle(A1),A1		; get reserved handle
			Move.L		(A1),A1					; deref
			Move.L		nullScrap(A1),A1		; get handle to scrap for null selection
			Move.L		A1,-(SP)				; save handle for later
			Move.L		(A1),A1					; deref
			Tst.W		scrpNStyles(A1)			; stored already?
			Beq.S		@0						; reset if not
			Lea			scrpStyleTab(A1),A1		; point to start of tableev style if so
			Bra.S		@1						; go use new settings

; First get current style settings
@0			SubQ		#1,D0					; in case sel is on a run boundary
			Bsr			GetCurStyle				; get current style run
			Move.W		styleIndex(A0),D0		; get style index
			Bsr.S		GetStyle				; get the style in A0			<C971/RWW102887>NO
			Move.W		#1,scrpNStyles(A1)		; indicate 1 style
			Lea			scrpStyleTab(A1),A1		; point to start of table
			Move.L		#0,scrpStartChar(A1)	; store start offset
			Lea			stFont(A0),A0
			Move.L		(A0)+,scrpFont(A1)		; font, face
			Move.L		(A0)+,scrpSize(A1)		; size, color
			Move.L		(A0)+,scrpColor+2(A1)	; color

; now adjust according to new settings
@1			Move.W		6(A2),D2				; get the mode
			Move.L		2(A2),A0				; get style ptr
			BTst		#fontBit,D2				; set font?
			Beq.S		@2						; no
			Move.W		tsFont(A0),scrpFont(A1)	; else, set it

@2			BTst		#faceBit,D2				; set face?
			Beq.S		@4						; no

; ** <C971/RWW102987>	Added code to support doToggle mode.
; An insertion point is by definition continuous, so all we have to do is
; calculate unique set elements
			Move.B		tsFace(A0),D0			; fetch given face					<C971/RWW102987>

			BTst		#toglBit,D2				; toggling?							<C971/RWW102987>
			Bz.S		@3						; no, go set						<C971/RWW102987>

			Eor.B		D0,scrpFace(A1)			; 									<C971/RWW111187>
			Bra.S		@4						; 									<C971/RWW102987>

@3			Tst.B		D0						; if new face is plainÉ				<C971/RWW102987>
			Bnz.S		@35						; 									<C971/RWW102987>
			Clr.B		scrpFace(A1)			; Éwipe out old attributes			<C971/RWW102987>
@35			Or.B		D0,scrpFace(A1)			; union in new attributes			<C971/RWW102987>

@4			BTst		#sizeBit,D2				; set size only?
			Beq.S		@5						; no
			BTst		#addSizeBit,D2			; is addSize also set?
			Bne.S		@5						; it has precedence
			Move.W		tsSize(A0),scrpSize(A1)	; else, get size

@5			BTst		#clrBit,D2				; set color only?
			Beq.S		@6						; no
			Move.L		tsColor(A0),scrpColor(A1)	; store the new value there
			Move.W		tsColor+4(A0),scrpColor+4(A1)	; store color ,hi

@6			BTst		#addSizeBit,D2			; is it addSize?
			Beq.S		@9
			Move.W		scrpSize(A1),D0			; get current size
			Bne.S		@7						; => not 0
			Move.B		FmDefaultSize,D0		; get default size as byte value** <C440/19nov86/MBK> **

@7			Add.W		tsSize(A0),D0			; add increment to size
			Bgt.S		@8						; size <-1 if it's 0 or negative
			Move.W		#1,D0					; minimum allowable

@8			Move.W		D0,scrpSize(A1)			; now store it

@9			Move.L		teGrafPort(A3),A0		; the port
			Move.W		scrpFont(A1),txFont(A0)	; set font
			Move.W		scrpFace(A1),txFace(A0)	; set face
			Move.W		scrpSize(A1),txSize(A0)	; set size
			Bsr			GetSize					; get ascent & hite
			Move.L		(SP)+,A0				; get back scrap handle
			Move.L		(A0),A0					; deref
			Lea			scrpStyleTab(A0),A0		; pt to start of scrap table
			Move.W		D0,scrpAscent(A0)		; save in ascent
			Move.W		D1,scrpHeight(A0)		; save in line height

lvSetRsrved
			Rts

; ----------------------------------------------------------------------

; 	PROCEDURE iTESetStyle( SetMode: INTEGER; Styl: StylPtr; redraw: BOOLEAN;
; 						 hTE: TEHandle );

; 	Sets the style of the selected text (replacing all other styles).

; 	Supports the following modes:
; 	1	doFont:		Set Font only
; 	2	doFace:		Set Face only
; 	4	doSize:		Set Size only
; 	8	doColor:	Set Color only
; 	15	doAll:		Set all modes
; 	16	addSize:	Add Size integer to each size in selection
; 	32	doToggle:	Set each face attribute if not continuous, reset otherwise		<C971/RWW102987>

; ----------------------------------------------------------------------

iTESetStyle

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@1						; if not, sorry, can't set it

			Bsr			SetRsrved				; save the style

; ** <C381/6nov86/MBK> ** boolean value is in bit 1 of high byte
			Move.W		(A2)+,D0				; get redraw value			** <C381/6nov86/MBK> **
			And			#$FF00,D0				; check redraw value		** <C381/6nov86/MBK> **
			Bne.S		@0						; must redraw if set

			Bsr.S		SetGuts					; else just add styles
			Bra.S		@1

@0			Move.L		A2,-(SP)				; save ptr to parameters

			Bsr			HideCaret
			Bsr			HiLite					; remove selection

			Move.L		(SP)+,A2				; restore ptr to parameters

			Bsr.S		SetGuts					; do style munging

			MoveQ		#0,D7					; length is 0

			Bsr			RecalDraw				; redo the line stuff

			Bsr			ShowCaret
			Bsr			Hilite					; restore selection

			Bsr			SelView					; ensure selection is visible

@1			MoveQ		#14,D0
			Bra			stdExit2


; ----------------------------------------------------------------------

SetGuts
			MoveM.L		D2-D7/A2/A4/A6,-(SP)	; save registers
			Move.L		(A2)+,A4				; style ptr
			Move.W		(A2)+,D7				; save mode here
			Sub.L		A6,A6					; not used by SetStyle

; ** <C971/RWW102987>	Added code to support doToggle.
; I changed the next statement to a mask from the original, which punted if
; it saw bits it didn't like.

			And.W		#doAll3,D7				; only lower 6 bits make sense		<C971/RWW102987>

			Move.W		D7,D0					; 									<C971/RWW102987>
			And.W		#doFace+doToggle,D0		; are we toggling?					<C971/RWW102987>
			Cmp.W		#doFace+doToggle,D0		; (both bits have to be on, dummy!)	<C971/RWW102987>
			Bne.S		@05						; 									<C971/RWW102987>

			SubQ.W		#1,A6					; -1 to signal toggle mode			<C971/RWW102987>
			Move.W		#doFace,-(SP)			; prepare fake frame for call		<C971/RWW102987>

; SP => doFace/2																<C971/RWW102987>
			Sub.W		#styleSize+2,SP			; make room for result & TextStyle	<C971/RWW102987>

; SP => VAR/2  VAR/styleSize  doFace/2											<C971/RWW102987>
			Pea			styleSize+2(SP)			; push pointer to doFace			<C971/RWW102987>

; SP => ^doFace/4  VAR/2  VAR/styleSize  doFace/2								<C971/RWW102987>
			Pea			4+2(SP)					; push pointer to TextStyle hole	<C971/RWW102987>

; SP => ^VAR/4  ^doFace/4  VAR/2  VAR/styleSize  doFace/2						<C971/RWW102987>
			Move.L		SP,A2					; point A2 at stacked parameters	<C971/RWW102987>

			Bsr			ContGuts				; coalesce continuous styles		<C971/RWW102987>

			Add.W		#10,SP					; pop stack back to TextStyle		<C971/RWW102987>
			Move.B		tsFace(SP),D5			; save continuous face attributes	<C971/RWW102987>
			Swap		D5						; we'll need low word later			<C971/RWW102987>
			Add.W		#styleSize+2,SP			; now remove TextStyle & doFace		<C971/RWW102987>
@05												; 									<C971/RWW102987>
			Bsr.S		StyleGuts				; do style munging

@0			MoveM.L		(SP)+,D2-D7/A2/A4/A6	; restore registers
			Rts


; ----------------------------------------------------------------------
StyleGuts
			Tst.W		D7						; check mode
			Beq			EndStyle				; 0 is invalid mode

			Bsr			SelSort					; sort selStart, selEnd
			Move.W		D0,D1					; save selEnd						<C971/RWW102987>
			Move.W		D0,D4
			Swap		D0
			Move.W		D0,D3					; save selStart
			Sub.W		D3,D1					; save selection length				<C971/RWW102987>
			Beq			EndStyle				; if len = 0, nothing to do

; store the input style information temporarily
			Sub.L		#stRecSize,SP			; make room on stack
			Move.L		SP,A2					; save ptr in A2

; 			Move.W		D3,D0					; selStart REDUNDANT!				<PMAB381/RWW020488>
			Bsr			GetCurStyle				; get current style
			Move.W		D4,D1					; selEnd
			Bsr			GetNumStyles			; get # of styles within selection
			Move.W		D0,D2					; preserve # of styles
			Swap		D3						; selStart in upper word
			Move.W		D4,D3					; selEnd in lower word

; ** <C971/RWW102787>	Faces are byte lengthÉ
			Move.B		tsFace(A4),D4			; save face							<C971/RWW102787>
			Swap		D4						; put face in upper word
			Move.W		tsFont(A4),D4			; font in lower word
			Move.W		tsSize(A4),D5			; save size
			Move.L		tsColor(A4),D6		 	; save color
			Swap		D7						; running out of reg's	** <C182/6oct86/MBK> **
			Move.W		tsColor+4(A4),D7		; store color in D7,hi	** <C182/6oct86/MBK> **
			Swap		D7						; keep mode in D7,low	** <C182/6oct86/MBK> **
			Move.L		A2,A4					; temp style handle

			Move.L		A0,A2					; preserve ptr

			Move.L		teStylesH(A3),A0		; handle to style info	** <C381/6nov86/MBK> **
			_HLock								; keep it locked		** <C381/6nov86/MBK> **

; By this point, the world looks like this:
; 			D2.W	=	number of styles in current selection (used as counter)
; 			D3.L	=	selStart/selEnd (high word/low word)
; 			D4.L	=	Face/Font
; 			D5.L	=	Toggle face info/Size
; 			D6.L	=	Color Red/Green
; 			D7.L	=	Color Blue/set mode
; 			A2.L	=>	StyleRun array, first associated element
; 			A4.L	=>	working STElement on stack

styleLoop	Move.W		styleIndex(A2),D0		; else, index to style
			Bsr			GetStyle				; find it
			Bsr			CheckMatch				; must match for replacement
			Tst.W		D0						; check return flag
			Beq			noMatch					; if false, don't replace

			Move.L		#stRecSize,D0			; length of a styleRec
			Move.L		A4,A1					; ptr to temp storage
			_BlockMove							; copy to temp location for mod

			Move.L		A2,A0					; current style
			Move.L		D3,D0					; selStart, selEnd
			Swap		D0						; selStart in low word
			Cmp.W		startChar(A2),D0		; compare to style start
			Bls.S		@0						; made this unsigned	** <C381/6nov86/MBK> **

			Bsr			DupStyle				; else dup it
			AddQ		#stStartSize,A0			; new style replaces this
			Move.L		A0,A2

@0			Cmp.W		#1,D2					; last style?
			Bne.S		@1						; not yet

			AddQ		#stStartSize,A0
			Cmp.W		startChar(A0),D3		; compare to style end
			Beq.S		@1						; ok if same as selEnd

			Move.W		D3,D0					; selEnd
			Move.L		A2,A0					; current style
			Bsr			DupStyle				; dup it
			Move.L		A0,A2					; ptr updated in A0

; ** <C381/7nov86/MBK> ** dupstyle was fixed to inc the style count, so it's
; 							ok to dec it in all cases now
@1			MoveQ		#1,D0					; # of styles to (possibly) delete
			Move.L		A2,A0					; ptr to style start
			Bsr			DecStylCount			; style used 1 less time

			BTst		#fontBit,D7				; set font?
			Beq.S		@3						; no

			Move.W		D4,stFont(A4)			; else, put in temp rec

@3			BTst		#faceBit,D7				; set face?
			Beq.S		@5						; no

; ** <C971/RWW102987>	This new code supports the doToggle mode
			Move.L		D4,D0					; fetch face information			<C971/RWW102987>
			Swap		D0						; move face to low byte				<C971/RWW102987>

			Move.L		A6,D1					; are we just setting?				<C971/RWW102987>
			Bz.S		@41						; 									<C971/RWW102987>

			AddQ.L		#1,D1					; are we toggling? (was it just -1?)<C971/RWW102987>
			Beq.S		@42						; yes, go handle					<C971/RWW102987>

; ReplacingÉ																	<C971/RWW102987>
			Move.B		D0,stFace(A4)			; we must be replacing, then		<C971/RWW102987>
			Bra.S		@5						; 									<C971/RWW102987>

; TogglingÉ (algorithm also works for plain, so we don't have to special case)	<C971/RWW102987>
@42			Move.L		D5,D1					; fetch toggle info					<C971/RWW102987>
			Swap		D1						; move continuous face to low byte	<C971/RWW102987>
			And.B		D0,D1					; intersect faces for XOR mask		<C971/RWW102987>
			Eor.B		D1,D0					; difference from desired is OR mask<C971/RWW102987>
			Or.B		D0,stFace(A4)			; union in new style attributes		<C971/RWW102987>
			Eor.B		D1,stFace(A4)			; remove already set attributes		<C971/RWW102987>
			Bra.S		@5						; 									<C971/RWW102987>

; MergingÉ																		<C971/RWW102987>
@41			Tst.B		D0						; is it plain?						<C971/RWW102987>
			Bnz.S		@43						; no, merge in attributes			<C971/RWW102987>
			Clr.B		stFace(A4)				; remove all styles if plain		<C971/RWW102987>
@43			Or.B		D0,stFace(A4)			; union sets						<C971/RWW102987>

@5			BTst		#sizeBit,D7				; set size only?
			Beq.S		@6						; no

			BTst		#addSizeBit,D7			; is addSize also set?	** <C139/10Sep86/MBK> **
			Bne.S		@6						; it has precedence		** <C139/10Sep86/MBK> **

			Move.W		D5,stSize(A4)			; else, get size

@6			BTst		#clrBit,D7				; set color only?
			Beq.S		@7						; no

			Move.L		D6,stColor(A4)			; store the new value there
			Swap		D7						; running out of reg's	** <C182/6oct86/MBK> **
			Move.W		D7,stColor+4(A4)		; store color in D7,hi	** <C182/6oct86/MBK> **
			Swap		D7						; keep mode in D7,low	** <C182/6oct86/MBK> **

@7			BTst		#addSizeBit,D7			; is it addSize?		** <C139/10Sep86/MBK> **
			Beq.S		@9

			Move.W		stSize(A4),D0			; get current size
			Bne.S		@8						; => not 0

; I assumed FmDefaultSize was a word constant, but actually it points to a byte value.
			Move.B		FmDefaultSize,D0		; get default size as byte value** <C440/19nov86/MBK> **
			Move.W		D0,stSize(A4) 			; store as word value			** <C440/19nov86/MBK> **

@8
; Don't allow the size to become 0 or be negative.
			Add.W		D5,D0					; add increment to size
			Bgt.S		@81						; size <-1 if it's 0 or negative

			Move.W		#1,D0					; minimum allowable

@81			Move.W		D0,stSize(A4)			; now store it

@9			Move.L		A4,A0					; point to relevent stuff
			Bsr			FindStyle				; look for this style
			Tst.L		D0						; do we have it already?
			Bne.S		@10						; guess so

			Move.L		A4,A0					; get ptr to new style
			Bsr.S		SetHiteAscent			; set line height and font ascent<C971/RWW102887>NO
			Move.W		#1,stCount(A0)			; will be used once to start
			Bsr			AddStyle				; and add it

@10			Move.W		D0,styleIndex(A2)		; store new style index

NoMatch		AddQ		#stStartSize,A2			; point to next style
			SubQ.W		#1,D2					; dec style counter
			Bne			styleLoop				; keep looping if not 0

			Move.L		teStylesH(A3),A0		; handle to style info
			_HUnlock

			Bsr			ConcatStyles			; watch out for adjoining styles
			Add.L		#stRecSize,SP			; restore stack

EndStyle	Rts


; ----------------------------------------------------------------------

; 			PROCEDURE SetHiteAscent

; 			Added 5/30/86 by MBK

; 			SetHiteAscent sets the line height and the font ascent based
; 			On the given style.

; 	Entry:
; 			A0:			ptr to style (preserved)
; 			A3:			TEHandle

; ----------------------------------------------------------------------
SetHiteAscent
			Move.L		D2,-(SP)				; save registers

; set my style just to get the info I need
			Move.L		teGrafPort(A3),A1		; the port
			Move.W		stFont(A0),txFont(A1)	; set font
			Move.W		stFace(A0),txFace(A1)	; set face
			Move.W		stSize(A0),txSize(A1)	; set size

; get the line height and font ascent
			Bsr			GetSize					; get ascent & hite		** <C207/10oct86/MBK> **

			Move.W		D0,stAscent(A0)		 	; save in ascent		** <C207/10oct86/MBK> **
			Move.W		D1,stHeight(A0)			; save in line height	** <C207/10oct86/MBK> **

			Move.L		(SP)+,D2				; restore registers

			Rts


; ----------------------------------------------------------------------

; 	AnyNullStyle
; 	<C971/RWW102387>

; 	Returns TRUE if a null style exists

; 	ENTRY:
; 			A3.L	=	TEPtr

; 	EXIT:
; 			A0.L	=>	null scrap record (hTE^^.nullStyle^^.nullScrap^)

; 	USES:
; 			A0.L

; ----------------------------------------------------------------------
AnyNullStyle
			Move.L		teStylesH(A3),A0		; => style record
			Move.L		(A0),A0
			Move.L		nullStyle(A0),A0		; => null style record
			Move.L		(A0),A0
			Move.L		nullScrap(A0),A0		; => null scrap record
			Move.L		(A0),A0
			Tst.W		scrpNStyles(A0)			; Assure null style exists
			Rts

; ----------------------------------------------------------------------

; 	GetTrueStyle
; 	<C971/RWW102387>

; 	Returns the style at the specified offset, whether from null style or
; 		inferred from current style.  Made subroutine because I needed
; 		similar result for iGetStylScrap.

; 	ENTRY:
; 			D0.W	=	offset into text record
; 			A3.L	=	TEPtr

; 	EXIT:
; 			A0.L	=>	STElement representing style

; 	USES:
; 			D0.W, A0.L

; ----------------------------------------------------------------------
GetTrueStyle
			Cmp.W		teSelStart(A3),D0		; start = offset, andÉ
			Bne.S		GetOneStyle
			Cmp.W		teSelEnd(A3),D0			; end = start?
			Bne.S		GetOneStyle

			Bsr.S		AnyNullStyle
			Bz.S		GetOneStyle				; None exists. Punt.

			; Yeah, this looks strange.  ScrpSTElements and STElements are _almost_
			;   the same, except that the first field of ScrpSTElement is a long instead
			; 	of a word.  Fake it as though A0 => STElement
			Lea			scrpStyleTab+2(A0),A0
			Rts

; ----------------------------------------------------------------------

; 	GetOneStyle
; 	<C971/RWW102387>

; 	Returns the style at the specified offset

; ----------------------------------------------------------------------
GetOneStyle
			Bsr			GetCurStyle				; get current style
			Move.W		styleIndex(A0),D0		; get style index
			Bsr			GetStyle				; now you have it

			Rts


; ----------------------------------------------------------------------

; 	PROCEDURE iTEGetStyle( offset: INTEGER; VAR Styl: StylePtr;
; 							VAR lineHite:INTEGER; VAR fontAscent:INTEGER;
; 							hTE: TEHandle );

; 	Returns the style _OF_THE_CHARACTER_ at the specified offset

; ----------------------------------------------------------------------

iTEGetStyle
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; if not, sorry, can't get it

			Move.L		(A2)+,-(SP)				; save ptr to font ascent
			Move.L		(A2)+,-(SP)				; save ptr to line height
			Move.L		(A2)+,-(SP)				; save style ptr

			Move.W		(A2),D0					; offset

			Bsr.S		GetOneStyle				; fetch inferred style				<C971/RWW102687>

			Move.L		(SP)+,A1				; point to styleRec

			Move.W		stFont(A0),(A1)+		; copy font
			Move.W		stFace(A0),(A1)+		; copy face
			Move.W		stSize(A0),(A1)+		; copy size
			Move.L		A0,A2					; save ptr					** <C182/6oct86/MBK> **
			Lea			stColor(A0),A0			; pt to color				** <C182/6oct86/MBK> **
			Move.W		(A0)+,(A1)+				; copy red					** <C182/6oct86/MBK> **
			Move.W		(A0)+,(A1)+				; copy green				** <C182/6oct86/MBK> **
			Move.W		(A0),(A1)				; copy blue					** <C182/6oct86/MBK> **

			Move.L		(SP)+,A1				; ptr to line height
			Move.W		stHeight(A2),(A1)		; store line height

			Move.L		(SP)+,A1				; ptr to font ascent
			Move.W		stAscent(A2),(A1)		; store font ascent
			Bra.S		@1

; ** <C139/10Sep86/MBK> ** Added this code to return GrafPort info for records without style.
@0			Bsr			GetSize					; get ascent & hite		** <C207/10oct86/MBK> **
			Move.L		(A2)+,A0				; ptr to ascent			** <C207/10oct86/MBK> **
			Move		D0,(A0)			 		; save in ascent		** <C207/10oct86/MBK> **
			Move.L		(A2)+,A0				; ptr to line height	** <C207/10oct86/MBK> **
			Move		D1,(A0)					; save in line height	** <C207/10oct86/MBK> **

			Move.L		(A2),A0					; ptr to style record
			Move.L		teGrafPort(A3),A1
			Move.W		txFont(A1),(A0)+		; copy font
			Move.W		txFace(A1),(A0)+
			Move.W		txSize(A1),(A0)+		; copy size
			Pea			0(A0)					; ptr to forecolor

;;	If forRAM THEN
	If (Not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; color QD around?					<C971/RWW112487>
			Bnz.S		@05						; nope								<C971/RWW112487>
			_GetForeColor						; 									<C971/RWW112487>
			Bra.S		@07						; 									<C971/RWW112487>
@05			Bsr			GetForeColor			; 									<C971/RWW112487>
@07
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb> 

			_GetForeColor						; for Ikki
	Else
			Bsr			GetForeColor			; for Alladin
	EndIf

@1			MoveQ		#20,D0
			Bra			StdExit2

; ------------------------------------------------
; SetStyle - sets the style pointed to by A0

; 	Entry:	A0	Pointer to styleStart (Preserved)

; ------------------------------------------------
SetStyle
			Move.L		A0,-(SP)

			Move.W		styleIndex(A0),D0		; get index to styleRec
			Bsr			GetStyle				; get the styleRec

			Move.L		teGrafPort(A3),A1		; get the Port

			Move.W		stFont(A0),txFont(A1)	; set font
			Move.W		stFace(A0),txFace(A1)	; set face
			Move.W		stSize(A0),txSize(A1)	; set size

;;	If forRAM THEN
	If (Not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; Becks or better?					<C971/RWW112487>
			Bnz.S		@1						; nope								<C971/RWW112487>
	EndIf

;;	If onNuMac|onMvMac|forRAM THEN					; <C914/29Oct87> rwh
	If hasCQD|(Not forROM) THEN					; <19Feb89smb>

		; Save D2 because the RGBForeColor trap destroys it.
		; Save the style ptr as an offset, since _RGBForeColor may shift memory.
			Move.L		teStylesH(A3),A1		; style handle			** <C717/28jan87/MBK> **
			Move.L		(A1),D0					; dereference			** <C717/28jan87/MBK> **
			Sub.L		D0,(SP)					; save as offset		** <C717/28jan87/MBK> **
			Move.W		D2,-(SP)				; save D2 for everybody	** <C574/30dec86/MBK> **
	EndIf

@1
			Pea			stColor(A0)				; point to fgColor		** <C182/6oct86/MBK> **

;;	If forRAM THEN
	If (Not forROM) THEN						; <19Feb89smb>
			BTst		#14,ROM85				; Becks or better?					<C971/RWW112487>
			Bnz.S		@2						; nope								<C971/RWW112487>
			_RGBForeColor						; 									<C971/RWW112487>
			Move.W		(SP)+,D2				; 									<C971/RWW112487>
			Move.L		teStylesH(A3),A1		; 									<C971/RWW112487>
			Move.L		(A1),D0					; 									<C971/RWW112487>
			Add.L		D0,(SP)					; 									<C971/RWW112487>
			Bra.S		@3						; 									<C971/RWW112487>
@2			Bsr			RGBForeColor			; 									<C971/RWW112487>
@3
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; <19Feb89smb>
			_RGBForeColor						; for Ikki				** <C182/06oct86/MBK> **
			Move.W		(SP)+,D2				; restore D2			** <C574/30dec86/MBK> **

			Move.L		teStylesH(A3),A1		; style handle			** <C717/28jan87/MBK> **
			Move.L		(A1),D0					; dereference			** <C717/28jan87/MBK> **
			Add.L		D0,(SP)					; restore as ptr		** <C717/28jan87/MBK> **
	Else
			Bsr			RGBForeColor			; for Alladin			** <C182/6oct86/MBK> **
	EndIf

			Move.L		(SP)+,A0

			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE ConcatStyles

; 			Added 6/12/86 by MBK

; 			ConcatStyles checks the entire runs array for adjoining
; 			identical styles, and concatenates any it finds.

; ----------------------------------------------------------------------
ConcatStyles
			MoveM.L		D2/A2,-(SP)				; save registers			** <C381/7nov86/MBK> **

			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A0					; dereference
			Move.L		styleTab(A0),A2			; handle to distinct styles	** <C381/7nov86/MBK> **
			Move.L		(A2),A2					; dereference				** <C381/7nov86/MBK> **
			Move.W		nRuns(A0),D0			; get # of style starts
			AddQ		#1,D0					; + dummy end index
			Lea			runs(A0),A0				; ptr to stStarts array
			Move.L		A0,A1					; copy it
			MoveQ		#0,D2					; repetition counter		** <C381/7nov86/MBK> **
			Move.W		styleIndex(A0),D1		; current index				** <C381/7nov86/MBK> **

; loop thru styles removing repetitious ones
@0			SubQ.W		#1,D0					; dec the count
			Beq.S		@2						; done, get out

			AddQ		#1,D2					; inc repetition counter	** <C381/7nov86/MBK> **
			AddQ.L		#stStartSize,A1			; point to next style
			Cmp.W		styleIndex(A1),D1		; are they the same?
			Beq.S		@0						; don't change ptrs if so

			SubQ		#1,D2					; dec repetition counter	** <C381/7nov86/MBK> **
			Beq.S		@1						; no repetitions			** <C381/7nov86/MBK> **

; ** <C381/7nov86/MBK> ** if any runs are merged, the stCount for that style must also be adjusted
			MulU		#stRecSize,D1			; * size of record			** <C381/7nov86/MBK> **
			Sub.W		D2,stCount(A2,D1.L)		; dec count					** <C381/7nov86/MBK> **
			MoveQ		#0,D2					; repetition counter		** <C381/7nov86/MBK> **

@1			AddQ.L		#stStartSize,A0			; now pt to next
			Move.L		startChar(A1),startChar(A0)	; move start and index
			Move.W		styleIndex(A0),D1		; current index				** <C381/7nov86/MBK> **
			Bra.S		@0

; shrink the handle to the style info
@2			Sub.L		A0,A1					; get amount that's redundant
			Move.L		A1,D0
			Move.L		teStylesH(A3),A0		; handle to style info
			Move.L		(A0),A1					; dereference
			AsR.L		#2,D0					; divide diff by 4
			Sub.W		D0,nRuns(A1)			; store new # of style starts

			MoveM.L		(SP)+,D2/A2				; restore registers			** <C381/7nov86/MBK> **
			Rts									; bye


; ----------------------------------------------------------------------

; 			PROCEDURE CheckMatch

; 			** Added 7/19/86 by MBK **

; 			CheckMatch checks to see if the input style record matches
; 			the style being sought by iTEReplaceStyle.  If so, a True flag
; 			is returned.  If the call was from iTESetStyle, True is auto-
; 			matically returned since the record does not have to match
; 			anything.

; 	Entry:
; 			A0:		ptr to style record
; 			A6:		ptr to style being searched for (0 if from iTESetStyle)
; 			D7:		replace mode

; 	Exit:
; 			D0:		flag = 1 if this style may be replaced

; ----------------------------------------------------------------------
CheckMatch
			MoveQ		#1,D0					; assume okay
			Cmp.L		#0,A6					; call from iTESetStyle?
			Beq.S		@5						; quit with true if so

; ** <C971/RWW102987>	Added code to support doToggle mode
; Specifically, A6 = -1 is used as a flag in iTESetStyle
			Cmp.L		#-1,A6					; ignore toggle mode, too			<C971/RWW102987>
			Beq.S		@5						; 									<C971/RWW102987>

			BTst		#fontBit,D7				; find font?
			Beq.S		@1

			Move.W		tsFont(A6),D1
			Cmp.W		stFont(A0),D1			; same as this style?
			Bne.S		@4						; stop comparing if not

@1			BTst		#faceBit,D7				; find face?
			Beq.S		@2

; ** <C971/RWW102787>	Faces are byte lengthÉ
			Move.B		tsFace(A6),D1			; 									<C971/RWW102787>
			Cmp.B		stFace(A0),D1			; same as this style?				<C971/RWW102787>
			Bne.S		@4						; stop comparing if not

@2			BTst		#sizeBit,D7				; find size?
			Beq.S		@3

			Move.W		tsSize(A6),D1
			Cmp.W		stSize(A0),D1			; same as this style?
			Bne.S		@4						; stop comparing if not

@3			BTst		#clrBit,D7				; find color?
			Beq.S		@5						; must have a match if still here

			Move.L		tsColor(A6),D1
			Cmp.L		stColor(A0),D1			; same as this style?
			Bne.S		@4						; red and green not same	** <C182/6oct86/MBK> **

			Move.W		tsColor+4(A6),D1		; get blue					** <C182/6oct86/MBK> **
			Cmp.W		stColor+4(A0),D1		; blues the same?			** <C182/6oct86/MBK> **
			Beq.S		@5

@4			MoveQ		#0,D0					; not a match

@5			Rts


; ----------------------------------------------------------------------

; 			PROCEDURE iTEReplaceStyle( ReplaceMode: INTEGER; Style1: STHandle;
; 									Style2: STHandle; redraw: BOOLEAN;
; 									hTE: TEHandle );

; 			** <C94/29jul86/MBK> **

; 			Replaces Style1 by Style2. If the mode is not doAll, the given
; 			characteristic will be replaced within all styles in which it's found.

; 			Supports the following modes:
; 			1	doFace:		replace Face only
; 			2	doSize:		replace Size only
; 			4	doFont:		replace Font only
; 			8	doColor:	replace Color only
; 			15	doAll:		replace all modes

; ----------------------------------------------------------------------

iTEReplaceStyle

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@1						; if not, sorry, can't set it

; ** <C381/6nov86/MBK> ** boolean value is in bit 1 of high byte
			Move.W		(A2)+,D0				; get redraw value			** <C381/6nov86/MBK> **
			And			#$FF00,D0				; check redraw value		** <C381/6nov86/MBK> **
			Bne.S		@0						; must redraw if set

			Bsr.S		ReplaceGuts				; else just add styles
			Bra.S		@1

@0			Move.L		A2,-(SP)				; save ptr to parameters

			Bsr			HideCaret
			Bsr			HiLite					; remove selection

			Move.L		(SP)+,A2				; restore ptr to parameters

			Bsr.S		ReplaceGuts				; do style munging

			MoveQ		#0,D7					; length is 0

			Bsr			RecalDraw				; redo the line stuff

			Bsr			ShowCaret
			Bsr			Hilite					; restore selection

			Bsr			SelView					; ensure selection is visible

@1			MoveQ		#18,D0
			Bra			stdExit2


; ----------------------------------------------------------------------

ReplaceGuts
			MoveM.L		D2-D7/A2/A4/A6,-(SP)	; save registers
			Move.L		(A2)+,A4				; replace style ptr
			Move.L		(A2)+,A6				; find style ptr
			Move.W		(A2)+,D7				; save mode here

			And.W		#doAll2,D7				; only the lower 5 bits make sense	<C971/RWW102987>

			Bsr			StyleGuts				; do style munging				<C971/RWW102887>NO

@0			MoveM.L		(SP)+,D2-D7/A2/A4/A6	; restore registers
			Rts


; ----------------------------------------------------------------------

; 			FUNCTION TEGetOffset( pt: Point; hTE: TEHandle): INTEGER;

; 			** <C94/29jul86/MBK> **

; 			Returns the offset into the text corresponding to the given point.

; ----------------------------------------------------------------------

TEGetOffset
			Bsr			StdEntry
			Move.L		teSelPoint(A3),-(SP)	; save selPoint

; Find the point and get char index of it in D6

			Move.L		(A2)+,teSelPoint(A3)	; pass selPoint
			Bsr			DoFind					; juggle dispStart/End and do find
			Move.W		D6,(A2)					; dispStart

			Move.L		(SP)+,teSelPoint(A3)	; restore selPoint
			Bra			Epilog8


; ----------------------------------------------------------------------

; 			FUNCTION	iGetStylHandle( hTE: TEHandle	): TEStylHandle;

; 			** <C94/29jul86/MBK> **

; 			Returns the style handle.

; ----------------------------------------------------------------------
iGetStylHandle
			Clr.L		(A2)					; init value to Nil

			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; if not, sorry, can't set it

			Move.L		teStylesH(A3),(A2)		; return the style handle

@0			MoveQ		#6,D0
			Bra			StdExit2


; ----------------------------------------------------------------------

; 			PROCEDURE iSetStylHandle (hST: TEStylHandle; hTE: TEHandle);

; 			** <C105/8aug86/MBK> **

; 			Sets the style handle.

; ----------------------------------------------------------------------
iSetStylHandle
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; if not, sorry, can't set it

; Dispose of old handle before replacing.
			Move.L		teStylesH(A3),A0		; get old handle
			_DisposHandle						; get rid of it

			Move.L		(A2),teStylesH(A3)		; set the style handle

@0			MoveQ		#10,D0
			Bra			StdExit2


;;	If onMacPP|onHcMac|forRAM THEN				; <C905/13oct87>
	If (Not hasCQD)|(Not forROM) THEN			; <19Feb89smb>

	
		; procedure RGBForeColor (Color : RGBColor);
	
		; 	This routine takes an RGB triple and sets the current Graf- or CGrafPort
		; 	fields so that drawing will take place with the best match of the
		; 	requested color, using the current GDevice's color matching rules.  The
		; 	appropriate fields are set depending on portType
	

RGBForeColor
			Move.L		4(SP),A1				; point at the RGB color

; convert RGB to old-style index value
; use high bit of each component to select RGB off (0) or on (1)
			MoveQ		#0,D1					; clear out D1
			Move		(A1)+,D1				; get red
			LsL.L		#1,D1					; get high bit
			Move		(A1)+,D1				; get green
			LsL.L		#1,D1					; get high bit
			Move		(A1)+,D1				; get blue
			LsL.L		#1,D1					; get high bit
			Swap		D1						; get RGB index

			Lea			MapTbl,A0				; get translate table
			MoveQ		#0,D0					; clear out high word
			LsL.W		#1,D1					; word index
			Move		0(A0,D1),D0				; convert to planar value

			Move.L		GrafGlobals(A5),A0		; get the QuickDraw globals pointer
			Move.L		thePort(A0),A0			; point at the port
			Move.L		D0,fgColor(A0)			; and set the index field
			Move.L		(SP)+,A0				; get the return address
			AddQ		#4,SP					; get rid of the parameter
			Jmp			(A0)					; and return

; TABLE TO MAP FROM 3 BIT RGB TO OLD-STYLE COLOR INDICES
MapTBL		DC.W		$21						; RBG = 0,0,0 -> black
			DC.W		$199					; RBG = 0,0,1 -> blue
			DC.W		$155					; RBG = 0,1,0 -> green
			DC.W		$111					; RBG = 0,1,1 -> cyan
			DC.W		$CD						; RBG = 1,0,0 -> red
			DC.W		$89						; RBG = 1,0,1 -> magenta
			DC.W		$45						; RBG = 1,1,0 -> yellow
			DC.W		$1E						; RBG = 1,1,1 -> white

	
		; PROCEDURE GetForeColor (VAR Color: RGBColor);
	
		; Return the RGB components of the current foreground color
		; Works for old and new ports.

GetForeColor
			Move.L		4(SP),A1				; point at the RGB color
			Move.L		GrafGlobals(A5),A0		; get the QuickDraw globals pointer
			Move.L		thePort(A0),A0			; point at the port

; Use CMYB bits in color to derive proper RGB components

			Move.L		fgColor(A0),D0			; get planar color from port
			BTst		#5,D0					; test black bit
			Beq.S		notBlack				; => color isn't not black
			Or.W		#$01C0,D0				; else set CMY = 111 for black
notBlack	LsR.W		#1,D0					; xxxC MYBR GBwb -> CMYx xxxx

			MoveQ		#2,D1					; process 3 bits
nxtBit		Clr.W		(A1)					; assume component is 0
			LsL.B		#1,D0					; check next component
			Blo.S		cmpOK					; => if bit set, component clear
			Not.W		(A1)					; else component = $FFFF
cmpOK		AddQ		#2,A1					; advance to next component
			DBra		D1,nxtBit				; repeat for all components

			Move.L		(SP)+,A0				; get the return address
			AddQ		#4,SP					; get rid of the parameter
			Jmp			(A0)					; and return

	EndIf


; ----------------------------------------------------------------------

; 	FUNCTION iTEGetPoint( offset: INTEGER; hTE: TEHandle): Point;

; 	** <23jan87/MBK> **

; 	Returns the point corresponding to the given offset into the text.

; ----------------------------------------------------------------------

iTEGetPoint
			Move.W		(A2)+,D0				; get the offset
			Move.L		A2,-(SP)				; preserve parameter ptr
			Move.W		D0,-(SP)				; preserve offset
			Cmp.W		teLength(A3),D0			; pin it to the length
			Blo.S		@0						; ok if less or same

			Move.W		teLength(A3),D0			; else pin to end
			Move.W		D0,(SP)					; replace offset
			SubQ		#1,D0					; just for GetLine

@0			Lea			teLines(A3),A2			; pt to start of array
			Bsr			GetLine					; get ptr to line it's on

; LineRect expects to be called from RecalLines, which has its own frame.  It saves
; a value off of A6, which in this case destroys the savePort value on the stdEntry frame.
; So save and restore the value that will be overwritten.

			Move.W		saveJust(A6),-(SP)		; LineRect will write something here
			Bsr			LineRect				; sets up selRect from destRect and justification
			Move.W		(SP)+,saveJust(A6)		; restore port
			Move.W		(A2),D6					; start of line
			Move.W		(SP)+,D7				; offset to measure to

; If the last char is a CR, the h coord should be at the beginning of the next line after the CR
; (the v coord was correct, but the h was at the point preceding the CR on the previous line).
			Cmp.W		teLength(A3),D7			; is offset = text length?
			Bne.S		@2						; skip CR test if not
			Move.L		teTextH(A3),A0
			Move.L		(A0),A0
			Cmp.B		#$0D,-1(A0,D7)			; if last char = CR then...
			Bne.S		@2

; assume left justification
			Move.W		teSelRect+left(A3),D0
			Move.W		teJust(A3),D1
			Bne.S		@1
			Move.W		teSysJust,D1
			Beq.S		@3
			Cmp.W		#teForceLeft,D1
			Beq.S		@3
@1
; right or center justification
			Move.W		teDestRect+right(A3),D0
			SubQ		#1,D0
			Tst.W		D1
			Bmi.S		@3

; center justification (divide width by 2)
			Sub.W		teDestRect+left(A3),D0
			AsR			#1,D0
			Add.W		teDestRect+left(A3),D0
			Bra.S		@3
@2
			Bsr			MeasureIt				; measure with style
			Add.W		teSelRect+left(A3),D0	; add in justification
@3
			Move.L		(SP)+,A2				; restore parameter ptr
			Move.W		teSelRect+bottom(A3),(A2)+	; return v coord
			Move.W		D0,(A2)					; return h coord

			MoveQ		#8,D0
			Bra			StdExit2


; ----------------------------------------------------------------------

; 	FUNCTION iGetStylScrap( hTE: TEHandle): StScrpHandle;

; 	** <23jan87/MBK> **

; 	Gets the style information corresponding to the current selection and
; 	returns a handle to it, stored in the same format as the 'styl' block.

; ----------------------------------------------------------------------

iGetStylScrap
			Clr.L		(A2)					; init value to Nil
			Tst.W		teSize(A3)				; is it a new TERec?
			Bpl.S		EndGet					; quit if not

			Move.W 		teSelStart(A3),D0		; get selstart, selEnd
			Move.W		teSelEnd(A3),D1			; selEnd in D1
			Cmp.W		D0,D1					; compare start to end

; Return true style at selection, whether inferred or stated in NullStRec
			Bne.S		@05						; selection - get it				<C971/RWW102387>

			Move.L		#scrpRecSize+2,D0		; size of total scrap style rec		<C971/RWW102387>
			Bsr			MyNewHandle				; temp handle for style scrap		<C971/RWW102387>
			Move.L		A0,(A2)					; report back with scrap handle		<C971/RWW102387>
			Move.L		(A0),A1					; save as destptr					<C971/RWW102387>
			Move.W		#1,(A1)+				; one style total					<C971/RWW102387>
			Clr.L		(A1)+					; scrpStartChar := 0				<C971/RWW102387>

			Move.W		teSelStart(A3),D0		; get offset						<C971/RWW102387>
			Bsr			GetTrueStyle			; Get style record					<C971/RWW102387>
			Lea			2(A0),A0				; skip over stCount to stHeight		<C971/RWW102387>

			Move.L		#scrpRecSize-4,D0		; amount to copy					<C971/RWW102387>
			_BlockMove							; from NullStRec to StScrpRec		<C971/RWW102387>
			Bra.S		EndGet					; we're outta here					<C971/RWW102387>
@05												; 									<C971/RWW102387>

			Bhs.S		@0						; ok if end >= start
			Exg			D0,D1					; else swap start and end

@0			MoveM.L		D2-D5/A2/A5,-(SP)		; save stuff
			Bsr			CopyGuts				; go to create 'styl' handle
			MoveM.L		(SP)+,D2-D5/A2/A5		; restore stuff
			Move.L		A4,(A2)					; return 'styl' handle

EndGet		MoveQ		#6,D0
			Bra			StdExit2


; ----------------------------------------------------------------------

; 			PROCEDURE iSetStylScrap(rangeStart, rangeEnd: LONGINT; newStyles: StScrpHandle;
; 									redraw: BOOLEAN; hTE: TEHandle);
; 			** <C971/RWW102887> **

; 			This procedure is the logical opposite of iGetStylScrap.  It
; 				takes a handle to a style scrap record and applies it
; 				over the given range.  iSetStylScrap does not affect the
; 				range of the current selection.  If newStyles is NIL or
; 				if the edit record was not created with TEStylNew, this
; 				procedure has no effect.
; 			It is easily possible for the range to be out of sync with
; 				with the scrap record.  In either case, as soon as a
; 				boundary is reached, this procedure is terminated without
; 				a specific error condition.

; ----------------------------------------------------------------------
iSetStylScrap
			Tst.W		teSize(A3)				; don't do anything if not styled
			Bpl			@xit

			Move.W		(A2)+,D5				; get redraw byte					<C971/RWW111787>
			And.W		#$FF00,D5				; boolean is bit 1 of high byte		<C971/RWW111787>
			Sne			D5						; D5 non-zero if we want to redraw	<C971/RWW111787>
			Beq.S		@03						; we don't, so skip hiliting		<C971/RWW111787>

			Bsr			HideCaret				; remove hiliting
			Bsr			Hilite

@03
			Move.L		(A2)+,A1				; fetch scrap handle
; <17May89smb> must lock the handle before using it
			move.l		a1,-(sp)				; save for restoring flags <17May89smb>
			Move.l		a1,a0					; handle to style scrap <17May89smb>
			_HGetState
			move.b		d0,-(sp)				; save state flags for handle <17May89smb>
			move.l		a1,a0					; get handle again for lock <17May89smb>
			_HLock								; <17May89smb>
			Move.L		(A1),A1					; point at scrap record proper
			Move.L		(A2)+,D7				; fetch end
			Move.L		(A2),D6					; fetch start

			Cmp.L		D6,D7					; sort start/end
			Bhs.S		@05						; end is higher or same, so okay

			Exg			D6,D7					; we want start in D6

@05			MoveQ		#0,D0					; make long for comparisons
			Move.W		teLength(A3),D0
			Cmp.L		D0,D6					; pin start to end of record
			Bls.S		@07

			Move.L		D0,D6

@07			Cmp.L		D0,D7					; pin end to end of record
			Bls.S		@09

			Move.L		D0,D7

@09			Move.L		D6,D3					; make a working copy

			Move.L		teSelStart(A3),-(SP)	; save original start/end

			Move.W		(A1)+,D4				; number of styles to do
			Bra.S		@loop


@1			Cmp.L		D3,D7					; break out if start >= range end
			Bls.S		@done

			Move.W		D3,teSelStart(A3)		; save end as new start
			Tst.W		D4						; is this the last scrap entry?
			Bnz.S		@2						; no, calc end from table

			Move.L		D7,D0					; ran off end of table, so force end
			Bra.S		@3

@2			Move.L		D6,D0					; calc end of selection
			Add.L		scrpRecSize+scrpStartChar(A1),D0
			Cmp.L		D7,D0					; pin end to range end
			Bls.S		@4

@3			Move.L		D7,D0

@4			Move.W		D0,teSelEnd(A3)			; and save as new end
			Move.L		D0,D3					; (save end as next new start)

			MoveM.L		D3-D7/A1/A4/A6,-(SP)	; 									<C971/RWW111787>

			Move.W		teSelStart(A3),D0		; fetch start of style				<C971/RWW111787>
			Bsr			GetOneStyle				; point at style to copy over		<C971/RWW111787>
			Lea			stFont(A0),A6			; iTEReplaceStyle expects it in A6	<C971/RWW111787>
			Lea			scrpFont(A1),A4			; point at style to set				<C971/RWW111787>
			Move.W		#doAll,D7				; replace everything				<C971/RWW111787>
			Bsr			StyleGuts				; go replace it						<C971/RWW111787>

			MoveM.L		(SP)+,D3-D7/A1/A4/A6	; 									<C971/RWW111787>

			Add			#scrpRecSize,A1			; bump pointer to next scrap entry	<C971/RWW111787>

@loop		DBra		D4,@1


@done
			Move.L		(SP)+,teSelStart(A3)	; restore previous select/end
			move.b		(sp)+,d0				; state flags for style scrap handle <17May89smb>
			move.l		(sp)+,a0				; handle to reset <17May89smb>
			_HSetState							; <17May89smb>

			Tst.B		D5						; are we redrawing?					<C971/RWW111787>
			Beq.S		@xit					; nope, dump out					<C971/RWW111787>

			MoveQ		#0,D7					; no change in lineStarts array
			Bsr			RecalDraw
			Bsr			ShowCaret
			Bsr			Hilite
			Bsr			SelView					; ensure selection is visible		<C971/RWW111787>

@xit		MoveQ		#20,D0
			Bra			StdExit2

; ----------------------------------------------------------------------

; 			PROCEDURE iTEStylInsert( pText: Ptr; l: LONGINT; hST: StScrpHandle;
; 									hTE: TEHandle );

; 			This inserts the passed text/length and the associated styles
; 			specified in the StScrpHandle just before the selection
; 			but doesn't touch the scrap.  The selection too is "untouched"
; 			because it is offset by the inserted amount to point to the same
; 			range.  Just after a TEStylNew this can be used as a replacement
; 			for the old TESetText because the selection and length are all zero.

; 			** <C734/30jan87/MBK> ** Replaced PutStylScrap by iTEStylInsert.
; 			iTEStylInsert is exactly the same as TEInsert if the TERec is not
; 			a style record, or if a NIL style handle is passed in.  Otherwise,
; 			iTEStylInsert inserts the input style information along with the
; 			text.

; 			** <C788/11feb87/mbk> ** A2 points to the style handle when we
; 			1st enter here.   Before I was getting it after the text and length.
; ----------------------------------------------------------------------
iTEStylInsert
; ** <C766/10feb87/MBK> ** Removed call to StdEntry because TEDispatch does it.
			Bsr			HideCaret				; 								<C971/RWW102887>NO
			Bsr			HiLite					; remove selection				<C971/RWW102887>NO

			Move.L		(A2)+,D0				; get style handle			** <C788/11feb87/mbk> **
			MoveQ		#0,D7					; delta = 0(No deletion)
			MoveM.L 	(A2)+,D5-D6 			; A2 points to l param

; ** <C971/RWW101987>	If length is 0, punt
			Tst.L		D5						; length?							<C971/RWW101987>
			Bz.S		@15						; Nope, so leave					<C971/RWW101987>

			Tst.L		D0						; check if handle is NIL	** <C788/11feb87/mbk> **
			Beq.S		@0						; can't insert styles if NIL

			Move.L		D0,A2					; save style handle in A2	** <C788/11feb87/mbk> **
			Tst.W		teSize(A3)				; check style flag
			Bpl.S		@0						; just insert text if not a style record

			Bsr 		MungeSetup				; setup for the insert
			Clr.L		-(SP)					; fake l1
			Move.L		D6,-(SP)				; pointer to insert = p2
			Move.L		D5,-(SP)				; length to insert = l2
			_Munger 							; use sloppy munger
			AddQ.L		#4,SP					; pop result
			Add 		D5,teLength(A3) 		; adjust length by insert amount

			Move.L		teTextH(A3),A0			; get text handle
			_Hlock								; and relock it

			Move.L		A2,A0					; get style handle			** <C788/11feb87/mbk> **
			_HGetState							; get the style handle's tag
			Move.B		D0,-(SP)				; and save the flags
			_HLock								; and lock it

			MoveM.L		D2-D6/A2/A4,-(SP)		; save stuff
			Move.L		A2,A4					; style handle in A4		** <C788/11feb87/mbk> **

; ** <C851/23Apr87/MBK> ** High word of D3 must be clear for PstStylGuts
			MoveQ		#0,D3					; clear whole register

			Move.W		teSelStart(A3),D3		; selection start
			Bsr			PstStylGuts				; go do the style paste
			MoveM.L		(SP)+,D2-D6/A2/A4		; restore stuff

			Move.B		(SP)+,D0				; get the flags
			Move.L		A2,A0					; get style handle			** <C788/11feb87/mbk> **
			_HSetState							; set the style handle's tag

			Sub 		D5,D7					; adjust delta amount for ReCalLines
			Bra.S		@1						; go recal

@0			Bsr			insGuts 				; go insert the text			<C971/RWW102887>NO

@1			Bsr 		RecalDraw				; redo the line stuff
			Add 		D5,teSelStart(A3)		; selStart:=selstart + insert amount
			Add 		D5,teSelEnd(A3) 		; selEnd:=selEnd + insert amount

@15												; 									<C971/RWW101987>
			Bsr 		ShowCaret
			Bsr			HiLite					; restore selection				<C971/RWW102887>NO
			MoveQ		#18,D0					; # of bytes on stack
			Bra 		StdExit2				; 	to be removed before exit


; ----------------------------------------------------------------------

; 			FUNCTION iTEGetHeight (endLine, startLine : LONGINT; hTE: TEHandle): LONGINT;

; 			** Rewritten <C971/RWW102387>  **

; 			Gets the total line height of the document.
; 			Now properly sorts endLine and startLine so doesn't need special glue.

; ----------------------------------------------------------------------
iTEGetHeight
			MoveM.L		(A2)+,D0-D1				; 1st line
			Cmp.L		D0,D1					; Which is larger?
			Bhs.S		@05						; D1 is, so okay

			Exg.L		D0,D1					; Assure endLine in D1

@05			Tst.L		D0						; is it 0?
			Bnz.S		@0

			MoveQ		#1,D0					; minimum line #

@0			SubQ.L		#1,D0					; make it 0-based

			Tst.L		D1						; is it 0?
			Bnz.S		@1

			MoveQ		#1,D1					; minimum line #

@1			MoveQ		#0,D2					; clear D2 long
			Move.W		teNLines(A3),D2			; last line

			Bne.S		@15						; At least one line!			<S443/RWW032588>
			MoveQ		#1,D2					; 								<S443/RWW032588>
@15												; 								<S443/RWW032588>

			Cmp.L		D2,D0					; pin to last line
			Bls.S		@2						; okay if less or same

			Move.L		D2,D0					; else set to max line

@2			Cmp.L		D2,D1					; pin to last line
			Bls.S		@3						; okay if less or same

			Move.L		D2,D1					; else set to max line

@3			Bsr			GetLineHites			; get total height
			Move.L		D0,(A2)					; return total height

			MoveQ		#14,D0					; # of bytes on stack
			Bra			StdExit2				; 	to be removed before exit


; ----------------------------------------------------------------------

; 			PROCEDURE iTECustomHook(which: TEHook; VAR addr: ProcPtr;
; 									hTE: TEHandle);
; 			** <C971/RWW110487> **

; 			This procedure sets the various internal dispatch table
; 				addresses, returning the previous contents in addr.

; ----------------------------------------------------------------------
iTECustomHook
			Move.L		(A2)+,A1				; fetch pointer to new address
			Move.W		(A2),D0					; fetch selector
			LsL.W		#2,D0					; * 4 for long offset
			Move.L		teDispatchH(A3),A0		; get handle to hooks
			Move.L		(A0),A0					; point at table
;;			Add.L		D0,A0					; add in offset <16May89smb>
			Add.w		D0,A0					; add in offset <16May89smb>: changed to word op.
			Move.L		(A0),D0					; fetch old vector
			Move.L		(A1),(A0)				; and store away the new one
			Move.L		D0,(A1)

@xit		MoveQ		#12,D0					; # of bytes on stack
			Bra			StdExit2				; 	to be removed before exit


; ----------------------------------------------------------------------

; 			FUNCTION  iTENumStyles(rangeStart, rangeEnd: LONGINT;
; 									 hTE: TEHandle): LONGINT;
; 			** <C971/RWW111887> **

; 			This function returns the number of style changes across
; 				a given range.

; ----------------------------------------------------------------------
iTENumStyles
			Move.L		(A2)+,D1				; get end of range
			Move.L		(A2)+,D0				; get start of range

			Cmp.L		D0,D1					; Which is larger?
			Bhi.S		@1						; D1 is, so okay
			Beq.S		@3						; (special case when both same)

			Exg.L		D0,D1					; Assure endLine in D1

@1			Tst.W		teSize(A3)				; if it is an old TERec
			Bmi.S		@2

@3			MoveQ		#1,D0					; signify one style exists
			Bra.S		@xit

@2			Clr.L		D2						; pin rangeEnd to selEnd			<C971/RWW111987>
			Move.W		teSelEnd(A3),D2			; 									<C971/RWW111987>
			Cmp.L		D2,D1					; 									<C971/RWW111987>
			Bls.S		@4						; 									<C971/RWW111987>

			Move.L		D2,D1					; rangeEnd was larger, force selEnd	<C971/RWW111987>

@4			Bsr			GetCurStyle
			Bsr			GetNumStyles

@xit		Move.L		D0,(A2)					; store away result
			MoveQ		#14,D0
			Bra			StdExit2


; ----------------------------------------------------------------------

; 			FUNCTION  iTEContinuousStyle(VAR mode: INTEGER; VAR aStyle: TextStyle;
; 										hTE: TEHandle): BOOLEAN;
; 			** <C971/RWW102687> **

; 			This function gives you information about the continuity of
; 				various aspects of the current selection.  The result
; 				returned is TRUE if the given style exists across the
; 				entire selection range.  The style attributes to check
; 				are specified by the mode parameter, which takes the
; 				same values as in iTESetStyle.  Attributes which are
; 				continuous across the current selection range are
; 				returned in aStyle, with the appropriate bits set in
; 				mode.  If the selection range is an insertion point,
; 				this call duplicates iTEGetStyle, except that the returned
; 				style reflects the style of the _next_character_typed_.
; 			The attribute bits of aStyle.tsFace are individually
; 				checked across the selection range, and are returned set
; 				to 1 if that attribute is indeed continuous.

; ----------------------------------------------------------------------
iTEContinuousStyle
			Tst.W		teSize(A3)				; is it a new TERec?
			Bmi.S		@1						; yes it is, continue

			Move.L		(A2),A0
			Move.L		teGrafPort(A3),A1
			Move.L		txFont(A1),(A0)+		; copy font/face
			Move.W		txSize(A1),(A0)+		; copy size
			Pea			0(A0)					; ptr to forecolor
;;	If forRAM THEN
	If (Not forROM) THEN						; 19Feb89smb>
			BTst		#14,ROM85				; Becks or better?					<C971/RWW112487>
			Bnz.S		@2						; nope								<C971/RWW112487>
			_GetForeColor						; 									<C971/RWW112487>
			Bra.S		@3						; 									<C971/RWW112487>
@2			Bsr			GetForeColor			; 									<C971/RWW112487>
@3
;;	ElseIf onNuMac|onMvMac THEN					; <C914/29Oct87> rwh
	ElseIf hasCQD THEN							; 19Feb89smb>
			_GetForeColor						; for Mac II
	Else
			Bsr			GetForeColor			; for all others
	EndIf
			ST			8(A2)					; only one style, so everything's continuous
			Bra.S		@xit

@1			Bsr.S		ContGuts

@xit		MoveQ		#14,D0
			Bra			StdExit2


; ----------------------------------------------------------------------

; 	ContGuts
; 	<C971/RWW102687>
; 	<S425/RWW031688>	Rewrote according to suggestions from DTS.  Now no face information
; 					needs to be passed in.  If ANY face information is continuous across
; 					the selection, doFace is returned TRUE if it was requested.
; 					Seems this is a more required case than the original allowed for,
; 					(and besides, it is a helluva lot easier case to code for)

; 	Does actual work of iTEContinuousStyle

; ----------------------------------------------------------------------
contArgs	Record		0
contStyle	Ds.L		1
contMode	Ds.L		1
contResult	Ds.B		1
			EndR

ContGuts
			With		contArgs

			MoveM.L		D3-D7/A4,-(SP)			; save working registers

			Move.W		teSelStart(A3),D0		; insertion point gets handled differently
			Cmp.W		teSelEnd(A3),D0
			Seq			D5						; show as an insertion point
			Bne.S		@1

			Bsr			AnyNullStyle			; use null style if available
			Bnz.S		@1

			Tst.W		D0						; otherwise, we want style of characterÉ
			Bz.S		@1						; Éjust _before_ insert point

			SubQ.W		#1,D0					; (exception is top of record, obviously)

@1			Bsr			GetTrueStyle

			Move.L		contStyle(A2),A1		; point at receiving record

			Move.L		stFont(A0),tsFont(A1)	; move TextStyle
			Move.L		stSize(A0),tsSize(A1)
			Move.L		stColor+2(A0),tsColor+2(A1)

; aStyle is primed with the style of the selection start.  Find the StyleRun that
; 	determines the selection start and walk through the style changes, noting differences

			Move.B		stFace(A0),D7			; save start face for compare later	<S425/RWW031688>
			Move.B		D7,D6					; make a working copy

			Move.L		contMode(A2),A0			; point at mode
			Move.W		(A0),D0					; save mode for comparison later
			And.W		#$000F,D0				; only low 4 bits make any sense
			Move.W		D0,D4					; D4 = working register				<S425/RWW031688>
			Move.W		D0,D3					; D3 = original request				<S425/RWW031688>

			Tst.B		D5						; insertion point?
			Bnz			@goodxit				; yes, so no need to consult style entries <S425/RWW031688>

			Move.W		teSelStart(A3),D0		; get selection start
			Bsr			GetCurStyle				; get the current StyleRun
			Move.L		A0,A4					; (we don't need the TEHandleÉ)

@loop		AddQ		#stStartSize,A4			; actually, we want the next one

			Tst.W		D4						; if we've reset all bitsÉ
			Bz.S		@2						; Éit's senseless to go on

			Move.W		startChar(A4),D0		; if negative, we're off end of table
			Bmi.S		@2

			Cmp.W		teSelEnd(A3),D0			; if past end of selection, we're done
			Bhs.S		@2

			Move.W		styleIndex(A4),D0		; get index into style table
			Bsr			GetStyle				; go get it

; In order for this to work, neither GetCurStyle nor GetStyle can mess with A1!!!!!É
			BTst		#fontBit,D4				; check font?
			Bz.S		@3

			Move.W		tsFont(A1),D0
			Cmp.W		stFont(A0),D0			; do fonts match?
			Beq.S		@3						; yes, go on

			BClr		#fontBit,D4				; don't need to check it anymore

@3			BTst		#sizeBit,D4				; check size?
			Bz.S		@4

			Move.W		tsSize(A1),D0
			Cmp.W		stSize(A0),D0			; do sizes match?
			Beq.S		@4						; yes, go on

			BClr		#sizeBit,D4				; don't need to check it anymore

@4			BTst		#clrBit,D4				; check color?
			Bz.S		@5

			Move.L		tsColor(A1),D0
			Cmp.L		stColor(A0),D0			; do red/green match?
			Bne.S		@6						; no, reset bit
			Move.W		tsColor+4(A1),D0
			Cmp.W		stColor+4(A0),D0		; does blue match?
			Beq.S		@5

@6			BClr		#clrBit,D4				; don't need to check it anymore

; Comparing faces is a bit tricky.  If we started out plain, merge in style bits.
; 	Otherwise, calculate intersection of bit sets
@5			BTst		#faceBit,D4				; check face?
			Bz.S		@loop

			Tst.B		D7						; did we start out with plain style?
			Bnz.S		@8

			Or.B		stFace(A0),D6			; Don't fall through anymore		<S488/RWW050388>
			Bra.S		@loop					; 									<S488/RWW050388>

@8			And.B		stFace(A0),D6
			Bra.S		@loop



; We come here when we're done perusing the selection range.
; 	Now, we have to resolve the doFace bit.  This is all complicated by the fact that
; 	ÒplainÓ isn't a style attribute, but rather a lack of other styles.
@2			BTst		#faceBit,D4				; check face?
			Bz.S		@xit					; nope, skip resolution

; <S425/RWW031688>	All this is new, for new handling of face information
			Tst.B		D7						; did we start out with plain?		<S425/RWW031688>
			Bnz.S		@notPlain				; nope, go on						<S425/RWW031688>
			
			Tst.B		D6						; if ended with plain, hunky dory	<S425/RWW031688>
			Bz.S		@goodxit				; save result and exit				<S425/RWW031688>
			
@badxit		BClr		#faceBit,D4				; no good.  reset bit				<S425/RWW031688>
			Bra.S		@xit					; Éand leave						<S425/RWW031688>

@notPlain	Tst.B		D6						; end with any intersection?		<S425/RWW031688>
			Bz.S		@badxit					; nope, so nothing was continuous	<S425/RWW031688>

@goodxit	Move.B		D6,tsFace(A1)			; save intersection to aStyle		<S425/RWW031688>

@xit		Move.L		contMode(A2),A0			; Point at mode
			Move.W		D4,(A0)					; save intersection back to mode

			Cmp.W		D4,D3					; Was everything continuous?		<S425/RWW031688>

			Seq			D0						; TRUE if everything was equal		<S425/RWW031688>
			Neg.B		D0						; Blaise wants false=0 and true=1	<C971/RWW111687>
			Move.B		D0,contResult(A2)		; Blaise wants false=0 and true=1	<C971/RWW111687>
			MoveM.L		(SP)+,D3-D7/A4			; Retrieve working registers
			Rts

			EndWith		; contArgs


; *************************************************************************************************
; *************************************************************************************************
; *************************************************************************************************

; TextEdit end