mirror of
https://github.com/elliotnunn/sys7.1-doc-wip.git
synced 2024-06-12 14:29:29 +00:00
4850 lines
177 KiB
Plaintext
4850 lines
177 KiB
Plaintext
;
|
||
; File: WindowMgr.a
|
||
;
|
||
; Contains: Window Manager for MacIntosh User Interface ToolBox
|
||
;
|
||
; Written by: Andy Hertzfeld May 23, 1982
|
||
;
|
||
; Copyright: © 1982-1993 by Apple Computer, Inc. All rights reserved.
|
||
;
|
||
; Change History (most recent first):
|
||
;
|
||
; <SM40> 9/30/93 IH Change hasDisplayMgr feature to hasDisplayMgrWindows. This
|
||
; allows me to build the display manager in the gibbly without
|
||
; patching out the window manager on PDM.
|
||
; <SM39> 9/9/93 SAM w/jdr Saved D1 thru a call to CopyRgn in DragTheRgn. Bad Ernie.
|
||
; <SM38> 9/2/93 SKH The gray region was not being set up correctly for non-rounded GDevices
|
||
; <SM37> 6/22/93 kc Check window title handle before dereferencing it in GetWTitle.
|
||
; <SM36> 6/17/93 KW (LW11 fau) In the dragThumb routine, check to see if the
|
||
; emControlHandle is nil, and if so, do the normal case where we
|
||
; use Paintrgn. (LW10 fau) Cleaned up the use of DragFlag to
|
||
; always set and test a word.
|
||
; <SM34> 6/14/93 kc Roll in Ludwig.
|
||
; <LW6> 5/3/93 chp Flush the caches for WDEF handles smaller than 32 bytes. It used
|
||
; to be 16 bytes, but a 22-byte, unflushed, fake defproc has been
|
||
; discovered in Software Ventures Microphone II and Microphone
|
||
; Pro. (RADAR #1082386)
|
||
; <LW4> 3/8/93 fau In the CallWindow routine, flushed the cache if the WDEF handle
|
||
; is less or equal to 16 bytes. In previous ROMS, HLock was doing
|
||
; the cache flush, but SM Roms don't do that anymore. See the
|
||
; comment for more details.
|
||
; <SM34> 6/7/93 CSS Per Shannon Holland, fix another problem if the scroll bar was
|
||
; unable to get the colors it needed to draw the shaded colors on
|
||
; color monitor.
|
||
; <SM33> 6/3/93 CSS Per Shannon Holland and KON, change the pattern to black when we
|
||
; do our special thumb dragging routine. This fixes a bug in PDM.
|
||
; <SM32> 5/17/93 CSS Per code review with Mark Law and Kevin Williams of Cyclone:
|
||
; change test for whether we changed ports to WMgrCPort from a
|
||
; test of PortOffset (the failure case would be if local 0,0 is
|
||
; ever equal to global 0,0 which is possible even though unlikely)
|
||
; to testing if the port is color again.
|
||
; <SM31> 5/5/93 CSS Make sure that the clip is wide open when we use the wmgrcport
|
||
; when dragging the thumb.
|
||
; <SM30> 5/5/93 CSS Dean fixed a problem with <SM29> not working properly when
|
||
; drawing in black&white ports. Also, I cleaned up some of the
|
||
; code.
|
||
; <SM29> 4/30/93 CSS Make _DragTheRgn drag a black box when we are dragging a scroll
|
||
; bar thumb. We tell this by using the DragFlag. So, we must be
|
||
; careful about clearing this flag after we are done with it. The
|
||
; clear state (DragFlag=0) is the original behavior of _DragTheRgn
|
||
; <SM28> 4/8/93 IH Touch file to force rebuild because default state of
|
||
; hasDisplayMgr flag is changing for RISC builds. Display Manager
|
||
; will not initialize properly without recompiling this file.
|
||
; <SM27> 3/31/93 IH Use Display Manager to Draw Desktop if hasDisplayMgr is true.
|
||
; <SM26> 2/4/93 CSS Rollin Horror (WindowMgrPatch.a). Comments follow:
|
||
; <H5> 7/8/92 SWC Fixed a bug in InitWindowFramePatch that would cause it to fall
|
||
; thru to the ‘normal’ code even in the LCD case.
|
||
; <H4> 01/27/92 jmp Removed the BoxFlag dependencies in these patches, and padded to
|
||
; match the TERROR/Zydeco ROM map.
|
||
; <H3> 1/14/92 SWC Added DB-Lite LC to the list of LCD screen machines. Changed
|
||
; boxTIM and boxTIMLC to boxPowerBook170 and boxPowerBook140.
|
||
; <H2> 10/29/91 jmp Did a quick-and-dirty update to the InitWindowsFrame and
|
||
; InitWindowsRgn patches to support DB-Lites. These routines need
|
||
; to be cleaned up soon.
|
||
; <SM25> 1/13/93 kc Change BSR's to JSR's to appease the Linker gods.
|
||
; <SM24> 12/10/92 HI Modified CallWindow to save the A4 register for those WDEF's
|
||
; which trash it (specifically Dreams 1.1). (Hoon Im)
|
||
; <SM23> 12/09/92 HI Modified DragTheRgn to set/clear the emIsDragging field of
|
||
; ExpandMem upon entry/exit. This allows OSEventAvail to determine
|
||
; whether to execute the HelpMgr patch code or bypass it. The
|
||
; HelpMgr patch code causes the HelpMgr to remove/show balloons
|
||
; which trash the clipRgn, penPat, and penMode of WMgrPort; then,
|
||
; DragTheRgn canNOT properly remove the drag region. Bypassing the
|
||
; HelpMgr patch code solves this problem and IT IS supposed to
|
||
; behave this way in the first place. (Hoon Im)
|
||
; <SM22> 11/3/92 SWC Changed PaletteEqu.a->Palettes.a.
|
||
; <SM21> 9/17/92 kc Remove short branches.
|
||
; <SM20> 7/15/92 PN Fix the bug in ShowHide where the show/hide flag was push on the
|
||
; stack before jsr Preshowhide. The byte gets pushed was not the
|
||
; flag but some garbage since the offset from (sp) was wrong.
|
||
; <SM19> 7/13/92 FM Fixed a bug in send behind. In the case where a window had
|
||
; actually been moved forward by SendBehind I wasn't preserving
|
||
; the original nextWindow in a4. As a result the loop was
|
||
; comparing to whatever garbage happened to be in a4 which would
|
||
; often cause a crash. Basically just a dumb mistake on my part…
|
||
; <SM18> 6/22/92 RB Rolled-in the Help Manager patch to ShowHide from
|
||
; BalloonPthc28.a, HMShowHidePatch.
|
||
; <SM17> 6/12/92 CSS Roll-in Reality Changes:
|
||
; <10> 6/11/92 FM Removed the obsolete call to FixSMgrWorld.
|
||
; <SM16> 5/22/92 FM
|
||
; <SM16 > 5/5/92 FM Redo the windowmgr patches and bring up to date w/ Reality:
|
||
;
|
||
; deleted calcviswindow since it is completely patched out. Kept SubStructLoop.
|
||
; deleted CheckUpdate because it is completely patched out
|
||
; and PaintBehind
|
||
;
|
||
;
|
||
; rolled in patchSectRgn. Just needed to call _ClipAbove instead of JSRing
|
||
;
|
||
; rolled in CheckPaintWhiteWord. Changed a tst.b to a tst.w
|
||
;
|
||
; rolled in PaintDesk from WindowMgrPatches.a into PaintTheDesk in the WindowMgr.a file.
|
||
; I renamed the routine PaintDesk (as in the patch file) and I took out the ROM85 check for
|
||
; color since the SuperMario ROM always has color. Took out export of NoDeskHook. Its no
|
||
; longer needed since (yet again) we're not jumping through the patch file anymore.
|
||
;
|
||
; rolled in PreShowHide more cleanly in ShowHide.
|
||
;
|
||
; Renamed InitWindows as InitWindowsGuts so that we wouldn't be bouncing between the patch
|
||
; file, LayerMgr.c and here. The Dispatch Table now points to __InitLayers
|
||
;
|
||
; copied over Philips NewWindow and NewCWindow routines and broke them into procs.
|
||
;
|
||
; Renamed closewindow as closewindowguts so that it can be called from the layermgr
|
||
; and the dispatch table won't point at the patch file.
|
||
;
|
||
; rolled in patch to move ShowHide call in closewindow, in front of KillControls to eliminate unecessary redrawing
|
||
;
|
||
; Changed all frontwindow calls to JSR __ActiveWindow
|
||
;
|
||
; Rolled in ShowHideInShowWindow correctly (and cleaner). Otherwise we would be trashing A1 all the time.
|
||
;
|
||
;
|
||
; Roll in SetWTitleActivatePalette
|
||
;
|
||
; Rolled in PaintOneInMoveWindow w/ explanation.
|
||
;
|
||
; Cleaned up the ugly patchFrontWindow selectWindow case
|
||
;
|
||
; re-roll in the SendBehind patch instead of copyingy and pasting it so it is easier to read
|
||
; and more straightforaward.
|
||
;
|
||
; fixed bugs due to copy and paste in the BeginUpdate and EndUpdate
|
||
; proceudres.
|
||
;
|
||
; Rolled in PatchDragGrayRgn
|
||
;
|
||
; Renamed FindWindow as findlayer because thats what the patches did. Saves us going through
|
||
; the patch file.
|
||
;
|
||
; ReRolled in the fixes to SetCtlColor and SetWinColor which were messy and wrong.
|
||
; Added utility routine GetRearWindow
|
||
;
|
||
;
|
||
; <9> 4/23/92 DTY The last change leaves a region on the screen if you drag a
|
||
; window over the menu bar, then back again. If the outline is
|
||
; just becoming visible again, don’t do the XorRgn.
|
||
; <8> 4/21/92 DTY Get rid of the “fast paint” case in DragTheRgn. _PaintRgn is
|
||
; fast enough now to deal with funky regions. Also reworked
|
||
; dragging algorithm so the region doesn’t flicker as it is
|
||
; dragged around.
|
||
; <7> 4/17/92 DTY Dean hates the fact that everything’s lumped into one huge Proc.
|
||
; Make separate procs for all the routines.
|
||
; <6> 9/25/91 JSM Also, stop using useless conditional HMenus.
|
||
; <5> 9/25/91 JSM Cleanup header, remove use of hasCQD from this file since all
|
||
; future ROMs will have color QuickDraw.
|
||
; <4> 9/13/90 BG Removed <3>. 040s are behaving more reliably now.
|
||
; <3> 7/19/90 BG Added EclipseNOPs for flakey 040s.
|
||
; <2> 1/18/90 DVB Include PalettePriv.a
|
||
; <1.5> 12/4/89 MSH Moved a local label into a conditional.
|
||
; <1.4> 10/31/89 dba concatenated source files WindowMgr1.a, WindowMgr2.a and
|
||
; WindowMgr3.a to this one
|
||
;
|
||
; Note: This file used to be split into four pieces. Here are the modification histories for each:
|
||
;
|
||
;----------------------------------------------------------------------------------------------------
|
||
; Modification History for WindowMgr.a
|
||
;----------------------------------------------------------------------------------------------------
|
||
;
|
||
; 1.3 SES 08/22/1989 Removed references to nFiles.
|
||
; 1.2 DAF 05/30/1989 Added INCLUDE of PaletteEqu.a
|
||
; 1.1 CCH 11/10/1988 Fixed Header.
|
||
; 1.0 CCH 11/ 9/1988 Adding to EASE.
|
||
; 1.3 GGD 11/ 2/1988 Got rid of machine specific conditionals in favor of
|
||
; feature based conditionals.
|
||
; 1.2 PKE 10/27/1988 Added reference to FixSMgrWorld
|
||
;•1.1 CCH 9/23/1988 Got rid of inc.sum.d and empty nFiles
|
||
; 1.0 BBM 2/11/88 Adding file for the first time into EASE…
|
||
;
|
||
; 04-Aug-82 AJH added DocumentProc
|
||
; 10-Aug-82 AJH got rid of scrapWindow,getSysWindows,GetGrayRgn
|
||
; 31-Aug-82 AJH added GrowWindow
|
||
; 07-Sep-82 AJH added DrawMBar external reference
|
||
; 22-Sep-82 AJH integrate string routines
|
||
; 25-Sep-82 AJH added dBoxWProc,TrackGoAway
|
||
; 29-Sep-82 AJH made CallWindow externally accessible
|
||
; 09-Oct-82 AJH converted to QuickDraw Trap interface
|
||
; 16-Oct-82 AJH added copyRight notice
|
||
; 01-Nov-82 AJH added FindWindow
|
||
; 14-Nov-82 AJH added SelectWindow
|
||
; 20-Nov-82 AJH changed SendToBack to SendBehind
|
||
; 21-Nov-82 AJH got rid of DiffVisBehind
|
||
; 24-Dec-82 AJH made DocumentProc,DBoxProc resources
|
||
; 02-Jan-83 AJH made ShowHide externally accessible
|
||
; 31-Jan-83 AJH added CloseWindow
|
||
; 07-Feb-83 AJH GetSysPorts -> GetWmgrPort
|
||
; 03-Apr-83 AJH Added interface for PinRect, DeltaPoint
|
||
; 28-Apr-83 AJH move PinRect to cursor core
|
||
; 23-Jun-83 SC Multi-window ornaments (Changed SystemKind test in wmgrasm3)
|
||
; 05-Aug-83 AJH Added DrawGrowIcon
|
||
; 12-Aug-83 AJH added alternate entry point to DragTheRgn (DragGrayRgn)
|
||
; 09-Sep-83 AJH made WmgrGray external
|
||
; 23 Jan 85 LAK Adapted for new equate files.;
|
||
; 23-Jan-85 EHB added patches: cancel pending paintBehind; reset alarm parity;
|
||
; say that window world exists.
|
||
; 23-Jan-85 EHB Made CloseWindow cancel pending activate events; made it
|
||
; properly update curActivate in DoActivate
|
||
; 23-Jan-85 EHB Fixed SetWTitle so no flicker if structure doesn't change
|
||
; 23-Jan-85 EHB fixed FrontWindow to return NIL if no window world
|
||
; 31 Jan 85 EHB When a window is closed or disposed, and thePort was set to
|
||
; that window, set thePort to WMgrPort instead.
|
||
; 10-May-85 EHB Made the drawing in InitWindows really clean
|
||
; 9-Jul-85 EHB Added ROMMapInsert for ROM resources
|
||
; 5-Aug-85 EHB Made initwindows call menu routine CalcMBHeight so that the menu
|
||
; bar height always correct for calc'ing regions.
|
||
; EHB Added SetWPort and RestorePort to CallWindow so that defproc can
|
||
; call GetFontInfo on the window manager port
|
||
; 6-Aug-85 EHB fixed DragWindow's pinning for variable menu heights
|
||
; Added .REF of CalcMBHeight from menu manager
|
||
; 29-Aug-85 EHB In SetWTitle check for NIL window title handle
|
||
; 29-Aug-85 EHB Added routine TrackBox for tracking zoom boxes etc...
|
||
; 29-Aug-85 EHB Added routine ZoomWindow(window:windowPtr;partCode:integer);
|
||
; to do it, split off MoveGuts and SizeGuts from Move- and SizeWindow
|
||
; 09-Sep-85 EHB Pull right update byte off stack in sizewindow.
|
||
; 23-Oct-85 EHB save D1 across FindWindow to make OverView work
|
||
;_______________________________________________________________________
|
||
;
|
||
; Post Lonely Hearts
|
||
;_______________________________________________________________________
|
||
;
|
||
; <19feb86> BBM Made some modifications to work under MPW
|
||
;_______________________________________________________________________
|
||
;
|
||
; <C59/30Jun86> DAF Color window manager support for nuMac added (no 020 code)
|
||
; <C75/15Jul86> DAF Updated default color constants for new QD
|
||
; <C79/21Jul86> DAF Made a fix to GoPaintOne to correctly preserve colors
|
||
; <C203/06Oct86> DAF Converted to RGBColor specifications everywhere.
|
||
; Added color window manager port. Added new call
|
||
; GetCWmgrPort.
|
||
; <C388/09Nov86> DAF reverted to setting wmgrPort rather than wmgrCPort for
|
||
; compatibility
|
||
; <C424/18Nov86> DAF Made FindWindow call MBarProc (menuMgr) to test for menubar hits
|
||
; To do this, CallMBarProc is imported.
|
||
; <C458/23Nov86> DAF Added SetDeskCPat, removed SetDeskColor
|
||
; <C491/08Dec86> DAF Added GetWVariant
|
||
; <C906/13oct87> MSH Port to HcMac (Laguna). Menu bar proc call.
|
||
; <C914/29Oct87> rwh Port to Modern Victorian
|
||
; <C949/08Nov87> DAF Updated PaintDesk to switch to system heap when using deskPPAT.
|
||
; Fixed CallWindow to call syserror if WDEF LoadResource didn't work.
|
||
;
|
||
; <1.2/30May89> DAF Added PaletteEqu.a. Fixed up 32-bit mode handling of auxWinRecs.
|
||
; Updated palette disposal in CloseWindow.
|
||
;
|
||
;----------------------------------------------------------------------------------------------------
|
||
; Modification History for WindowMgr1.a
|
||
;----------------------------------------------------------------------------------------------------
|
||
;
|
||
; 1.2 SES 08/22/1989 Removed references to nFiles. Updated equates accordingly.
|
||
; 1.1 CCH 11/10/1988 Fixed Header.
|
||
; 1.0 CCH 11/ 9/1988 Adding to EASE.
|
||
; 1.1 GGD 11/ 2/1988 Got rid of machine specific conditionals in favor of
|
||
; feature based conditionals.
|
||
; 1.0 BBM 2/11/88 Adding file for the first time into EASE…
|
||
;
|
||
; 20-Aug-82 AJH Fixed bug in InsertWindow when inserting 1st one in list
|
||
; 06-Sep-82 AJH Made InsertWindow/DeleteWindow handle empty list
|
||
; 08-Oct-82 AJH Converted for QuickDraw trap interface
|
||
; 21-Nov-82 AJH got rid of DiffVisBehind (no-one was using it)
|
||
; 21-Nov-82 AJH Added string routines (were in WmgrAsm2)
|
||
; 23-Nov-82 AJH Made InsertWindow clear NextWindow link to avoid circles
|
||
; 19-Dec-82 AJH Installed deskHook hook for painting the desk, use deskPat
|
||
; 23-Jan-83 AJH Made it use deskHook for inDesk in FindWindow
|
||
; 10-Jun-83 AJH Saved code in NewString, SetString using Capps' routines
|
||
; 15-Aug-83 AJH Monster code krunch following review (Donn, Jerome)
|
||
; 01-Sep-83 AJH Changed booleans in PaintOne to be bytes instead of words
|
||
; 28-Oct-85 EHB In ShowHide, fixed compare of booleans for equality.
|
||
;
|
||
; <C59/30Jun86> DAF Changed GoPaintOne and desktop filling routines to
|
||
; support color in nuMac
|
||
; <C79/21Jul86> DAF Fixed color setting in GoPaintOne.
|
||
; <C106/5Aug86> EHB Added routine PortToMap
|
||
; Make sure we use the right BOUNDS for color ports
|
||
; (only needed for nuMac, but works for old)
|
||
; <C203/06Oct86> DAF Converted to RGB color specifications. Changed
|
||
; manager to use color wmgrPort. Disabled whiteRgn
|
||
; erase in PaintBehind for nuMac only. Fixed
|
||
; PaintWhite to work in nuMac.
|
||
; <C388/09Nov86> DAF reverted to setting wmgrPort rather than wmgrCPort for
|
||
; compatibility
|
||
; <C666/22Jan87> DAF Fixed NoDeskHook to eliminate update bug, and use pRam copy
|
||
; of deskCPatEnable.
|
||
; <18Jun87> DAF Conditionalized Palette Mgr patch to ShowHide.
|
||
; <C914/29Oct87> rwh Port to Modern Victorian
|
||
; <C949/08Nov87> DAF Updated PaintDesk to switch to system heap when using deskPPAT.
|
||
;
|
||
;----------------------------------------------------------------------------------------------------
|
||
; Modification History for WindowMgr2.a
|
||
;----------------------------------------------------------------------------------------------------
|
||
;
|
||
; 1.7 SES 08/22/1989 Removed references to nFiles. Updated equates accordingly.
|
||
;•1.6 DAF 06/30/1989 Override of previous version due to lack of space on
|
||
; Reality
|
||
; 1.6 DAF 06/30/1989 Cleared hi half of register in EORSymbol's call to WDEFs
|
||
; 1.5 DAF 06/28/1989 Moved WWExist flag setting to end of routine (after
|
||
; window world really IS set up)
|
||
; 1.4 DAF 05/30/1989 Fixed dispose of AuxWinRecs in 32-bit addressing mode.
|
||
; Updated palette dispose tests
|
||
;•1.3 DAF 04/27/1989 Improved color desktop handling in InitWindows
|
||
; 1.2 MSH 03/01/1989 Added support for external video (Topanga) with Dave F's
|
||
; help.
|
||
; 1.1 CCH 11/10/1988 Fixed Header.
|
||
; 1.0 CCH 11/ 9/1988 Adding to EASE.
|
||
; 1.2 GGD 11/ 2/1988 Got rid of machine specific conditionals in favor of
|
||
; feature based conditionals.
|
||
; 1.1 PKE 10/27/1988 Added code to InitWindows for in-ROM ScriptManager.
|
||
; 1.0 BBM 2/11/88 Adding file for the first time into EASE…
|
||
;
|
||
; 04-Aug-82 AJH 'TenBytExit' label added add end of 'SizeWindow'
|
||
; 10-Aug-82 AJH Got rid of GetSysWindows,GetGrayRgn,scrapWindow;
|
||
; 20-Aug-82 AJH Added InitMsg call to NewWindow; DisposeMsg call to DisposeWindow
|
||
; 29-Aug-82 AJH made InitWindowsinitialize IShapeHook for controls
|
||
; 06-Sep-82 AJH made CheckUpdate handle empty window list
|
||
; 06-Sep-82 AJH got rid of Alert and DialogWindow as special ones
|
||
; 07-Sep-82 AJH saved code in InitWindow using common code to draw menu bar
|
||
; 12-Sep-82 AJH made windowMgr calcRgns for invisible windows instead of procs
|
||
; 19-Sep-82 AJH made InitWindow set up symbol bitmap low memory pointers
|
||
; 22-Sep-82 AJH integrated string routines
|
||
; 26-Sep-82 AJH made DisposeWindow dispose the window's controls
|
||
; 28-Sep-82 AJH made TrackGoAway send message to XOR, changed CallDWindow
|
||
; 05-Oct-82 AJH Fixed HiliteWindow clip bug, made code saving optimizations
|
||
; 10-Oct-82 AJH Converted to QuickDraw trap interface
|
||
; 16-Oct-82 AJH Made dot-size independent
|
||
; 14-Nov-82 AJH Added SelectWindow
|
||
; 16-Nov-82 AJH Made Initwindows initialize TaskLock
|
||
; 19-Nov-82 AJH Made it use more traps for internal calls
|
||
; 21-Nov-82 AJH Fixed thePort trashing bug in HiliteWindow, moved string routines
|
||
; 24-Nov-82 AJH Made selectWindow call BTF1 instead of BTF
|
||
; 19-Dec-82 AJH Added initialization of cur(De)active, deskHook
|
||
; 20-Dec-82 AJH Added SelectWindow calls to New,Dispose,Move
|
||
; 21-Dec-82 AJH Made SelectWindow post activate/deactivate events
|
||
; 22-Dec-82 AJH Fixed region dispose bug in MoveWindow
|
||
; 24-Dec-82 AJH changed initialization, defProcs as resources for 2.0
|
||
; 02-Jan-83 AJH made disposeWindow kill a the picture if its installed
|
||
; 09-Jan-83 AJH removed size-checking in SizeWindow
|
||
; 12-Jan-83 AJH rewrote CheckUpdate to support pictures
|
||
; 31-Jan-83 AJH clear high byte when loading the defProc
|
||
; 31-Jan-83 AJH no more special casing of alertWindows; fixed HideWindow problem
|
||
; 31-Jan-83 AJH added CloseWindow
|
||
; 07-Feb-83 AJH made NewWindow generate updates; no more deskPort
|
||
; 26-Feb-83 AJH fixed select bug when disposing the last window
|
||
; 27-Feb-83 AJH saved some code in CloseWindow by using ClosePort
|
||
; 07-Mar-83 AJH made CloseWindow dispose of the title string
|
||
; 09-Mar-83 AJH fixed bug introduced by disposing the title string
|
||
; 02-Apr-83 AJH saved code by not initing wmgrPort visRgn
|
||
; 03-Apr-83 AJH made NewWindow use defProc 0 if it can't find one
|
||
; 05-Apr-83 AJH made InitWindows initialize the ghostWindow ptr
|
||
; 10-May-83 AJH made InitWindows init CloseOrnHook
|
||
; 09-Jun-83 AJH made InitWindows only draw minimal black for corners
|
||
; 10-Jun-83 AJH new, much improved MoveWindow (blits as much as it can)
|
||
; 16-Jun-83 AJH PaintBehind a little earlier in MoveWindow
|
||
; 05-Aug-83 AJH Made NewWindow default textFont to 1
|
||
; 06-Aug-83 BLH Moved oneOne, minusOne initialization to Start;
|
||
; Moved DragHook, TaskLock, CloseOrnHook, DeskHook to
|
||
; segment loader.
|
||
; 13-Aug-83 AJH Made InitWindows do a ShowCursor
|
||
; 15-Aug-83 AJH Monster code krunch after review (Donn, Jerome)
|
||
; 02-Sep-83 AJH masked off high-order bits in user's storage ptr
|
||
; 02-Sep-83 AJH made it use least recent deactivate
|
||
; 12-Sep-83 AJH made it post CurDeKind in CloseWindow and when its
|
||
; deactivated
|
||
; 23-Jan-85 EHB added patches: cancel pending paintBehind; reset alarm parity;
|
||
; say that window world exists.
|
||
; 23-Jan-85 EHB Made CloseWindow cancel pending activate events; made it
|
||
; properly update curActivate in DoActivate
|
||
; 23-Jan-85 EHB Fixed SetWTitle so no flicker if structure doesn't change
|
||
; 31 Jan 85 EHB When a window is closed or disposed, and thePort was set to
|
||
; that window, set thePort to WMgrPort instead.
|
||
; 10-May-85 EHB Made the drawing in InitWindows really clean
|
||
; 9-Jul-85 EHB Set flag to Get new window resource from ROM if possible
|
||
; 10-Jul-85 EHB Set flag to reload WDEF from ROM if possible too
|
||
; 5-Aug-85 EHB Initwindows calls CalcMBHeight to set up height of menu bar
|
||
; 29-Aug-85 EHB In SetWTitle check for NIL window title handle
|
||
; 29-Aug-85 EHB Added routine TrackBox for tracking zoom boxes etc...
|
||
; 29-Aug-85 EHB Added routine ZoomWindow(window:windowPtr;partCode:integer);
|
||
; to do it, split off MoveGuts and SizeGuts from Move- and SizeWindow
|
||
; 09-Sep-85 EHB Pull right update byte off stack in sizewindow.
|
||
; 28-Oct-85 EHB In ShowWindow, set boolean WVISIBLE to $01, not $FF
|
||
; 03-Nov-85 EHB Get Window Ptr into A3 BEFORE calling CallWCalc
|
||
;
|
||
;----------------------------------------------------------------------------
|
||
;
|
||
; Post Lonely Hearts Changes
|
||
;
|
||
; <C59/30Jun86> DAF Changed InitWindows to allocate window and control Aux
|
||
; structures and desk colors
|
||
; <C75/15Jul86> DAF Updated default colors to work w/new QD
|
||
; <C106/5Aug86> EHB Make sure we use the right BOUNDS for color ports
|
||
; (only needed for nuMac, but works for old)
|
||
; Added NewCWindow.
|
||
; <C168/17Sep86> DAF Added InitMenus to InitWindows so that menuBar def
|
||
; proc is initialized before attempting to clear
|
||
; the bar region. THIS NEEDS A BETTER RESOLUTION!
|
||
; <C203/08Oct86> DAF updated wmgr to RGBColor. Revamped InitWindows.
|
||
; <C388/09Nov86> DAF reverted to setting wmgrPort rather than wmgrCPort for
|
||
; compatibility
|
||
; <C424/18Nov86> DAF converted InitWindows to use look in system file, then ROMresources
|
||
; for default window and control colors (wctb=0,cctb=0). Added
|
||
; DeskCPat init stuff in InitWindows. Also made some 32-bit changes.
|
||
; <C491/08Dec86> DAF general cleanup from code review. Added GetWVariant.
|
||
; Restructured desk pattern stuff in InitWindows.
|
||
; <C589/03Jan87> EHB Added SmartMove routine for multiple screens
|
||
; <C591/04Jan87> DAF Improved 32-bit handling. When MMUFlag=1, moved variant code to
|
||
; auxWinRec
|
||
; <C612/11Jan87> DAF set visible flag in off at beginning of NewWindow, so
|
||
; SetWinColor doesn't try to draw with invalid portRect in 32-bit.
|
||
; <C666/21Jan87> DAF Fixed LoadResource in CallWindow. Switched to using pRAM copy
|
||
; bit (pCDeskPat) to tell which deskPat to use. Switched to using
|
||
; rGetResource when loading wctb,cctb in InitWindows. Switched 32-bit
|
||
; stuff to use MMU32Bit (the correct flag)
|
||
; <C725/31Jan87> DAF Adjusted InitWindows to read binary deskpat always. Also does not
|
||
; look in ROM for ppat=16.
|
||
; <C768/06Feb87> EHB Make sure that each device is active in InitWindows.
|
||
;
|
||
;------ Macintosh II is born ------------------------------------------------
|
||
;
|
||
; <12May87> DAF Rolled in Palette Manager patches from ROM78Fix
|
||
; <C914/29Oct87> rwh Port to Modern Victorian
|
||
; <C949/08Nov87> DAF Fixed CallWindow to call syserror if WDEF LoadResource didn't work.
|
||
; This is better since Juggler can gracefully terminate this app.
|
||
;
|
||
;------ Aurora -------------------------------------------------------------
|
||
;
|
||
; <1.3> DAF Improved DeskCPat handling in InitWindows
|
||
; <1.4> DAF Updated CloseWindow to correctly handle the auxWinRecs in 32-bit addressing
|
||
; mode. Also, dvb had an update to the Palette disposal routines.
|
||
; <1.5> DAF Moved clearing of WWExist to end of InitWindows (when it's really done!)
|
||
; rather than at beginning. This helps out the Palette manager when it's
|
||
; dealing with the color apple in the menubar during InitWindows' InitMenus call.
|
||
; <1.6> DAF Fixed an old bug for Ernie. TrackGoAway passes a word-sized part code to the
|
||
; WDEF in a long-size field. Make sure that the hiword of the long is clear.
|
||
;
|
||
;----------------------------------------------------------------------------------------------------
|
||
; Modification History for WindowMgr3.a
|
||
;----------------------------------------------------------------------------------------------------
|
||
;
|
||
; 1.5 DAF 07/23/1989 Corrected 32-bit mode bug in SetWinColor for dialogs.
|
||
; Updated obsolete equate names
|
||
; 1.4 DAF 07/14/1989 FOR AURORA BUILD - Corrected DeAlAux in
|
||
; SetWinColor/SetCtlColor to fix the auxWinList/auxCtlList problems in
|
||
; 32-bit addressing mode.
|
||
; 1.3 DAF 05/30/1989 Improved 32-bit addressed behaviour of SetAuxWin et.al.
|
||
;•1.2 DAF 04/27/1989 Made sure SetDeskCPat released old desktop PixPat before
|
||
; setting new one.
|
||
; 1.1 CCH 11/10/1988 Fixed Header.
|
||
; 1.0 CCH 11/ 9/1988 Adding to EASE.
|
||
; 1.4 GGD 11/ 2/1988 Got rid of machine specific conditionals in favor of
|
||
; feature based conditionals.
|
||
; 1.3 rwh 9/24/1988 fixed added NuMac conditionals to also be for onMvMac
|
||
; 1.2 DAF 6/17/88 added conditionals for numac that were left out.
|
||
; 1.1 CSL 4/18/88 fixed bug introduced by rolling in code for NuMac.
|
||
; 1.0 BBM 2/11/88 Adding file for the first time into EASE…
|
||
;
|
||
; 20-Aug-82 AJH Fixed DragWindow bug in computing position when origin <> (0,0)
|
||
; 21-Aug-82 AJH Made InvalRect/Rgn share more code with ValRect/Rgn
|
||
; 21-Aug-82 AJH Added boundRect to DragTheRgn so it can be used by Controls
|
||
; 29-Aug-82 AJH Made DragTheRgn use a pattern from global area (dragPattern)
|
||
; 30-Aug-82 AJH Added slopRect parameter to dragTheRgn
|
||
; 06-Sep-82 AJH Got rid of special casing of alert/dialog windows
|
||
; 06-Sep-82 AJH Added GrowWindow
|
||
; 08-Sep-82 AJH Fixed BeginUpdate -- it was trashing A3
|
||
; 09-Sep-82 AJH Put bounds (size) checking into GrowWindow
|
||
; 28-Sep-82 AJH Changed FrontWindow to skip alertKind only, added CallDragHook
|
||
; 05-Oct-82 AJH Made some code saving optimizations
|
||
; 06-Oct-82 AJH Made dragging pin instead of freezing (DragTheRgn,GrowWindow)
|
||
; 10-Oct-82 AJH Converted to QuickDraw trap interface
|
||
; 16-Oct-82 AJH Made independent of screen size
|
||
; 25-Oct-82 AJH Made FrontWindow return frontmost visible window
|
||
; 01-Nov-82 AJH Added control-less FindWindow to window manager
|
||
; 07-Nov-82 AJH Tweaked delay in DragTheRgn for 512 machine
|
||
; 16-Nov-82 AJH Made DragWindow look at command key state for ClipAbove
|
||
; 16-Nov-82 AJH Changed menuBar hit-test in FindWindow to 20 pixels
|
||
; 20-Nov-82 AJH Changed SendToBack to SendBehind
|
||
; 20-Nov-82 AJH Finally fixed bounds pinning in GrowWindow
|
||
; 24-Nov-82 AJH made bringToFront clear DragFlag as default entry
|
||
; 20-Dec-82 AJH made bringToFront do nothing if its already the front one
|
||
; 21-Dec-82 AJH made SendBehind call SelectWindow when appropriate
|
||
; 04-Feb-83 AJH added actionProc to DragTheRgn
|
||
; 26-Feb-83 AJH made DragTheRgn distinguish between aborted and not moved
|
||
; fixed DragWindow accordingly.
|
||
; 05-Apr-83 AJH made FrontWindow ignore the ghostWindow
|
||
; 28-Apr-83 AJH moved PinRect to cursorCore
|
||
; 26-Jun-83 AJH fixed keyMap clobber in DragWindow;
|
||
; pinned users dragRect at top (12)
|
||
; 01-Jul-83 SC fixed bug in DragWindow created by above
|
||
; 05-Aug-83 AJH Added DrawGrowIcon
|
||
; 15-Aug-83 AJH code krunch after review
|
||
; 30-Aug-83 AJH fixed restorePort bug and saved code in SendBehind (thanks,Donn)
|
||
; 07-Sep-83 AJH fixed stack offset bug in SendBehind (introduced 30-Aug)
|
||
; 23-Jan-85 EHB fixed FrontWindow to return NIL if no window world
|
||
; 5-Aug-85 EHB fixed DragWindow's pinning for variable menu heights
|
||
; 23-Oct-85 EHB save D1 across FindWindow to make OverView work
|
||
;
|
||
;------------------------------- Lonely Heifer ROMs ----------------------------------
|
||
|
||
; 14-Jan-86 EHB Fixed infinite loop bug in DragTheRgn (@DragDelay)
|
||
; <C106/5Aug86> EHB Make sure we use the right BOUNDS for color ports
|
||
; (only needed for nuMac, but works for old)
|
||
;<C392/10Nov86> DAF Fixed DragGrayRgn and GrowWindow to save and restore penstate in
|
||
; both wmgrPort and wmgrCPort
|
||
;<C407/16Nov86> DAF Fixed DeAlAux (in SetWinColor) to not dispose default winCTable
|
||
;<C424/18Nov86> DAF Made FindWindow call MBarProc (menuMgr) to test for menubar hits
|
||
;<C458/23Nov86> DAF Removed SetDeskColor. Added DeskCPat.
|
||
;<C46x/23Nov86> EHB Disable all drag bounds for multiple screens
|
||
;<C467/25Nov86> EHB Fixed bug in merged code in DragTheRgn
|
||
;<C591/04Jan87> DAF Made small fixes in SetWinColor for 32-Bit Support
|
||
;<C612/11Jan87> DAF Fixed some small bugs introduced in SetWinColor in C591.
|
||
; Corrected resource bit test in SetWinColor (it was backward!)
|
||
;<C616/12Jan87> DAF Changed _ShowControl in SetCtlColor to _Draw1Control so that it
|
||
; would correctly redraw.
|
||
;<C624/13Jan87> EHB Added fast version of dragTheRgn (if region is rect)
|
||
;<C666/22Jan87> DAF Changed SetDeskCPat to use pCDeskPat and to switch to binary pat if
|
||
; pixPatHandle is NIL.
|
||
;<C767/06Feb87> DAF Fixed special case testing in SetGuts so that it wouldn't dereference
|
||
; a -1 handle.
|
||
;<C835/20Feb87> DAF Fixed stack trashing problem in SetDeskCPat(NIL).
|
||
;<C841/21Feb87> DAF Corrected C835.
|
||
;<C914/29Oct87> rwh Port to Modern Victorian
|
||
;<C970/22Nov87> DAF Fixed register trashing bug in GetPinMouse to correct extra update
|
||
; problem in GrowWindow
|
||
;
|
||
;--------- Aurora!! ------------------
|
||
;
|
||
;<1.2/27Apr89> DAF Rolled patch to SetDeskCPat into source. Now the desk pix pat is disposed
|
||
; when a new one is set (instead of overwriting!).
|
||
;<1.3/30May89> DAF Updated AuxWin/CtlRec handlers to be more graceful in 32-bit addressing mode
|
||
;
|
||
;<1.5/23Jul89> DAF Corrected 32-bit bug in SpecAlloc. Updated equate names in this file
|
||
; to the official MPW names (this file doesn't need nToolEqu.a anymore).
|
||
;
|
||
|
||
LOAD 'StandardEqu.d'
|
||
INCLUDE 'ColorEqu.a'
|
||
INCLUDE 'ScriptPriv.a'
|
||
INCLUDE 'Palettes.a'
|
||
INCLUDE 'PalettePriv.a'
|
||
INCLUDE 'Balloons.a' ;
|
||
INCLUDE 'BalloonsPriv.a' ;
|
||
INCLUDE 'ControlPriv.a'
|
||
IF hasDisplayMgrWindows THEN ; <SM81>
|
||
INCLUDE 'Displays.a' ;
|
||
INCLUDE 'DisplaysPriv.a' ;
|
||
ENDIF
|
||
|
||
MACHINE MC68020 ; needed for cache flush <LW4> fau
|
||
|
||
; *** move these equates into system equate files
|
||
|
||
CurLayer EQU $A90
|
||
WMgrUpdate EQU $AFC
|
||
|
||
PortToBitMap Proc Export
|
||
|
||
; Given a window pointer in A0, return the bitmap/pixmap pointer in A0
|
||
|
||
ADDQ #PORTBITS,A0 ;POINT TO BITMAP/PIXMAP HANDLE
|
||
TST ROWBYTES(A0) ;BITMAP OR PIXMAP HANDLE?
|
||
BPL.S GOTBITMAP ;=>JUST A BITMAP
|
||
MOVE.L BASEADDR(A0),A0 ;ELSE GET PORT'S PIXMAP HANDLE
|
||
MOVE.L (A0),A0 ;GET PIXMAP POINTER
|
||
GotBitMap
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; SetUpColor takes a window part identifier in D0, and the windowRecord
|
||
; in A0, finds the appropriate rgb, and returns with a pointer to
|
||
; it, ready for RGBForeColor. The auxRec is not locked, so RGBForeColor
|
||
; should be called immediately. If the desired window part is not found,.
|
||
; the first color in the auxRec is used.
|
||
|
||
SetUpColor Proc Export
|
||
MOVEM.L D1/D3,-(SP) ; save some registers
|
||
MOVE.W D0,D3 ; keep the window part
|
||
SUBQ #4,SP ; make room for var ptr result
|
||
CLR.B -(SP) ; make room for boolean result
|
||
MOVE.L A0,-(SP) ; push window ptr
|
||
PEA 6(SP) ; push pointer to placeholder
|
||
_GetAuxWin ; get the window aux rec
|
||
ADDQ #2,SP ; pitch the boolean
|
||
MOVE.L (SP)+,A0 ; get the auxWinHandle
|
||
MOVE.L (A0),A0 ; get the auxWinPtr
|
||
MOVE.L awCTable(A0),A0 ; get the color table handle <1.2>
|
||
MOVE.L (A0),A0 ; get a cTabPtr
|
||
|
||
MOVE.W CTSize(A0),D1 ; get the color table size
|
||
MULU #CTEntrySize,D1 ; convert to color table index
|
||
LegalIndex
|
||
CMP.W CTTable+value(A0,D1),D3 ; is this the one?
|
||
BEQ.S FoundIt ; if equal, then done
|
||
SUB.W #CTEntrySize,D1 ; try the previous one
|
||
BGE.S LegalIndex ; loop while index positive
|
||
MOVEQ #0,D1 ; OK, use the first one
|
||
FoundIt
|
||
LEA CTTable+rgb(A0,D1),A0 ; get the address of the color to use
|
||
MOVE.L A0,D0 ; we'll need A0 in a second
|
||
MOVEM.L (SP)+,D1/D3 ; restore the registers
|
||
MOVE.L (SP)+,A0 ; get the return address
|
||
MOVE.L D0,-(SP) ; move the ret addr back
|
||
JMP (A0) ; return to caller
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION NewString(string): StringHandle
|
||
;
|
||
; allocates a string as a relocatable object on the heap and returns
|
||
; a handle to it
|
||
;
|
||
;
|
||
|
||
NewString Proc Export
|
||
Import GetSPtr
|
||
|
||
BSR.S GetSPtr ;A0 points to string, D0 has length
|
||
_PtrToHand ;allocate handle in A0
|
||
MOVE.L A0,8(SP) ;return it as the result
|
||
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
; GetSPtr is common code for NewString and SetString. It gets the pointer
|
||
; to the string in A0 and its length in D0
|
||
|
||
GetSPtr Proc Export
|
||
MOVE.L 8(SP),A0 ;get the string pointer
|
||
MOVEQ #0,D0 ;clear out high part of D0
|
||
MOVE.B (A0),D0 ;get the length
|
||
ADDQ #1,D0 ;bump to include length byte
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SetString(h: StringHandle; s: string)
|
||
;
|
||
; set the specified string handle to the specified string
|
||
;
|
||
SetString Proc Export
|
||
Import GetSPtr
|
||
Import TwoParmExit
|
||
|
||
MOVE.L 8(SP),A1 ;get the stringHandle
|
||
BSR.S GetSPtr ;set up A0 and D0
|
||
_PtrToXHand ;let Capps do the work
|
||
BRA TwoParmExit ;standard exit saves code <27oct85> BBM
|
||
EndProc
|
||
|
||
;
|
||
; Utility PrevWindow(windowPtr):windowPtr
|
||
;
|
||
; given a window in the display list, find the one in front of it. If
|
||
; the parameter is NIL, find the last one in the list. If the parameter
|
||
; is the first in the list, return NIL. If not found, use last window
|
||
;
|
||
; this utility routine has a register interface to save code. On entry,
|
||
; D0 contains the window to be searched for. On exit, A0 contains the
|
||
; result. A0, A1 and D0 are trashed -- all other registers are preserved.
|
||
|
||
PrevWindow Proc Export
|
||
MOVE.L D0,-(SP) ;save window to search for
|
||
|
||
MOVE.L WINDOWLIST,A1 ;get the 1st entry in the window list
|
||
SUB.L A0,A0 ;set prev to NIL
|
||
|
||
PrevLoop
|
||
CMP.L (SP),A1 ;does it match the parameter?
|
||
BEQ.S DONEPWINDOW ;if so, we're done
|
||
MOVE.L A1,A0 ;update prev pointer
|
||
MOVE.L NEXTWINDOW(A0),A1 ;get the next one in the list
|
||
MOVE.L A1,D0 ;is it NIL?
|
||
BNE.S PrevLoop ;if not,loop
|
||
|
||
DonePWindow
|
||
MOVE.L (SP)+,D0 ;restore D0
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE InsertWindow(window,behind);
|
||
;
|
||
; insert this behind into the window list behind the one specified by the
|
||
; "behind" parameter. If behind = NIL, insert it as the last one in the
|
||
; list. If this is the first window (windowList = NIL), insert as first one.
|
||
; Make sure the window's windowLink ptr is initialized to NIL.
|
||
;
|
||
|
||
InsertWindow Proc Export
|
||
Import PrevWindow
|
||
Export TwoParmExit
|
||
|
||
MOVE.L 8(SP),D1 ;get window to insert
|
||
MOVE.L D1,A1 ;get ptr in A-reg
|
||
CLR.L NextWindow(A1) ;make its link NIL
|
||
|
||
TST.L WindowList ;is the windowList empty?
|
||
BNE.S @1 ;if not, go look at behind
|
||
;
|
||
; its the first one ever so install it at the head of the list
|
||
;
|
||
MOVE.L D1,WindowList ;make it the head of the list
|
||
BRA.S TwoParmExit ;all done!
|
||
;
|
||
; check to see if we should insert it as the last one (behind = NIL).
|
||
;
|
||
@1 MOVE.L 4(SP),D0 ;behind = NIL ?
|
||
BEQ.S INSERTLAST
|
||
;
|
||
MOVE.L D0,A0 ;get behind
|
||
MOVE.L NEXTWINDOW(A0),NEXTWINDOW(A1) ;update the link of new one
|
||
MOVE.L A1,NEXTWINDOW(A0) ;insert new one in list
|
||
BRA.S TWOPARMEXIT ;all done
|
||
;
|
||
; insert it as the last one in the list
|
||
;
|
||
|
||
InsertLast
|
||
MOVEQ #0,D0 ;find the last one
|
||
BSR.S PREVWINDOW ;find last window in list
|
||
MOVE.L D1,NEXTWINDOW(A0) ;insert the window in the list
|
||
;
|
||
|
||
TwoParmExit
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
ADDQ #8,SP ;strip parameters
|
||
JMP (A0) ;all done -- return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE DeleteWindow(window)
|
||
;
|
||
; delete the specified window from the list
|
||
;
|
||
;
|
||
|
||
DeleteWindow Proc Export
|
||
Import PrevWindow
|
||
Import OneParmExit
|
||
Export OneParmExit
|
||
Export WRts1
|
||
|
||
MOVE.L 4(SP),D0 ;get the parameter window
|
||
BSR PREVWINDOW ;find the one before it
|
||
;
|
||
MOVE.L A0,D1 ;is it the first window?
|
||
BNE.S @1 ;if not, skip adjust
|
||
|
||
LEA WindowList-NextWindow,A0 ;make it point to windowList
|
||
|
||
@1 MOVE.L D0,A1 ;get the window to be deleted
|
||
MOVE.L NEXTWINDOW(A1),NEXTWINDOW(A0) ;splice out of the list
|
||
OneParmExit
|
||
MOVE.L (SP)+,(SP) ;strip sole parameter
|
||
WRts1
|
||
RTS
|
||
EndProc
|
||
|
||
|
||
;
|
||
; PROCEDURE ClipAbove(window)
|
||
;
|
||
; set the clipRgn of the window manager's port to be the gray Rgn intersected
|
||
; with the current clipRgn, minus the structRgns of all the windows above
|
||
; the parameter window.
|
||
;
|
||
|
||
ClipAboveGuts Proc Export
|
||
Import SubStructLoop
|
||
|
||
MOVEM.L D4/A2-A3,-(SP) ;save work registers
|
||
MOVE.L WMGRPORT,A0 ;get ptr to the windowMgr port
|
||
MOVE.L CLIPRGN(A0),D4 ;get wmgrPort clipRgn handle
|
||
MOVE.L 16(SP),A2 ;get the window
|
||
|
||
MOVE.L D4,-(SP) ;push clipRgn
|
||
MOVE.L GRAYRGN,-(SP) ;push grayRgn
|
||
MOVE.L D4,-(SP) ;clipRgn gets the result
|
||
_SectRgn ;SectRgn(clipRgn,grayRgn,clipRgn)
|
||
;
|
||
; now subtract all windows above the parameter window from the clipRgn
|
||
;
|
||
|
||
BSR SubStructLoop ;let common code do the work
|
||
|
||
MOVEM.L (SP)+,D4/A2-A3 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
; the following routine subtracts the structRgns of all windows in the list
|
||
; from the region in D4 until the window in A2 is reached. It is common code
|
||
; to CalcVis and ClipAbove
|
||
|
||
SubStructLoop Proc Export
|
||
|
||
MOVE.L WINDOWLIST,A3 ;get 1st window in list
|
||
|
||
CVLoop
|
||
CMP.L A2,A3 ;have we reached parameter window yet?
|
||
BEQ.S WRTS1 ;if so, we're done
|
||
|
||
TST.B WVISIBLE(A3) ;dont bother if its not visible
|
||
BEQ.S SKIPDIFFRGN
|
||
|
||
MOVE.L D4,-(SP) ;push the visRgn
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;push region to be subtracted
|
||
MOVE.L D4,-(SP) ;visRgn gets the result
|
||
_DiffRgn
|
||
SkipDiffRgn
|
||
MOVE.L NEXTWINDOW(A3),A3 ;examine next one in list
|
||
BRA.S CVLOOP ;loop till we reach parameter window
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE PaintOneGuts(window: windowPtr; clobbered: RgnHandle);
|
||
;
|
||
; paint one window, clipped to the clobbered region and all windows
|
||
; above it. If some content is exposed, erase it and add it to the
|
||
; update region. IF the window is NIL, paint gray (its the desk)
|
||
;
|
||
; <SM16> FM the Window will never be NIL now, thanks to the layer manager.
|
||
|
||
PaintOneGuts Proc Export
|
||
Import SetWPClip
|
||
Import TestClip
|
||
Import TwoParmExit
|
||
Import CallDWindow
|
||
Import GetNewRgn
|
||
Import SetupColor
|
||
Export PaintODone
|
||
|
||
MOVEM.L D3-D4/A2-A3,-(SP) ;save work registers
|
||
MOVE.L 24(SP),A2 ;get the window pointer
|
||
|
||
BSR SetWPClip ;setWPort, get clip in D3
|
||
|
||
MOVE.L A2,D0 ;is window NIL?
|
||
BNE.S GOPAINTONE ;if not, go paint it
|
||
|
||
;
|
||
; all done with PaintOne
|
||
;
|
||
|
||
PaintODone
|
||
MOVEM.L (SP)+,D3-D4/A2-A3 ;restore work registers
|
||
BRA TWOPARMEXIT ;standard exit to save code (was .s) <DAF 08-Apr-86>
|
||
;
|
||
; see if the window intersects with clobbered; if not, dont bother to paint;
|
||
; otherwise go paint it
|
||
;
|
||
GOPAINTONE TST.B WVISIBLE(A2) ;is it visible?
|
||
BEQ.S PAINTODONE ;if not, we're done
|
||
MOVE.L 20(SP),-(SP) ;push clobbered
|
||
MOVE.L STRUCTRGN(A2),-(SP) ;push the structRgn of the window
|
||
MOVE.L D3,-(SP) ;their intersection is the clipRgn
|
||
_SectRgn ;SectRgn(clobbered,structRgn,clipRgn)
|
||
;
|
||
BSR TESTCLIP ;exit if clipRgn is empty
|
||
MOVE.L A2,-(SP) ;now subtract windows above this one
|
||
_ClipAbove ;<SM16> FM call the trap instead JSRing
|
||
BSR TESTCLIP ;exit if nothing left to paint
|
||
;
|
||
; draw the structure of the window by calling its window definition procedure
|
||
;
|
||
MOVE.L A2,A3 ;A3 holds the window
|
||
BSR CALLDWINDOW ;call the windowProc to draw it
|
||
;
|
||
; intersect the window's content region with the clipRgn and possibly erase
|
||
; and update that area
|
||
;
|
||
BSR GETNEWRGN ;allocate a new region handle
|
||
MOVE.L (SP)+,A3 ;keep it in A3
|
||
;
|
||
MOVE.L CONTRGN(A2),-(SP) ;push the content region
|
||
MOVE.L D3,-(SP) ;intersect with the clipRgn
|
||
MOVE.L A3,-(SP) ;put the result in the tempRgn
|
||
_SectRgn ;SectRgn(contRgn,clipRgn,tempRgn)
|
||
;
|
||
|
||
TST.W PAINTWHITE ;should we erase it? <SM16> FM do TST.w not TST.b
|
||
BEQ.S SKIPERASE ;if not, skip erasing
|
||
|
||
BTST #isPixMap,portBits+rowbytes(A2) ; is it a new window? <C687/24Jan87> DAF
|
||
BEQ.S @1 ; if zero, then stay in wmgrPort <C687/24Jan87> DAF
|
||
MOVE.L wmgrCPort,-(SP) ; in new, so do it in wmgrCPort for full color <C687/24Jan87> DAF
|
||
_SetPort ; <C687/24Jan87> DAF
|
||
@1
|
||
SUBQ #6,SP ; room to save current port rgbBkColor
|
||
PEA (SP) ; pointer to saved backcolor
|
||
_GetBackColor ; get the rgbColor
|
||
|
||
MOVE.W #wContentColor,D0 ; get the content color
|
||
MOVE.L A2,A0 ; copy the windowptr
|
||
BSR SetUpColor ; get a pointer on the stack
|
||
_RGBBackColor ; and set it
|
||
|
||
MOVE.L A3,-(SP) ;push the update area
|
||
_EraseRgn ;erase it
|
||
|
||
PEA (SP) ; push the saved color
|
||
_RGBBackColor ; reset the back color
|
||
ADDQ #6,SP ; flush the saved color
|
||
|
||
MOVE.L wmgrPort,-(SP) ; for compatibility, force wmgrPort <C687/24Jan87> DAF
|
||
_SetPort ; set it <C687/24Jan87> DAF
|
||
|
||
;
|
||
|
||
SkipErase
|
||
TST.B SAVEUPDATE ;accumulate the updates?
|
||
BEQ.S SKIPUPDATE
|
||
|
||
MOVE.L UPDATERGN(A2),-(SP) ;push the current update region
|
||
MOVE.L A3,-(SP) ;push the clobbered region
|
||
MOVE.L UPDATERGN(A2),-(SP) ;result goes in update region
|
||
_UnionRgn ;add it to the current update region
|
||
;
|
||
|
||
SkipUpdate
|
||
MOVE.L A3,-(SP) ;push tempRgn handle
|
||
_DisposRgn ;de-allocate it
|
||
BRA PAINTODONE ;all done with paintOne
|
||
EndProc
|
||
|
||
; SetWPClip is a code saving utility used in PaintOne and PaintBehind
|
||
|
||
SetWPClip Proc Export
|
||
Import SetWPort
|
||
|
||
BSR SETWPORT ;get into the window mgr port
|
||
MOVE.L WMGRPORT,A3 ;A3 points to the wmgrPort
|
||
MOVE.L CLIPRGN(A3),D3 ;D3 holds wmgrPort^.clipRgn
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; TestClip is a procedure used to speed things up by not bothering to paint
|
||
; windows that wouldn't show anyway. It does this by seeing if the clipRgn
|
||
; (passed in D3) is empty. If it is, it pop's the stack and exits PaintOne,
|
||
; since the window wouldn't show anyway
|
||
;
|
||
|
||
TestClip Proc Export
|
||
Import PaintODone
|
||
|
||
SUBQ #2,SP ;make room for result
|
||
MOVE.L D3,-(SP) ;push the region to be tested
|
||
_EmptyRgn ;is it empty?
|
||
TST.B (SP)+ ;test result
|
||
BNE.S @1 ;if it's empty, go pop stack
|
||
RTS ;its not empty, so just return
|
||
;
|
||
@1 ADDQ #4,SP ;pop off caller's return address
|
||
BRA PAINTODONE ;exit immediately
|
||
EndProc
|
||
|
||
|
||
;
|
||
; PaintDesk is a utility used to paint the desk gray. It clips to every visible window
|
||
; and then fills the port with gray. It assumes A3 points to the WMgrPort
|
||
;
|
||
|
||
PaintDesk Proc Export
|
||
|
||
IF hasDisplayMgrWindows THEN ; We should use the Display Manager desk draw routines
|
||
|
||
Move.l wmgrCPort,A0 ; switch to the cGrafPort
|
||
Move.l clipRgn(A0),-(SP)
|
||
_DMDrawDesktopRegion
|
||
ELSE
|
||
|
||
MOVE.L DeskHook,D0 ;user got a deskPaint routine?
|
||
BEQ.S NoDeskHook ;if not, paint gray
|
||
|
||
; a routine is installed in the deskHook so invoke it to do the painting
|
||
MOVE.L D0,A0 ;get deskPaint address
|
||
MOVEQ #0,D0 ;flag its a paint call
|
||
JMP (A0) ;let the user do the painting
|
||
|
||
NoDeskHook MOVE.L TheZone,-(SP) ; Save the current heap zone <SM16> FM
|
||
MOVE.L SysZone,TheZone ; Switch to the system heap in case of pattern expansion <SM16> FM
|
||
|
||
TST.B pCDeskPat ; test flag to see which to use <C666/22Jan87> DAF
|
||
BPL.S @69 ; if ≥, then use binary pat <C666/22Jan87> DAF
|
||
SUBQ #8,SP ; make room to save wmgrPort,curHeap <C949/08Nov87> DAF
|
||
MOVE.L theZone,4(SP) ; save current heap <C949/08Nov87> DAF
|
||
PEA (SP) ; make a pointer to it
|
||
_GetPort ; get that address
|
||
MOVE.L wmgrCPort,-(SP) ; switch to the cGrafPort
|
||
_SetPort
|
||
MOVE.L GrayRgn,-(SP) ;PUSH THE DESKTOP REGION <11/9/86 EHB>
|
||
MOVE.L DeskCPat,-(SP) ; push the desk ppat
|
||
_FillCRgn ; and fill
|
||
_SetPort
|
||
MOVE.L (SP)+,theZone ; restore theZone <C949/08Nov87> DAF
|
||
BRA.S @70 ;
|
||
@69
|
||
MOVE.L GRAYRGN,-(SP) ;PUSH THE DESKTOP REGION <11/9/86 EHB>
|
||
PEA DeskPattern ; push the desk pattern
|
||
_FillRgn ; and paint the desktop
|
||
@70
|
||
MOVE.L (SP)+,TheZone ; Restore the current heap zone <SM16> FM
|
||
ENDIF
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; Utility GetNewRgn:RgnHandle
|
||
;
|
||
; This short utility is used to save code. It allocates a new region and
|
||
; returns its handle on the top of the stack.
|
||
;
|
||
|
||
GetNewRgn Proc Export
|
||
SUBQ #4,SP ;make space for result
|
||
_NewRgn ;allocate new region
|
||
MOVE.L 4(SP),A0 ;get return address
|
||
MOVE.L (SP)+,(SP) ;strip it
|
||
JMP (A0) ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SaveOld(window)
|
||
;
|
||
; SaveOld saves the parameter window's old structure and content regions
|
||
; for the "DrawNew" operation. It must be followed by a call to DrawNew;
|
||
; note that they are not nestable.
|
||
;
|
||
|
||
SaveOld Proc Export
|
||
Import GetNewRgn
|
||
|
||
MOVEM.L D3-D4/A2,-(SP) ;save work registers
|
||
BSR.S GETNEWRGN ;get "oldStruct" region
|
||
MOVE.L (SP)+,D3 ;and keep in D3
|
||
BSR.S GETNEWRGN ;get "oldCont" region
|
||
MOVE.L (SP)+,D4 ;and keep in D4
|
||
;
|
||
MOVE.L 16(SP),A2 ;get the window pointer
|
||
;
|
||
; copy the window's structRgn into oldStruct and its content region into oldCont
|
||
;
|
||
MOVE.L STRUCTRGN(A2),-(SP) ;push the structure region
|
||
MOVE.L D3,-(SP) ;push oldStruct
|
||
_CopyRgn ;oldStruct <- structRgn
|
||
MOVE.L CONTRGN(A2),-(SP) ;push the content region
|
||
MOVE.L D4,-(SP) ;push oldCont
|
||
_CopyRgn ;oldCont <- contRgn
|
||
;
|
||
; update the oldStructure and oldContent globals and return to caller
|
||
;
|
||
|
||
SODone
|
||
MOVEM.L D3-D4,OLDSTRUCTURE ;update oldStructure,Content
|
||
MOVEM.L (SP)+,D3-D4/A2 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE DrawNew(window: windowPtr; fUpdate: BOOLEAN);
|
||
;
|
||
; called after a "SaveOld" call. It updates the area
|
||
; clobbered := (oldStruct XOR newStruct) UNION (oldContent XOR newContent)
|
||
; If fUpdate is TRUE, updates are accumulated
|
||
;
|
||
;
|
||
|
||
DrawNew Proc Export
|
||
Export SixBytExit
|
||
|
||
MOVEM.L D3-D4/A2,-(SP) ;save work registers
|
||
MOVE.L 18(SP),A2 ;get the window ptr
|
||
MOVEM.L OLDSTRUCTURE,D3-D4 ;get oldStructure,Content
|
||
|
||
TST.B WVISIBLE(A2) ;is this one visible?
|
||
BEQ.S SKIPXOR ;if not, its a waste of time to XOR
|
||
;
|
||
; compute (oldStruct XOR newStruct) UNION (oldContent XOR newContent)
|
||
;
|
||
MOVE.L STRUCTRGN(A2),-(SP) ;push newStruct
|
||
MOVE.L D3,-(SP) ;push oldStruct
|
||
MOVE.L D3,-(SP) ;oldStruct gets the result
|
||
_XorRgn
|
||
;
|
||
MOVE.L CONTRGN(A2),-(SP) ;push newCont
|
||
MOVE.L D4,-(SP) ;push oldContent
|
||
MOVE.L D4,-(SP) ;oldContent gets the result
|
||
_XorRgn
|
||
;
|
||
|
||
SkipXOR
|
||
MOVE.L D4,-(SP) ;push oldContent
|
||
MOVE.L D3,-(SP) ;push oldStructure
|
||
MOVE.L D3,-(SP) ;oldStructure gets result
|
||
_UnionRgn ;union them together
|
||
;
|
||
; now paint the window clipped to the part that changed (the region in D3)
|
||
;
|
||
MOVE.B 16(SP),SAVEUPDATE ;set update flag according to fUpdate
|
||
MOVE.L A2,-(SP) ;push the window
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
_PaintOne ;paint the window
|
||
ST SAVEUPDATE ;re-enable update accumulation
|
||
;
|
||
; paint all the windows behind the parameter window as some may have been
|
||
; exposed
|
||
;
|
||
MOVE.L NEXTWINDOW(A2),-(SP) ;start with one immediately behind
|
||
MOVE.L D3,-(SP) ;clip to clobbered area
|
||
; PaintBehind in DrawNew - since we have done CalcAncestorRgns in _PaintOne, we can do a PaintBehindLite <SM16> FM
|
||
move.l ExpandMem,a0 ; <SM16> FM
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; set the one-shot to keep from recalcing ancestor rgns <SM16> FM
|
||
_PaintBehind
|
||
MOVE.L A2,-(SP) ;push the parmeter window
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
_CalcVBehind ;recalculate visRgns of behind windows
|
||
;
|
||
; dispose of oldStruct and oldContent regions and return to caller
|
||
;
|
||
MOVE.L D3,-(SP) ;push oldStructure
|
||
_DisposRgn ;dispose of it
|
||
MOVE.L D4,-(SP) ;push oldContent
|
||
_DisposRgn ;dispose of that one, too
|
||
;
|
||
MOVEM.L (SP)+,D3-D4/A2 ;restore work registers
|
||
SixBytExit
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
ADDQ #6,SP ;strip stack of 6 parameter bytes
|
||
JMP (A0) ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE ShowHide(window: windowPtr; showFlag: BOOLEAN);
|
||
;
|
||
; This is the low level routine for showing and hiding windows. It sets the
|
||
; visible state of the window according to the value of the showFlag boolean.
|
||
; A1 is preserved so ShowWindow and HideWindow can save some code
|
||
;
|
||
;
|
||
|
||
ShowHide Proc Export
|
||
Import SetWPort
|
||
Import CallWCalc
|
||
Import RestorePort
|
||
Import SixBytExit
|
||
IMPORT PreShowHide
|
||
IMPORT ptchHMGetBalloons ; <SM18> rb, start
|
||
|
||
MOVE.L A1,-(SP) ; we have to save this register (Why?, I don't know)
|
||
|
||
JSR ptchHMGetBalloons ; what is the state of What Is? mode?
|
||
BEQ.S @BalloonsOff ; EQ means no, so, let's not do anything.
|
||
|
||
SUBQ #2,SP ; room for Boolean
|
||
_HMIsBalloon ; was there a Balloon up?
|
||
TST.B (SP)+
|
||
BEQ.S @BalloonsOff ; EQ means no, so, let's exit now
|
||
|
||
MOVE.L ExpandMem,A0 ; point to the expand mem ptr
|
||
MOVE.L ExpandMemRec.emHelpGlobals(A0),A0 ; A0 = global ptr
|
||
|
||
; note: 10 = 6 + A1 saved on stack
|
||
MOVE.L 10(SP),D0 ; get the ShowHide WindowPtr that was passed
|
||
|
||
CMP.L hmgWindow(A0),D0 ; was it our balloon window?
|
||
BEQ.S @BalloonsOff ; yes, ignore _ShowHide calls with the balloon window
|
||
|
||
MOVE hmgTitleBalloon(A0),D0 ; see if one of the menu bar title balloons was up (<>0)
|
||
BNE.S @BalloonsOff ; NE means one was so just exit the patch
|
||
|
||
TST.B 8(SP) ; true if the window is becoming active
|
||
BNE.S @BalloonsOff ; NE means that somebody called ShowHide
|
||
; to show a currently showing window
|
||
@DifferentLastWindow
|
||
|
||
SUBQ #2,SP ; remove any balloons that might have been up
|
||
_HMRemoveBalloon ; do the remove
|
||
ADDQ.L #2,SP ; toss result
|
||
@BalloonsOff
|
||
MOVE.L (SP)+,A1 ; restore the return address that was in A1
|
||
; <SM18> rb, end
|
||
|
||
MOVEM.L D3-D4/A1/A3,-(SP) ;save work registers
|
||
|
||
; <SM22> FM roll in patchShowHide from WindowMgrPactches.a
|
||
; <SM22> FM
|
||
; <SM22> FM ShowHide patch for the Layer Manager
|
||
; <SM22> FM PreShowHide fixes up the regions of the windows of the layer to be shown/hidden:
|
||
; <SM22> FM If the layer is becoming visible, all the visible windows (determined by the visible flag)
|
||
; <SM22> FM will have their structRgn and contRgn recalculated.
|
||
; <SM22> FM If the layer is becoming invisble, all the windows will have their structRgn, contRgn and
|
||
; <SM22> FM visRgn emptied out.
|
||
|
||
MOVE.L 22(SP),-(SP) ; <SM22> FM Push the WindowPtr on the stack
|
||
MOVE.B 24(SP),-(SP) ; <SM22> FM Push the show/hide flag on the stack <PN><SM20)
|
||
jsr PreShowHide ; <SM22> FM fix up regions on Layer Hides/Reveals
|
||
|
||
MOVE.L 22(SP),A3 ;get the window pointer
|
||
MOVE.B 20(SP),D3 ; get showFlag <EHB 28-Oct-85>
|
||
MOVE.B WVisible(A3),D0 ; get wvisible flag <EHB 28-Oct-85>
|
||
EOR.B D3,D0 ; already in requested state? <EHB 28-Oct-85>
|
||
LSR #1,D0 ; only bit 0 is significant <EHB 28-Oct-85>
|
||
BCC.S SHDONE ; => same as before <EHB 28-Oct-85>
|
||
|
||
BSR.S SETWPORT ;get into the wmgrPort
|
||
MOVE.L A3,-(SP) ;push window pointer
|
||
_SaveOld ;save old state of struct and cont
|
||
;
|
||
MOVE.B D3,WVISIBLE(A3) ; set new state of visible
|
||
BSR CALLWCALC ;recalculate regions
|
||
;
|
||
MOVE.L A3,-(SP) ;push window
|
||
ST -(SP) ;fUpdate = TRUE (accumulate updates)
|
||
_DrawNew ;draw the new state
|
||
;
|
||
BSR.S RESTOREPORT ;restore saved grafPort
|
||
|
||
TST.B WVisible(A3) ; is this window visible now? <12May87 DAF>
|
||
BEQ.S SHDONE ; if not visible, don't activate palette <12May87 DAF>
|
||
|
||
MOVE.L A3,-(SP) ; push the window pointer <12May87 DAF>
|
||
_ActivatePalette ; and activate it
|
||
;
|
||
SHDone
|
||
MOVEM.L (SP)+,D3-D4/A1/A3 ;save work registers
|
||
BRA SIXBYTEXIT ;standard exit saves code
|
||
EndProc
|
||
|
||
;
|
||
; Utility SetWPort;
|
||
;
|
||
; SetWPort is a utility used to save code. It gets the current grafPort into
|
||
; D4 (for later restoring by RestorePort) and sets the port to the wmgrPort
|
||
;
|
||
|
||
SetWPort Proc Export
|
||
MOVE.L grafGlobals(A5),A0 ;get pointer to lisaGraf globals
|
||
MOVE.L thePort(A0),D4 ;get the current port
|
||
MOVE.L WMgrPort,ThePort(A0) ;push the wmgrPort pointer
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; Utility RestorePort;
|
||
;
|
||
; RestorePort is a utility used to save code. It sets the grafPort to
|
||
; the window pointer saved in D4.
|
||
;
|
||
|
||
RestorePort Proc Export
|
||
MOVE.L D4,-(SP) ;push the old grafPort
|
||
GoSetPort
|
||
_SetPort ;and set it
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE GetWMgrPort(VAR wPort: windowPtr);
|
||
;
|
||
; access routine that returns pointers to the window manager's port
|
||
;
|
||
|
||
GetWMgrPort Proc Export
|
||
|
||
BLANKS ON
|
||
STRING ASIS
|
||
|
||
MOVE.L (SP)+,A1 ;get return address
|
||
MOVE.L (SP)+,A0 ;get pointer to wmgrPort variable
|
||
MOVE.L WMGRPORT,(A0) ;move it in
|
||
JMP (A1) ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE GetCWMgrPort(VAR wPort: windowPtr);
|
||
;
|
||
; access routine that returns pointers to the window manager's cGrafPort
|
||
;
|
||
|
||
GetCWMgrPort Proc Export
|
||
MOVE.L (SP)+,A1 ;get return address
|
||
MOVE.L (SP)+,A0 ;get pointer to wmgrPort variable
|
||
MOVE.L wmgrCPort,(A0) ;move it in
|
||
JMP (A1) ;return to caller
|
||
EndProc
|
||
|
||
|
||
|
||
;
|
||
; Utility AllocPort -- a little utility to save some code
|
||
;
|
||
; D1 is non-zero to open a color port
|
||
;
|
||
|
||
AllocPort Proc Export
|
||
Export AllocP1
|
||
Export AllocP2
|
||
Export AllocCPort
|
||
|
||
MOVEQ #PortRec,D0 ;get size of a grafPort <C106 EHB>
|
||
MOVEQ #0,D1 ;say it's a black and white port <C106 EHB>
|
||
AllocP1 _NewPtr ;allocate the grafPort <C106 EHB>
|
||
AllocP2 MOVE.L A0,A3 ;remember it in A3 <C106 EHB>
|
||
MOVE.L A0,-(SP) ;push it as parameter to OpenPort <C106 EHB>
|
||
TST D1 ;black and white or color? <C106 EHB>
|
||
BNE.S AllocCPort ;=>color <C106 EHB>
|
||
_OpenPort ;open it <C106 EHB>
|
||
RTS ; <C106 EHB>
|
||
AllocCPort
|
||
_OpenCPort ;open a color port <C106 EHB>
|
||
|
||
RTS ;and return <C106 EHB>
|
||
EndProc
|
||
|
||
|
||
;
|
||
; PROCEDURE InitWindowsGuts <SM16> FM
|
||
;
|
||
; High-level routine to initialize the window world. Will eventually be
|
||
; called during SYSINIT but now must be called by the application.
|
||
;
|
||
; This routine is now called InitWindowsGuts because it is called from the middle <SM16> FM
|
||
; of InitLayers to do the low level WindowMgr initialization. <SM16> FM
|
||
;
|
||
|
||
InitWindowsGuts Proc Export
|
||
Import AllocPort
|
||
Import AllocP1
|
||
Import GetNewRgn
|
||
Import CalcMBHeight
|
||
Import DrawMBar
|
||
|
||
; Stack Frame definition ; <C203> DAF
|
||
|
||
LocalVar EQU 0 ; stack frame eliminated <C491/08Dec86> DAF
|
||
|
||
LINK A6,#LocalVar ; make a stack frame <C203> DAF
|
||
MOVEM.L D3-D7/A3-A4,-(SP) ;save work registers
|
||
|
||
; Added patches: cancel pending PaintBehind; reset alarm parity; and say
|
||
; that the window world exists. <EHB 1/23/85>
|
||
|
||
MOVEQ #7,D0 ; handy bit number <EHB 1/23/85>
|
||
BSET D0,DSWndUpdate ; cancel pending PaintBehind <EHB 1/23/85>
|
||
BSET D0,AlarmState ; reset alarm parity <EHB 1/23/85>
|
||
|
||
MOVE.L MinusOne,SaveUpdate ;enable update accumulation and erasing
|
||
|
||
; set up the deskPattern from Sys.resource
|
||
|
||
SUBQ #4,SP ;make room for function result
|
||
MOVE #deskPatID,-(SP) ;push pattern ID of deskPattern
|
||
_GetPattern ;tell resource manager to get it
|
||
MOVE.L (SP)+,A0 ;get the pattern handle
|
||
MOVE.L (A0),A0 ;get pattern pointer
|
||
MOVE.L (A0)+,DeskPattern ;init the deskPattern
|
||
MOVE.L (A0),DeskPattern+4 ;don't forget 2nd half of it
|
||
|
||
TST.B pCDeskPat ; test flag <C725/31Jan87 DAF>
|
||
BPL.S @12 ; if hi bit clear, don't load ppat <C725/31Jan87 DAF>
|
||
;
|
||
; load the DeskCPat from the system if pCDeskPat enabled
|
||
; Switch to the system zone temporarily, so that GetPixPat will allocate
|
||
; it's private storage on the system heap (it normally allocates on theZone)
|
||
;
|
||
|
||
MOVE.L TheZone,-(SP) ; save it <C666/22Jan87> DAF
|
||
MOVE.L SysZone,TheZone ; get the system zone <C666/22Jan87> DAF
|
||
|
||
MOVE.L DeskCPat,D0 ; get the current pattern <1.3>
|
||
BEQ.S @100 ; if NIL, then continue <1.3>
|
||
CMP.L MinusOne,D0 ; is it uninitialized? <1.3>
|
||
BEQ.S @100 ; if so, then continue <1.3>
|
||
MOVE.L D0,-(SP) ; push old pat handle <1.3>
|
||
_DisposPixPat ; release it <1.3>
|
||
|
||
@100
|
||
SUBQ #4,SP ; make room for function result
|
||
MOVE #deskPatID,-(SP) ; push pattern ID of deskCPat
|
||
_GetPixPat ; tell resource manager to get it from system
|
||
MOVE.L (SP)+,DeskCPat ; put handle to pattern in lomem <C725/31Jan87 DAF>
|
||
BNE.S @30 ; if not present, use binary pat <C725/31Jan87 DAF>
|
||
BCLR #7,pCDeskPat ; clear the cDeskPat bit <C725/31Jan87 DAF>
|
||
@30
|
||
MOVE.L (SP)+,theZone ; restore the app's zone <C666/22Jan87> DAF
|
||
@12
|
||
|
||
;
|
||
; allocate and init the window manager's port
|
||
;
|
||
BSR AllocPort
|
||
MOVE.L A3,WMGRPORT ;make it the wmgrPort
|
||
|
||
;
|
||
; also allocate the wmgr COLOR port! ; <C203/06Oct86> DAF
|
||
; note that both ports share the same handles to vis & clip regions!
|
||
; The other fields should not be changed during normal usage
|
||
;
|
||
; <13Nov86 EHB> Save visRgn and clipRgn in D6 and D7 for later use
|
||
;
|
||
MOVE.L A3,A4 ; hold this for a moment <C203/06Oct86> DAF
|
||
MOVE.L visRgn(A4),D6 ; deallocate oldport's regions <C203/06Oct86> DAF
|
||
MOVE.L clipRgn(A4),D7 ; cGrafPort's regions <C203/06Oct86> DAF
|
||
MOVE.L #PortRec,D0 ; get color port size for NewPtr <C203/06Oct86> DAF
|
||
MOVEQ #-1,D1 ; non-zero means color port <C203/06Oct86> DAF
|
||
BSR AllocP1 ; <C203/06Oct86> DAF
|
||
MOVE.L A3,wmgrCPort ; set up lomem <C203/06Oct86> DAF
|
||
MOVE.L visRgn(A3),visRgn(A4) ; copy the handles to old port <C203/06Oct86> DAF
|
||
MOVE.L clipRgn(A3),clipRgn(A4) ; <C203/06Oct86> DAF
|
||
|
||
MOVE.L A4,A3
|
||
MOVE.L A3,-(SP) ; push the old port
|
||
_SetPort ; set it back
|
||
|
||
; Initialize DeskRgn, the union of all screen devices. Set WmgrPort.VisRgn to DeskRgn.
|
||
; The bounding box of DeskRgn region is what we will use to black out the corners.
|
||
|
||
MOVE.L D7,-(SP) ; push DeskRgn <13Nov86 EHB>
|
||
_SetEmptyRgn ; and empty it out <13Nov86 EHB>
|
||
MOVE.L DEVICELIST,A4 ; get handle to main screen <13Nov86 EHB>
|
||
DoNextDev
|
||
MOVE.L (A4),A0 ; point at main screen device <13Nov86 EHB>
|
||
TST GDFlags(A0) ; is device active? <C768>
|
||
BPL.S @NxtDev ; =>no, try next device <C768>
|
||
MOVE.L D6,-(SP) ; push ScreenRgn <13Nov86 EHB>
|
||
MOVE.L GDRect+TopLeft(A0),-(SP); push topleft of device's rect <13Nov86 EHB>
|
||
MOVE.L GDRect+BotRight(A0),-(SP) ; push botright <13Nov86 EHB>
|
||
_SetRecRgn ; get ScreenRgn <13Nov86 EHB>
|
||
MOVE.L D6,-(SP) ; push ScreenRgn <13Nov86 EHB>
|
||
MOVE.L D7,-(SP) ; push DeskRgn <13Nov86 EHB>
|
||
MOVE.L D7,-(SP) ; get result in DeskRgn <13Nov86 EHB>
|
||
_UnionRgn ; add screen to desk <13Nov86 EHB>
|
||
@NxtDev
|
||
MOVE.L (A4),A0 ; point to grafDevice <13Nov86 EHB>
|
||
MOVE.L GDNextGD(A0),D0 ; get next grafDevice <13Nov86 EHB>
|
||
MOVE.L D0,A4 ; save in A4 <13Nov86 EHB>
|
||
BNE.S DoNextDev ; => more devices to do <13Nov86 EHB>
|
||
|
||
MOVE.L D7,-(SP) ; push the DeskRgn <13Nov86 EHB>
|
||
MOVE.L VisRgn(A3),-(SP) ; push the port's visRgn <13Nov86 EHB>
|
||
_CopyRgn ; visRgn := DeskRgn <13Nov86 EHB>
|
||
|
||
|
||
|
||
IF hasDisplayMgrWindows THEN ; <SM81>
|
||
; Now that the WMgr port is initialized, initialize the Display Manager
|
||
; We must do this between when the WMgrPort is initialized and when the desktop is drawn
|
||
subq.l #2,sp ; init display manager (now that wmgrport is set up)
|
||
_DMInitDisplayManager
|
||
move.w (sp)+,d0 ; get result
|
||
ENDIF
|
||
|
||
; initialize the screen by drawing the menu bar, blacking out the corners, and then
|
||
; filling the rest with the deskPattern.
|
||
;
|
||
; draw the empty menu bar, leaving the clip region set to the menuBar
|
||
|
||
_InitMenus ; init the mbar defproc <C168/17Sep86>DAF
|
||
JSR CalcMBHeight ; use menu mgr routine to calc new size <EHB 5Aug85>
|
||
JSR DrawMBar ; use menu mgr routine to save code
|
||
|
||
; set TempRect to the DeskRgn's bounding box
|
||
|
||
MOVE.L D7,A0 ; get deskRgn <13Nov86 EHB>
|
||
MOVE.L (A0),A0 ; and point at it <13Nov86 EHB>
|
||
LEA RgnBBox(A0),A0 ; point to deskRgn bounding box <13Nov86 EHB>
|
||
|
||
LEA TempRect,A4 ; get a temp rect
|
||
MOVE.L A4,A1 ; get a copy to trash
|
||
MOVE.L (A0)+,(A1)+ ; copy the deskRect
|
||
MOVE.L (A0),(A1)
|
||
|
||
; initialize the gray region
|
||
|
||
BSR GETNEWRGN ; allocate a region
|
||
MOVE.L (SP)+,D5 ; keep grayRgn in D5
|
||
MOVE.L D5,GRAYRGN ; update grayRgn global
|
||
|
||
_HidePen ; don't really draw this
|
||
_OpenRgn ; start recording a region
|
||
|
||
; <SM26> CSS Rollin patch from Horror: InitWindowsRgnPatch
|
||
; InitWindowsRgnPatch - Decides whether WMgrCPort part of the GrayRgn should be
|
||
; round or square. LCD displays have square regions and
|
||
; CRT displays have rounded ones.
|
||
IF hasPwrControls THEN ; <SM81>
|
||
IMPORT LCDScreenChk ; <SM26> CSS
|
||
BigJsr LCDScreenChk,a0 ; If we don’t have an LCD screen,
|
||
BEQ.S @DoNormalCode ; then just go on.
|
||
|
||
Move.l A4,-(Sp) ; Push the temp rect.
|
||
_FrameRect ; Draw it.
|
||
BRA.S @DontRound
|
||
@DoNormalCode
|
||
ENDIF
|
||
|
||
MOVE.L A4,-(SP) ; push the temp rect <13Nov86 EHB>
|
||
MOVE.L #ScreenRadius,-(SP) ; with rounded corners
|
||
_FrameRoundRect ; draw it
|
||
@DontRound
|
||
; SKH, fixed SM mistake, the grayRgn was not being pushed onto the stack <SM38>
|
||
|
||
MOVE.L D5,-(SP) ; push the grayRgn
|
||
_CloseRgn ; initialize the gray region
|
||
_ShowPen ; show the pen again
|
||
|
||
; subtract the menu bar from the gray region
|
||
|
||
MOVE.L D5,-(SP) ; push the gray region
|
||
MOVE.L ClipRgn(A3),-(SP) ; push the clipRgn (menuBar only)
|
||
MOVE.L D5,-(SP) ; grayRgn gets the result
|
||
_DiffRgn ; grayRgn := grayRgn - menuBar
|
||
|
||
; finally intersect the gray region with the deskRegion
|
||
|
||
MOVE.L D7,-(SP) ; push the deskRgn <13Nov86 EHB>
|
||
MOVE.L D5,-(SP) ; push the gray region <13Nov86 EHB>
|
||
MOVE.L D5,-(SP) ; get result in gray region <13Nov86 EHB>
|
||
_SectRgn
|
||
|
||
; set the wmgrPort clipRgn to the wide open region
|
||
|
||
MOVE.L GRAFGLOBALS(A5),A0 ; get grafglobals <13Nov86 EHB>
|
||
MOVE.L WIDEOPEN(A0),-(SP) ; push wide open region <13Nov86 EHB>
|
||
_SetClip ; set clipRgn to wideopen <13Nov86 EHB>
|
||
|
||
;<SM26> CSS Rollin patch: InitWIndowsRgnPatch from Horror:
|
||
; InitWindowsFramePatch - Decides whether the corners of the screen should be rounded
|
||
; or not. LCD displays don’t have rounded corners while CRT
|
||
; displays do.
|
||
|
||
IF hasPwrControls THEN ; <SM26> CSS <SM81>
|
||
IMPORT LCDScreenChk ; <SM26> CSS
|
||
BigJsr LCDScreenChk,a0 ; do we have an LCD screen? <SM26> CSS
|
||
BNE.S @doneRounding ; don't round the corners
|
||
ENDIF
|
||
|
||
; black out the corners of the desk
|
||
|
||
MOVE.L A4,-(SP) ; push the temp rect
|
||
MOVE.L #$FFFDFFFD,-(SP) ; and make it bigger
|
||
_InsetRect ; by 3 pixels on each side
|
||
|
||
MOVE.L #$00030003,-(SP) ; get a wider pen
|
||
_PenSize
|
||
|
||
MOVE.L A4,-(SP) ; push the port rect
|
||
MOVE.L #$00160016,-(SP) ; and a radius for nice rounding
|
||
_FrameRoundRect ; and black out the corners
|
||
_PenNormal ; fix the pen back up
|
||
|
||
IF hasPwrControls THEN ; <SM26> CSS <SM81>
|
||
@doneRounding
|
||
ENDIF
|
||
|
||
IF hasDisplayMgrWindows THEN ;
|
||
MOVE.L D5,-(SP) ; push grayRgn <13Nov86 EHB>
|
||
_DMDrawDesktopRegion
|
||
ELSE
|
||
; and paint gray rgn with old or new pattern
|
||
|
||
MOVE.L D5,-(SP) ; push grayRgn <13Nov86 EHB>
|
||
TST.B pCDeskPat ; test flag to see which to use <C666/22Jan87> DAF
|
||
BPL.S @UseOldPat ; if hi bit clear, then use binary pat
|
||
MOVE.L wmgrCPort,-(SP) ; set the cgrafPort for color patterns
|
||
_SetPort ;
|
||
MOVE.L DeskCPat,-(SP) ; push the desk PPAT
|
||
_FillCRgn ; and fill the gray region
|
||
MOVE.L wmgrPort,-(SP) ; restore the wmgrPort
|
||
_SetPort ;
|
||
BRA.S @DonePat ;
|
||
@UseOldPat PEA DeskPattern ; push the desk pattern
|
||
_FillRgn ; and paint the desktop <13Nov86 EHB>
|
||
|
||
@DonePat
|
||
|
||
ENDIF
|
||
|
||
; set the wmgrPort clipRgn to the gray region
|
||
|
||
MOVE.L D5,-(SP) ; push grayRgn
|
||
_SetClip ; set clipRgn to grayRgn
|
||
|
||
; make sure the cursor is visible
|
||
|
||
_ShowCursor
|
||
;
|
||
; initialize the window list to empty
|
||
;
|
||
CLR.L WindowList
|
||
|
||
;
|
||
; set up the AuxWinList ; <C59/30Jun86> DAF
|
||
;
|
||
MOVE.L #AuxWinSize,D0 ;set up for newHandle <C59/30Jun86> DAF
|
||
_NewHandle ,CLEAR ;allocate a new record (init fields to NIL, too) <C59/30Jun86> DAF
|
||
MOVE.L A0,A4 ;copy the handle <C59/30Jun86> DAF
|
||
_HLock ;lock that bad boy (no BUS ERRORs!) <C491/08Dec86> DAF
|
||
MOVE.L A4,AuxWinHead ;set up list head <C59/30Jun86> DAF
|
||
MOVE.L (A4),A3 ;get a pointer to the default <C59/30Jun86> DAF
|
||
SUBQ #4,SP ;leave room for the function result <C666/22Nov87> DAF
|
||
MOVE.L #'wctb',-(SP) ;push the resource type <C666/22Nov87> DAF
|
||
CLR.W -(SP) ;get wctb=0 <C666/22Nov87> DAF
|
||
_rGetResource ;get from disk or ROM (last) <C666/22Nov87> DAF
|
||
@1 MOVE.L (SP)+,awCTable(A3) ;set up the colortable <C666/22Nov87> DAF<1.7>
|
||
MOVE.L A4,A0 ;copy the handle to unlock
|
||
_HUnlock ;unlock the auxWinRec <C491/08Dec86> DAF
|
||
|
||
;
|
||
; since there's no InitControls, set up the AuxCtlList <C59/30Jun86> DAF
|
||
;
|
||
MOVE.L #acSize,D0 ;set up for newHandle <C59/30Jun86> DAF<1.7>
|
||
_NewHandle ,CLEAR ;allocate a new record (init fields to NIL, too) <C59/30Jun86> DAF
|
||
MOVE.L A0,A4 ;copy the handle <C59/30Jun86> DAF
|
||
_HLock ;lock it down <C491/08Dec86> DAF
|
||
MOVE.L A4,AuxCtlHead ;set up list head <C59/30Jun86> DAF
|
||
MOVE.L (A4),A3 ;get a pointer to the default <C59/30Jun86> DAF
|
||
SUBQ #4,SP ;leave room for the function result <C666/22Nov87> DAF
|
||
MOVE.L #'cctb',-(SP) ;push the resource type <C666/22Nov87> DAF
|
||
CLR.W -(SP) ;get cctb=0 <C666/22Nov87> DAF
|
||
_rGetResource ;get from disk or ROM (last) <C666/22Nov87> DAF
|
||
@2 MOVE.L (SP)+,acCTable(A3) ;set up the colortable <C666/22Nov87> DAF<1.7>
|
||
MOVE.L A4,A0 ;copy the handle to unlock
|
||
_HUnlock ;unlock the auxCtlRec <C491/08Dec86> DAF
|
||
|
||
;
|
||
; allocate saveVisRgn, a region used to save the visRgn during updates
|
||
;
|
||
BSR GETNEWRGN ;allocate a region
|
||
MOVE.L (SP)+,SAVEVISRGN ;update saveVisRgn global
|
||
;
|
||
; initialize window manager globals (and desk mgr)
|
||
;
|
||
CLR.L GhostWindow ;init ghostWindow pointer
|
||
|
||
LEA CurActivate,A0 ;get address of activate buffer
|
||
CLR.L (A0)+ ;clear it
|
||
CLR.L (A0)+ ;clear deactivate, too
|
||
|
||
;
|
||
; flag that the window manager has now been initialized
|
||
;
|
||
|
||
CLR.B WWExist ; say the window world exists <1.5> DAF
|
||
|
||
MOVE.L D6,-(SP) ; dispose of WMGRCPORT visRgn <13Nov86 EHB>
|
||
_DisposRgn
|
||
MOVE.L D7,-(SP) ; and WMGRCPORT clipRgn <13Nov86 EHB>
|
||
_DisposRgn
|
||
|
||
_InitPalettes ; init palette manager <12May87 DAF>
|
||
|
||
;
|
||
; all done -- restore registers return to caller
|
||
;
|
||
MOVEM.L (SP)+,D3-D7/A3-A4 ;restore work registers
|
||
UNLK A6 ; bag the stack frame <C203> DAF
|
||
RTS
|
||
EndProc
|
||
|
||
;----------------------------------------------------------------------------
|
||
;
|
||
; FUNCTION NewCWindow( wStorage: Ptr;
|
||
; pboundsRect: Rect;
|
||
; pTitle: String;
|
||
; pVisible: BOOLEAN;
|
||
; theProc: INTEGER;
|
||
; pBehind: WindowPtr;
|
||
; pGoAway: BOOLEAN;
|
||
; pRefCon: LongInt; ): windowPtr;
|
||
;
|
||
; Allocates and initializes a new color window, and returns a pointer to it
|
||
;
|
||
; Roll in new 'NewCWindow' from WindowMgrPatches.a which rewrites the whole thing in C <SM 2><PN>
|
||
|
||
NEWCWINDOW PROC EXPORT
|
||
IMPORT NewWindowCommon ;in layermgr.c <PN>
|
||
MOVE.L (SP)+, A0
|
||
ST -(SP)
|
||
MOVE.L A0, -(SP)
|
||
IMPORT NewWindowCommon
|
||
JMP NewWindowCommon
|
||
ENDPROC
|
||
; end roll in
|
||
|
||
;----------------------------------------------------------------------------
|
||
;
|
||
; FUNCTION NewWindow( wStorage: Ptr;
|
||
; pboundsRect: Rect;
|
||
; pTitle: String;
|
||
; pVisible: BOOLEAN;
|
||
; theProc: INTEGER;
|
||
; pBehind: WindowPtr;
|
||
; pGoAway: BOOLEAN;
|
||
; pRefCon: LongInt; ): windowPtr;
|
||
;
|
||
; Allocates and initializes a new window, and returns a pointer to it
|
||
; Roll in new 'NewWindow' from WindowMgrPatches.a which rewrites the whole thing in C <SM 2><PN>
|
||
NewWindow PROC EXPORT
|
||
IMPORT NewWindowCommon ;in layermgr.c <PN>
|
||
|
||
MOVE.L (SP)+, A0
|
||
CLR.B -(SP)
|
||
MOVE.L A0, -(SP)
|
||
JMP NewWindowCommon
|
||
ENDPROC
|
||
; end roll in
|
||
|
||
|
||
; Utility CancelActivate -- takes a window pointer and checks to see if
|
||
; that address is in either the CurActivate or the curDeactive locations.
|
||
; If it is, sets the high bit of that address. Has the effect of
|
||
; cancelling pending activate events. Trashes A0, D0 and D1.
|
||
|
||
; Note: patch worked by clearing curActivate or curDeactive. This doesn't work
|
||
; because if a window was both curActivate and curDeactive, then both are cleared
|
||
; and next GetNextEvent on an activate doesn't set sys<->app bit. Solved by
|
||
; cancelling event by setting high bit. See also: fix in DoActivate.
|
||
|
||
CancelActivate Proc Export
|
||
LEA CurActivate,A0 ; check curActivate first <EHB 1/23/85>
|
||
MOVE.L A3,D0 ; get window pointer <EHB 1/23/85>
|
||
BSR.S @1 ; into D0 <EHB 1/23/85>
|
||
ADDQ #4,A0 ; now do curDeactive <EHB 1/23/85>
|
||
@1
|
||
MOVE.L (A0),D1 ; get current active/deactive ptr <EHB 1/23/85>
|
||
EOR.L D0,D1 ; compare addresses <EHB 1/23/85>
|
||
AND.L MaskBC,D1 ; minus the high bits <EHB 1/23/85>
|
||
BNE.S @2 ; oops, not the same address <EHB 1/23/85>
|
||
BSET #7,(A0) ; else cancel the event <EHB 1/23/85>
|
||
@2
|
||
RTS ; <EHB 1/23/85>
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE CloseWindow(window);
|
||
;
|
||
; hides a window, unlinks it from the window list and disposes of all
|
||
; the storage it uses except for the window itself.
|
||
;
|
||
|
||
CloseWindowGuts Proc Export
|
||
Import SetWPort
|
||
Import CancelActivate
|
||
Import CallWindow
|
||
Import DeleteWindow
|
||
Import RestorePort
|
||
Import DoActivate
|
||
Import __ActiveWindow
|
||
|
||
MOVEM.L D3-D4/A2/A3,-(SP) ;save working registers <1.4/DAF>
|
||
MOVE.L 20(SP),A3 ;get window pointer
|
||
BSR SETWPORT ;set the port to the wmgrPort
|
||
|
||
; Cancel pending activate events. (This cancels activates for DisposeWindow too)
|
||
|
||
BSR.S CancelActivate ; <EHB 1/23/85>
|
||
|
||
SUBQ #4,SP ;make room for frontWindow result
|
||
JSR __ActiveWindow ; <SM16> FM This was _FrontWindow
|
||
; But we need Active window with layers
|
||
|
||
;
|
||
; <SM16> FM Moved the show hide call before the KillControls call
|
||
; <SM16> FM Preventing unecessary drawing as controls are disposed.
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
CLR.W -(SP) ;say "Hide"
|
||
_ShowHide ;hide the window
|
||
|
||
;
|
||
; dispose of all the controls in the window
|
||
;
|
||
MOVE.L A3,-(SP) ;push the window ptr
|
||
_KillControls ;get rid of them
|
||
|
||
MOVEQ #WDisposeMsg,D0 ;tell window to dispose of private data
|
||
BSR CallWindow ;send window dispose message
|
||
;
|
||
; dispose of palette, then auxWinRec if present. To do this, do a SetWinColor with the
|
||
; request being the default colortable (which deletes the auxWinRec).
|
||
; If we are in 24-bit mode, then set the default color table which will delete the auxWinRec and
|
||
; color table if it's not a resource. In 32-bit mode, also set the default color table which
|
||
; will delete the color table if it's not the default, then remove the auxWinRec upon return.
|
||
;
|
||
|
||
TST PORTBITS+ROWBYTES(A3) ; is it new?
|
||
BPL.S @NotNew ; => no
|
||
|
||
MOVE.L GrafVars(A3),A0 ; get grafVar handle
|
||
MOVE.L (A0),A0 ; point at grafVars
|
||
MOVE.L PmFgColor(A0),D0 ; is there a palette
|
||
BEQ.S @NotNew ; => no
|
||
|
||
Move.L D0,A0 ; let's use an address register AWC.PB457
|
||
Move.L (A0),A0 ; dereference it AWC.PB457
|
||
BTst #DisposeBit,pmPrivate(A0) ; should we dispose of it? AWC.PB457
|
||
Beq.S @NotNew ; no => the user has to dispose of it AWC.PB457
|
||
|
||
MOVE.L D0,-(SP) ; else push palette
|
||
_DisposePalette ; and dump it
|
||
@NotNew
|
||
MOVE.L A3,-(SP) ; push handle for SetWinColor later
|
||
SUBQ #4+2,SP ; make room for VAR return and boolean func result <1.4/DAF>
|
||
CLR.L -(SP) ; push the window pointer
|
||
PEA 6(SP) ; push a pointer to the cTabHndl placeholder
|
||
_GetAuxWin ; get the default cTabHndl
|
||
ADDQ #2,SP ; dump the function result
|
||
MOVE.L (SP)+,A0 ; get the default winRec handle
|
||
MOVE.L (A0),A0 ; get the default ptr
|
||
MOVE.L awCTable(A0),-(SP) ; push default colors hndl <1.7>
|
||
|
||
TST.B MMU32Bit ; are we in 32-bit mode? <1.4/DAF>
|
||
BEQ.S @WinRec24 ; nope, so get rid of it the easy, old-fashioned way <1.4/DAF>
|
||
|
||
LEA AuxWinHead,A1 ; get the head of the auxWinList (offset is zero so this works!)
|
||
@10
|
||
MOVE.L (A1),A2 ; get the handle to the auxWinRec
|
||
MOVE.L (A2),A0 ; get the pointer to the auxWinRec
|
||
CMP.L awOwner(A0),A3 ; is this the one? <1.7>
|
||
BEQ.S @20 ; yes, so remove it
|
||
LEA awNext(A0),A1 ; get the next one <1.7>
|
||
BRA.S @10
|
||
|
||
@20 MOVE.L awNext(A0),(A1) ; link around the closing window <1.7>
|
||
MOVE.L A2,A1 ; copy the dead auxWinRec handle
|
||
MOVE.L (A1),A1 ; get a pointer to it
|
||
MOVE.L awCTable(A1),D0 ; get the doomed color table handle <1.7>
|
||
CMP.L (SP)+,D0 ; does this doomed record have the same color table as the default?
|
||
BEQ.S @30 ; if so, then don't delete it
|
||
MOVE.L D0,A0 ; get the doomed ctab handle in A0
|
||
_HGetState ; get the tag bits of this color table
|
||
BTST #resource,D0 ; is the resource bit set?
|
||
BNE.S @30 ; if so, don't delete it (it the app's responsibility)
|
||
_DisposHandle ; kill the color table
|
||
@30
|
||
MOVE.L A2,A0 ; release the auxWinRec
|
||
_DisposHandle ;
|
||
ADDQ #4,SP ; get rid of the extra window pointer pushed above
|
||
BRA.S @WinRecDone ;
|
||
|
||
@WinRec24
|
||
_SetWinColor ; set this window's colors to default
|
||
|
||
@WinRecDone
|
||
|
||
MOVE.L A3,-(SP) ;push windowPtr
|
||
BSR DELETEWINDOW ;splice it out of the list
|
||
;
|
||
; now that the visual stuffs taken care off, free up the storage of the window
|
||
; data structure
|
||
;
|
||
MOVE.L WTitleHandle(A3),A0 ;get the title string handle
|
||
_DisposHandle
|
||
|
||
MOVE.L StructRgn(A3),-(SP) ;push the structRgn
|
||
_DisposRgn ;dispose it
|
||
MOVE.L CONTRGN(A3),-(SP) ;push the content region
|
||
_DisposRgn ;dispose it
|
||
MOVE.L UPDATERGN(A3),-(SP) ;ditto for the update Rgn
|
||
_DisposRgn ;dispose it
|
||
|
||
MOVE.L A3,-(SP) ;push pointer to port
|
||
|
||
TST portVersion(A3) ; is this a Window or cWindow? <C733/02Feb87> DAF
|
||
BPL.S @Old ; if +, then old port <C733/02Feb87> DAF
|
||
_CloseCPort ; if cWindow, close cPort <C733/02Feb87> DAF
|
||
BRA.S @Dunn ; all done <C733/02Feb87> DAF
|
||
@Old
|
||
_ClosePort ;deallocate vis and clip
|
||
@Dunn ; <C733/02Feb87> DAF
|
||
;
|
||
MOVE.L windowPic(A3),D0 ;get picture handle
|
||
BEQ.S @1 ;if it doesnt have one, skip
|
||
|
||
MOVE.L D0,-(SP) ;get the picture handle
|
||
_KillPicture ;dispose it
|
||
|
||
@1 CMP.L (SP)+,A3 ;was it the old frontWindow?
|
||
BNE.S @2 ;if not, we're done
|
||
|
||
MOVE.W windowKind(A3),CurDeKind ;get kind of old one
|
||
|
||
SUBQ #4,SP ;make room for frontWindow result
|
||
JSR __ActiveWindow ; <SM16> FM This was _FrontWindow
|
||
; But with the Layer manager we
|
||
; have to use ActiveWindow to get the
|
||
; most truly frontmost window.
|
||
|
||
BSR DoActivate ;select the new frontWindow
|
||
|
||
; if thePort was set to the window we just closed, leave it set to the window manager port
|
||
|
||
@2
|
||
CMP.L D4,A3 ; was old grafPort our window? <EHB 31 Jan 85>
|
||
BEQ.S StdExitOne ; =>yes, leave ThePort=WmgrPort <EHB 31 Jan 85>
|
||
BSR RESTOREPORT ; else restore old grafPort
|
||
StdExitOne
|
||
MOVEM.L (SP)+,D3-D4/A2/A3 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS
|
||
EndProc
|
||
|
||
; Utility MakeDeactive -- takes a window ptr in D0. It unhilites the window
|
||
; and posts the deactivate only if there wasn't one already posted
|
||
|
||
MakeDeactive Proc Export
|
||
MOVE.L D0,-(SP) ;push the window ptr
|
||
|
||
MOVE.L D0,-(SP) ;push it again for hilite
|
||
CLR.W -(SP) ;hilite = false
|
||
_HiliteWindow ;unhilite it
|
||
|
||
MOVE.L (SP)+,D0 ;get window pointer back
|
||
TST.L CurDeactive ;is the one in there already?
|
||
BGT.S @1 ;if so, dont post it
|
||
|
||
MOVE.L D0,A0 ;get the window pointer
|
||
MOVE.W windowKind(A0),CurDeKind ;get kind of old one
|
||
|
||
MOVE.L D0,curDeactive ;post the event!
|
||
@1
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE DisposeWindow(theWindow: windowPtr);
|
||
;
|
||
; does a close window and then disposes of the window itself -- it assumes
|
||
; the window's storage was allocated on the heap
|
||
;
|
||
|
||
DisposeWindow Proc Export
|
||
MOVE.L 4(SP),-(SP) ;push "theWindow"
|
||
_CloseWindow ;close it <EHB 1/25/85>
|
||
MOVE.L (SP)+,A1 ;get the return address
|
||
MOVE.L (SP)+,A0 ;get the window
|
||
_DisposPtr ;dispose of it
|
||
JMP (A1) ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE ShowWindow(theWindow: windowPtr);
|
||
;
|
||
; make the parameter window visible (if its not already). Use the "ShowHide"
|
||
; utility routine to do the real work. Also, select the window if its
|
||
; going to be the top one.
|
||
;
|
||
|
||
ShowWindow Proc Export
|
||
|
||
MOVE.L WindowList,A0 ;get base of windowList
|
||
|
||
; in this loop we see if we can find this window before any visible one
|
||
|
||
SFLoop
|
||
TST.B WVisible(A0) ;is this one visible?
|
||
BNE.S justShowIt ;if so, we're not frontWindow
|
||
|
||
CMP.L 4(SP),A0 ;is this one us?
|
||
BEQ.S ShowSelect ;if so, better go select it
|
||
|
||
MOVE.L NextWindow(A0),A0 ;try the next one
|
||
MOVE.L A0,D0 ;is it NIL?
|
||
BNE.S SFLoop ;if not, try again
|
||
|
||
; the window isn't before FrontWindow so just show it
|
||
|
||
JustShowIt
|
||
MOVE.L 4(SP),-(SP) ; push the window for the call to ShowHide <SM16> FM
|
||
MOVE.B #1,-(SP) ; push TRUE boolean <EHB 28-Oct-85>
|
||
_ShowHide ; do it
|
||
MOVE.L (SP)+,A0 ; Get return address in A0 <SM16> FM
|
||
ADDQ #4,SP ; Nuke the window parameter <SM16> FM
|
||
JMP (A0) ; return to caller
|
||
|
||
; the window we're about to show is the new front window so we better select it
|
||
;
|
||
ShowSelect
|
||
MOVE.L A0,-(SP) ;push it
|
||
_SelectWindow ;select it
|
||
BRA.S JustShowIt ;go show it, too
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE HideWindow(theWindow: windowPtr);
|
||
;
|
||
; make the parameter window invisible (if its not already). Use the "ShowHide"
|
||
; utility routine to do the real work. It also does the appropriate SelectWindow
|
||
; if the one we're hiding was the front window.
|
||
;
|
||
|
||
HideWindow Proc Export
|
||
Import __ActiveWindow
|
||
|
||
SUBQ #4,SP ;make room for result
|
||
JSR __ActiveWindow ;get the frontMost window
|
||
|
||
MOVE.L 8(SP),-(SP) ;push the window
|
||
CLR.W -(SP) ;push FALSE for "hide"
|
||
_ShowHide ;hide it
|
||
|
||
; if the one we hid was the frontWindow, select the new frontWindow
|
||
|
||
MOVE.L (SP)+,D0 ;get old frontWindow
|
||
CMP.L 4(SP),D0 ;is it this one?
|
||
BNE.S DoneHide1 ;if not, we're done
|
||
|
||
; we just hid the frontWindow so call SelectWindow to fix things up
|
||
|
||
BSR MakeDeactive ;go post the deactivate
|
||
|
||
SUBQ #4,SP ;make room on stack
|
||
JSR __ActiveWindow ;get new frontWindow
|
||
MOVE.L (SP),CurActivate ;remember to activate it
|
||
BEQ.S DoneH2 ;if none, better not activate
|
||
_SelectWindow ;select it
|
||
|
||
; all done with HideWindow
|
||
|
||
DoneHide1
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
DoneH2
|
||
ADDQ #4,SP ;pop off the window
|
||
BRA.S DoneHide1 ;use common code
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION GetWRefCon(window):LONGINT
|
||
;
|
||
; Returns the application-defined reference constant associated with the window
|
||
;
|
||
|
||
GetWRefCon Proc Export
|
||
Export GetWCommon
|
||
|
||
MOVE.W #WRefCon,D1 ;get offset to refCon
|
||
|
||
GetWCommon MOVE.L (SP)+,A0 ;get return address
|
||
MOVE.L (SP)+,A1 ;get the window pointer
|
||
MOVE.L 0(A1,D1),(SP) ;pass back the refCon
|
||
JMP (A0) ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SetWRefCon(window: windowPtr; value: LongInt);
|
||
;
|
||
; Sets the application-defined reference constant associated with the window
|
||
;
|
||
|
||
SetWRefCon Proc Export
|
||
Export SetWCommon
|
||
|
||
MOVE.W #WRefCon,D1 ;get offset to refCon
|
||
|
||
SetWCommon
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
MOVE.L (SP)+,D0 ;get the value
|
||
MOVE.L (SP)+,A1 ;get the window pointer
|
||
MOVE.L D0,0(A1,D1) ;pass back the refCon
|
||
JMP (A0) ;return to caller
|
||
EndProc
|
||
|
||
; PROCEDURE SetWindowPic(window: windowPtr; thePic: PicHandle);
|
||
;
|
||
; Sets the picture handle of a window
|
||
;
|
||
|
||
SetWindowPic Proc Export
|
||
Import SetWCommon
|
||
|
||
MOVE.W #WindowPic,D1 ;get offset to windowPic
|
||
BRA SetWCommon ;use common code
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION GetWindowPic(window):picHandle
|
||
;
|
||
; Returns the window picture associated with the window
|
||
;
|
||
|
||
GetWindowPic Proc Export
|
||
Import GetWCommon
|
||
|
||
MOVE.W #WindowPic,D1 ;get offset to windowPic
|
||
BRA GetWCommon ;use common code
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE GetWTitle(window: WindowPtr; VAR title: string);
|
||
;
|
||
; return the title of the window. Make sure we make a copy of the
|
||
; string cause it might move around.
|
||
;
|
||
|
||
GetWTitle Proc Export
|
||
|
||
MOVEM.L (SP)+,D1/A0-A1 ;get return address, stringPtr, windowPtr
|
||
|
||
MOVE.L WTITLEHANDLE(A1),D0 ;do we have a title <SM37>
|
||
BEQ.S @NilTitle ; nope <SM37>
|
||
|
||
MOVE.L D0,A1 ;get handle of title <SM37>
|
||
MOVE.L (A1),A1 ;handle -> pointer
|
||
|
||
MOVEQ #0,D0
|
||
MOVE.B (A1),D0 ;get length of string in bytes
|
||
@1 MOVE.B (A1)+,(A0)+ ;move a byte of the string
|
||
DBRA D0,@1 ;loop till its moved
|
||
|
||
BRA.S @Exit ;is this really necessary <SM37>
|
||
|
||
@NilTitle MOVE.B #0,(A0)+ ;zero length string <SM37>
|
||
|
||
@Exit MOVE.L D1,A0 ;get return address
|
||
JMP (A0) ;all done!
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SetWTitle(window: windowPtr; title: String);
|
||
;
|
||
; set the title of a window, redrawing stuff as necessary
|
||
;
|
||
|
||
SetWTitle Proc Export
|
||
Import SetWPort
|
||
Import CallWCalc
|
||
Import RemoveContent
|
||
Import RestorePort
|
||
Import TwoParmExit
|
||
|
||
MOVEM.L D3-D5/A2-A3,-(SP) ;save work registers (push one extra)
|
||
|
||
MOVE.L 24(SP),D5 ;get title String
|
||
MOVE.L 28(SP),A3 ;get the window pointer
|
||
BSR SETWPORT ;get into the window manager port
|
||
;
|
||
MOVE.L StructRgn(A3),A0 ;get the structRgn
|
||
_HandToHand ;clone it
|
||
MOVE.L A0,D3 ;set clobbered to struct
|
||
|
||
MOVE.L WTitleHandle(A3),D0 ; test for NIL handle <EHB 11-May-85>
|
||
BEQ.S @2 ; dispose region, restore port <EHB 11-May-85>
|
||
MOVE.L D0,-(SP) ; else push handle <EHB 11-May-85>
|
||
MOVE.L D5,-(SP) ;push pointer to new title
|
||
_SetString ;update the window's title
|
||
;
|
||
SUBQ #2,SP ;make room for stringWidth result
|
||
MOVE.L D5,-(SP) ;push newString pointer
|
||
_StringWidth ;measure width of new title
|
||
MOVE.W (SP)+,WTITLEWIDTH(A3) ;update window's title width
|
||
;
|
||
BSR CALLWCALC ;invoke the windowProc to calc regions
|
||
|
||
; if the new region is the same as the old region, then simply paint the
|
||
; current window (this is the usual case). Otherwise, redraw all windows.
|
||
|
||
CLR.W -(SP) ; room for boolean result <EHB 1/23/85>
|
||
MOVE.L StructRgn(A3),-(SP) ; compare the new structure <EHB 1/23/85>
|
||
MOVE.L D3,-(SP) ; to the old one <EHB 1/23/85>
|
||
_EqualRgn ; <EHB 1/23/85>
|
||
MOVE.W (SP)+,D0 ; are they equal?? <EHB 1/23/85>
|
||
BEQ.S @1 ; no, redraw everything <EHB 1/23/85>
|
||
|
||
BSR.S RemoveContent ; else remove content from region <EHB 1/23/85>
|
||
|
||
MOVE.L A3,-(SP) ; and paint the window <EHB 1/23/85>
|
||
MOVE.L D3,-(SP) ; with the new structure <EHB 1/23/85>
|
||
_PaintOne ; <EHB 1/23/85>
|
||
BRA.S @2 ; <EHB 1/23/85>
|
||
|
||
; compute the union of the old and new structures of the window, subtract
|
||
; out the content region, and redraw clipped to that
|
||
|
||
@1
|
||
|
||
move.l a3,-(sp) ;<SM16> FM pass the window pointer
|
||
_ActivatePalette ;<SM16> FM go tell the Palette Mgr to think about this window
|
||
|
||
MOVE.L StructRgn(A3),-(SP) ;push new struct
|
||
MOVE.L D3,-(SP) ;push old struct
|
||
MOVE.L D3,-(SP) ;clobbered gets the result
|
||
_UnionRgn ;clobbered = old and new struct
|
||
|
||
BSR.S RemoveContent ; remove content from region <EHB 1/23/85>
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
_PaintBehind ;PaintBehind(theWindow,clobbered)
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
_CalcVBehind ;CalcVBehind(theWindow,clobbered)
|
||
;
|
||
; all done -- dispose clobbered, restore the port and return to caller
|
||
|
||
@2
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
_DisposRgn ;dispose it
|
||
|
||
BSR RESTOREPORT ;restore grafPort
|
||
MOVEM.L (SP)+,D3-D5/A2-A3 ;restore registers
|
||
GoTwoParm
|
||
BRA TWOPARMEXIT ;standard exit saves code
|
||
EndProc
|
||
|
||
; Utility PROCEDURE RemoveContent;
|
||
;
|
||
; This is a code saving utility. It subtracts the content region of
|
||
; the window in A3 from the region in D3 and leaves the result in
|
||
; the region in D3.
|
||
|
||
RemoveContent Proc Export
|
||
MOVE.L D3,-(SP) ;push clobbered <EHB 1/23/85>
|
||
MOVE.L ContRgn(A3),-(SP) ;push content region <EHB 1/23/85>
|
||
MOVE.L D3,-(SP) ;clobbered gets the result <EHB 1/23/85>
|
||
_DiffRgn ;subtract off the result <EHB 1/23/85>
|
||
RTS ; <EHB 1/23/85>
|
||
EndProc
|
||
|
||
;
|
||
; Utility FUNCTION DeltaPoint(point1,point2: Point): Point;
|
||
;
|
||
; DeltaPoint is a code saving utility that computes the difference between
|
||
; two LisaGraf points, Result := point1 - point2.
|
||
;
|
||
|
||
DeltaPoint Proc Export
|
||
Import TwoParmExit
|
||
|
||
MOVE 8(SP),D0 ;get point1.v
|
||
SUB 4(SP),D0 ;subtract point2.v
|
||
MOVE D0,12(SP) ;record result
|
||
;
|
||
MOVE 10(SP),D0 ;get point1.h
|
||
SUB 6(SP),D0 ;subtract point2.h
|
||
MOVE D0,14(SP) ;record result
|
||
BRA TwoParmExit ;standard exit saves code
|
||
EndProc
|
||
|
||
; MoveGuts is common code shared between MoveWindow and ZoomWindow. It calculates the
|
||
; offset from the global point in D0 and the topLeft of the portRect, and offsets the
|
||
; portRect and regions by that amount. StructRgn is in A4.
|
||
|
||
MoveGuts Proc Export
|
||
Import PortToBitMap
|
||
Import DeltaPoint
|
||
Import NegWords
|
||
|
||
MOVE.L A4,-(SP) ;push structure region
|
||
SUBQ #4,SP ;make room for result
|
||
MOVE.L D0,-(SP) ;get global place to move to
|
||
SUBQ #4,SP ;make room for result
|
||
MOVE.L PORTRECT(A3),-(SP) ;get portRect topLeft
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bitMap/pixMap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),-(SP) ;push portBounds topLeft <C106 EHB>
|
||
BSR.S DeltaPoint ;compute portRect - bounds (global portRect)
|
||
BSR.S DeltaPoint ;compute target - current
|
||
;
|
||
; now offset all the windows' regions
|
||
;
|
||
MOVE.L (SP),D3 ;remember the offset
|
||
_OfsetRgn ;offset the structure
|
||
MOVE.L CONTRGN(A3),-(SP)
|
||
MOVE.L D3,-(SP)
|
||
_OfsetRgn ;offset the content region
|
||
MOVE.L UPDATERGN(A3),-(SP)
|
||
MOVE.L D3,-(SP)
|
||
_OfsetRgn ;offset the update region
|
||
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bitMap/pixMap pointer <C106 EHB>
|
||
PEA BOUNDS(A0) ;push pointer to port bounds rect <C106 EHB>
|
||
MOVE.L D3,-(SP) ;push offset
|
||
BSR NEGWORDS ;negate it
|
||
_OffsetRect ;offset port bounds rect to new position
|
||
|
||
RTS ; return to sender...
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE MoveWindow(window: windowPtr; hGlobal,vGlobal: INTEGER; front:BOOLEAN);
|
||
;
|
||
; move the position of the window (hGlobal and vGlobal specify the
|
||
; new position of topLeft) without changing its size. If the front parameter
|
||
; is true, also bring the window to the front
|
||
;
|
||
|
||
MoveWindow Proc Export
|
||
Import SetWPort
|
||
Import ClipGAbove
|
||
Import GetNewRgn
|
||
Import MoveGuts
|
||
Import SmartMove
|
||
Import SelWin1
|
||
Import RestorePort
|
||
Import TenBytExit
|
||
|
||
MOVEM.L D3-D6/A3-A4,-(SP) ;save work registers
|
||
BSR SETWPORT ;get into the wmgr Port
|
||
MOVE.L 34(SP),A3 ;get window ptr
|
||
|
||
; compute the region that describes the currently visible part of the window
|
||
; and keep it in D5
|
||
;
|
||
BSR ClipGAbove ;clip to windows above us
|
||
;
|
||
BSR GETNEWRGN ;allocate a new region, keep in A4
|
||
MOVE.L (SP)+,D5 ;call it srcRgn and keep in D5
|
||
MOVE.L STRUCTRGN(A3),A4 ;get the structure region
|
||
MOVE.L A4,-(SP) ;push the structure region
|
||
|
||
MOVE.L WMGRPORT,A0 ;get the wmgrPort
|
||
|
||
MOVE.L CLIPRGN(A0),-(SP) ;intersect clipRgn with structRgn
|
||
MOVE.L D5,-(SP) ;get result in srcRgn
|
||
_SectRgn ;intersect em
|
||
|
||
;
|
||
; remember the old struct
|
||
;
|
||
MOVE.L A4,A0 ;clone structRgn
|
||
_HandToHand ;perform the clone
|
||
MOVE.L A0,D6 ;keep in D6
|
||
;
|
||
; figure out the offsets for moving it
|
||
|
||
MOVE.L 30(SP),D0 ; pass new topLeft in D0
|
||
BSR MoveGuts ; call code shared with ZoomWindow
|
||
|
||
; if NuMac then clip to windows that don't need to be redrawn
|
||
|
||
BSR SmartMove ;clip to screens with same color table
|
||
|
||
MOVE.L D5,-(SP)
|
||
MOVE.L D3,-(SP)
|
||
_OfsetRgn ;offset visible part of struct
|
||
;
|
||
; Set up the clipRgn for the blit
|
||
;
|
||
TST.B 28(SP) ;bring to front flag set?
|
||
BEQ.S NoBTF0 ;if not, skip
|
||
|
||
; Roll in patchSetclip from WindowMgrPatches.a <SM 2><PN>
|
||
; Fix MoveWindow so that it calls ClipAbove(WindowList) for the bringToFront case
|
||
; _SetClip
|
||
;
|
||
MOVE.L WindowList, A3 ;else, clipAbove the first window
|
||
BSR ClipGAbove ;clip to windows above us
|
||
MOVE.L 34(SP),A3 ;get window <PN> <SM12> Test & Adjust to 34(sp)
|
||
|
||
; end roll -in
|
||
|
||
NoBTF0
|
||
|
||
; commented out <C388/09Nov86> DAF
|
||
MOVE.L WMGRPORT,A0 ;get wmgrPort
|
||
PEA PORTBITS(A0) ;use screen bitmap
|
||
MOVE.L (SP),-(SP) ;its the destination, too
|
||
MOVE.L D6,A0 ;get src region handle
|
||
MOVE.L (A0),A0 ;get pointer
|
||
PEA RGNBBOX(A0) ;push pointer to its bounding box
|
||
MOVE.L (A4),A0 ;dereference the structRgn
|
||
PEA RGNBBOX(A0) ;its the destination box
|
||
CLR -(SP) ;mode is srcCopy
|
||
MOVE.L D5,-(SP) ;clip to vis part of structRgn
|
||
_CopyBits ;do it!
|
||
|
||
; draw the part of the window we couldn't move -- the part covered by some other
|
||
; window or off the screen. Compute the part of the window that needs
|
||
; repainting into D5
|
||
|
||
MOVE.L A4,-(SP) ;push the whole structure
|
||
MOVE.L D5,-(SP) ;push the visible part
|
||
MOVE.L D5,-(SP) ;result goes in D5
|
||
_DiffRgn ;compute invis part of struct
|
||
;
|
||
; better fix up the ones behind up first to avoid two images
|
||
;
|
||
MOVE.L NEXTWINDOW(A3),-(SP) ;push next window
|
||
MOVE.L D6,-(SP) ;clobbered is old structure
|
||
_PaintBehind
|
||
;
|
||
; bring it to the front if necessary
|
||
;
|
||
TST.B 28(SP) ;bring to front flag set?
|
||
BEQ.S @3 ;if not, skip
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
MOVE.W #$FFFF,DragFlag ;set implicit param to BTF <LW10>
|
||
BSR SelWin1 ;bring us to the front
|
||
CLR.W DragFlag ;<SM29> CSS
|
||
; now we can repaint the clobbered part of the window in its new position
|
||
|
||
@3 MOVE.L A3,-(SP) ;push the windowPtr
|
||
MOVE.L D5,-(SP) ;push clobbered
|
||
; PaintOne in MoveWindow - since we have done CalcAncestorRgns in _PaintBehind, we can do a PaintOneLite <SM16> FM
|
||
move.l ExpandMem,a0 ; <SM16> FM
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; set the one-shot to keep from recalcing ancestor rgns <SM16> FM
|
||
_PaintOne ;repaint it, clipped to clobbered
|
||
|
||
;
|
||
; better union new and old structRgns for CalcVisBehind clobbered
|
||
;
|
||
MOVE.L D6,-(SP) ;old struct
|
||
MOVE.L A4,-(SP) ;new struct
|
||
MOVE.L D6,-(SP) ;old gets result
|
||
_UnionRgn ;union them together
|
||
;
|
||
MOVE.L A3,-(SP) ;push the window
|
||
MOVE.L D6,-(SP) ;clobbered is old structure
|
||
_CalcVBehind ;recalculate visRgns of those behind
|
||
|
||
MOVE.L D5,-(SP) ;all done with this region
|
||
_DisposRgn ;return to free list
|
||
MOVE.L D6,-(SP)
|
||
_DisposRgn
|
||
|
||
MOVE.L A3,-(SP) ;push the window pointer
|
||
_ActivatePalette ;and activate the palette
|
||
|
||
BSR RESTOREPORT ;restore the old grafPort
|
||
MOVEM.L (SP)+,D3-D6/A3-A4 ;restore work registers
|
||
BRA TenBytExit ;standard exit saves code
|
||
EndProc
|
||
|
||
; Utility SmartMove(srcRgn,offset)
|
||
; We only want to blt the parts of the src that are going to screens with the same color
|
||
; table as the src. Subtract all other parts from the srcRgn so that they can
|
||
; be drawn in response to an update event.
|
||
; SrcRgn is in D5. Offset is in D3
|
||
|
||
SmartMove Proc Export
|
||
Import NegWords
|
||
|
||
MOVEM.L D5-D7/A2-A4,-(SP) ; save work registers
|
||
SUBQ #8,SP ; make room for rectangle
|
||
MOVE.L SP,A2 ; keep tempRect in A2
|
||
|
||
SUBQ #8,SP ; make room for 2 region handles
|
||
_NewRgn ; allocate tempRgn
|
||
MOVE.L (SP)+,D7 ; keep tempRgn in D7
|
||
_NewRgn ; allocate rgn for dst screen
|
||
MOVE.L (SP)+,D6 ; keep scrnRgn in D6
|
||
|
||
; check each device to see if src is on that device.
|
||
|
||
MOVE.L DeviceList,A4 ; keep current device in A4
|
||
NxtDev1
|
||
MOVE.L (A4),A0 ; point to current device
|
||
TST GDFlags(A0) ; is it active?
|
||
BPL SkipDev1 ; => no, skip to next device
|
||
|
||
MOVE.L D7,-(SP) ; push tempRgn
|
||
PEA GDRect(A0) ; push rect
|
||
_RectRgn ; create a rectangular region
|
||
|
||
MOVE.L D5,-(SP) ; push srcRgn
|
||
MOVE.L D7,-(SP) ; push device's rectangle
|
||
MOVE.L D7,-(SP) ; keep intersection in tempRgn
|
||
_SectRgn ; get intersection of window with device
|
||
|
||
CLR.B -(SP) ; prepare for boolean result
|
||
MOVE.L D7,-(SP) ; push intersection
|
||
_EmptyRgn ; is the result empty?
|
||
TST.B (SP)+ ; test result of intersection
|
||
BNE SkipDev1 ; => no intersection, we're cool
|
||
|
||
; got a src device, check all possible dst devices
|
||
|
||
MOVE.L DeviceList,A3 ; keep current device in A3
|
||
NxtDev2
|
||
MOVE.L (A3),A0 ; point to current device
|
||
TST GDFlags(A0) ; is it active?
|
||
BPL.S SkipDev2 ; => no, skip to next device
|
||
|
||
CMP.L A3,A4 ; does src device = dst device?
|
||
BEQ.S SkipDev2 ; => yes, we know the color table matches
|
||
|
||
; does color table of src device match color table of dst device?
|
||
|
||
MOVE.L (A4),A1 ; point to source device
|
||
MOVE.L GDPMap(A1),A1 ; get handle to src pixMap
|
||
MOVE.L (A1),A1 ; point to src pixMap
|
||
MOVE.L pmTable(A1),A1 ; get handle to color table
|
||
MOVE.L (A1),A1 ; point to color table
|
||
MOVE.L ctSeed(A1),D0 ; get color table's seed
|
||
MOVE.L GDPMap(A0),A1 ; get handle to dst pixMap
|
||
MOVE.L (A1),A1 ; point to dst pixMap
|
||
MOVE.L pmTable(A1),A1 ; get handle to color table
|
||
MOVE.L (A1),A1 ; point to color table
|
||
CMP.L ctSeed(A1),D0 ; are color tables the same?
|
||
BEQ.S SkipDev2 ; => yes, blit is fine
|
||
|
||
; color tables don't match. Calculate the part of the src to be moved to this device (if any)
|
||
|
||
LEA GDRect(A0),A0 ; get dst deviceRect
|
||
MOVE.L A2,A1 ; get tempRect
|
||
MOVE.L (A0)+,(A1)+ ; copy topLeft
|
||
MOVE.L (A0),(A1) ; copy botRight
|
||
|
||
MOVE.L A2,-(SP) ; push rectangle
|
||
MOVE.L D3,-(SP) ; push offset
|
||
BSR NEGWORDS ; negate it
|
||
_OffsetRect ; offset by move amount
|
||
|
||
MOVE.L D6,-(SP) ; push scrnRgn
|
||
MOVE.L A2,-(SP) ; push tempRect
|
||
_RectRgn ; regionize offset device's rect
|
||
|
||
MOVE.L D6,-(SP) ; push scrnRgn
|
||
MOVE.L D7,-(SP) ; push tempRgn
|
||
MOVE.L D6,-(SP) ; get result in scrnRgn
|
||
_SectRgn ; get intersection
|
||
|
||
CLR.B -(SP) ; prepare for boolean result
|
||
MOVE.L D6,-(SP) ; push intersection
|
||
_EmptyRgn ; is the result empty?
|
||
TST.B (SP)+ ; test result of intersection
|
||
BNE.S SkipDev2 ; => no intersection, we're cool
|
||
|
||
; subtract this piece of the src from the srcRgn
|
||
|
||
MOVE.L D5,-(SP) ; push region being moved
|
||
MOVE.L D6,-(SP) ; push part going to bigger screen
|
||
MOVE.L D5,-(SP) ; get result as region being moved
|
||
_DiffRgn ; srcRgn := srcRgn-scrnRgn
|
||
|
||
; check next dst device
|
||
|
||
SkipDev2
|
||
MOVE.L (A3),A0 ; point to current device
|
||
MOVE.L GDNextGD(A0),D0 ; get next device
|
||
MOVE.L D0,A3 ; keep current device in A3
|
||
BNE.S NxtDev2 ; =>do next device
|
||
|
||
; check next src device
|
||
|
||
SkipDev1
|
||
MOVE.L (A4),A0 ; point to current device
|
||
MOVE.L GDNextGD(A0),D0 ; get next device
|
||
MOVE.L D0,A4 ; keep current device in A4
|
||
BNE.S NxtDev1 ; =>do next device
|
||
|
||
; clean up and return
|
||
|
||
MOVE.L D6,-(SP) ; push scrn region
|
||
_DisposRgn ; dispose of it
|
||
MOVE.L D7,-(SP) ; push temp region
|
||
_DisposRgn ; dispose of it
|
||
|
||
ADDQ #8,SP ; strip tempRect
|
||
MOVEM.L (SP)+,D5-D7/A2-A4 ; restore work registers
|
||
RTS ; and return
|
||
EndProc
|
||
|
||
;
|
||
; function GetWVariant ( someWindow : WindowPtr ) : integer;
|
||
;
|
||
; GetWVariant returns the variant code of the windowRecord pointed at by
|
||
; someWindow. The value returned is an integer even though variants
|
||
; are currently only 4 bits as word params on the stack are easier to
|
||
; handle
|
||
;
|
||
|
||
GetWVariant Proc Export ; <C491/08Dec86> DAF
|
||
MOVE.L 4(SP),A1 ; get windowPtr <C591/04Jan86> DAF
|
||
TST.B MMU32Bit ; are we running 32-bit? <C666/22Jan87> DAF
|
||
BEQ.S @1 ; do it the old way
|
||
SUBQ #6,SP ; leave room for result and boolean
|
||
MOVE.L A1,-(SP) ; push the windowPtr <C591/04Jan86> DAF
|
||
PEA 6(SP) ; point to the result space
|
||
_GetAuxWin ; get the window's auxRec
|
||
ADDQ #2,SP ; flush the boolean
|
||
MOVE.L (SP)+,A0 ; get the auxRec handle
|
||
MOVE.L (A0),A0 ; get the auxRec ptr
|
||
CLR.W D0 ; clear hi part of register
|
||
MOVE.B awFlags(A0),D0 ; get the variant byte <1.7>
|
||
BRA.S @2
|
||
@1
|
||
CLR.W D0 ; clear hi part of register
|
||
MOVE.B WindowDef(A1),D0 ; get the variant code
|
||
AND.W #$000F,D0 ; trim to 4 bits
|
||
@2
|
||
MOVE.W D0,8(SP) ; return the result
|
||
MOVE.L (SP)+,A0 ; get the return addr <C591/04Jan86> DAF
|
||
ADDQ #4,SP ; flush parameter <C591/04Jan86> DAF
|
||
JMP (A0) ; return to caller
|
||
EndProc
|
||
|
||
;
|
||
; UTILITY CallWindow
|
||
;
|
||
; This utility is used to save code. It has a register interface:
|
||
; A3 holds the window
|
||
; D3 holds the parameter
|
||
; D0 holds the message
|
||
;
|
||
; On exit, D0 contains the result parameter
|
||
;
|
||
|
||
CallWindow Proc Export
|
||
|
||
MOVE.L A4,-(SP) ;save A4 <SM24>
|
||
CLR.L -(SP) ;make room for function result
|
||
|
||
SUBQ #2,SP ;leave space for variant <C491/08Dec86> DAF
|
||
MOVE.L A3,-(SP) ;push window pointer
|
||
MOVE.W D0,-(SP) ;push message index
|
||
MOVE.L D3,-(SP) ;push parameter
|
||
|
||
SUBQ #2,SP ;make room for function return <C491/08Dec86> DAF
|
||
MOVE.L A3,-(SP) ;push window pointer <C491/08Dec86> DAF
|
||
_GetWVariant ;get variant code <C491/08Dec86> DAF
|
||
MOVE.W (SP)+,10(SP) ;put in placeholder on stack <C491/08Dec86> DAF
|
||
|
||
MOVE.L WindowDef(A3),A0 ;get proc handle
|
||
TST.L (A0) ;has the proc been purged? <C666/21Jan87> DAF
|
||
BNE.S @1 ;if we got it, skip
|
||
|
||
MOVE.L A0,D0 ;clean the handle (historical) <C666/21Jan87> DAF
|
||
_StripAddress ;clean the pointer <C491/08Dec86> DAF
|
||
MOVE.L D0,-(SP) ;better reload the proc <C491/08Dec86> DAF
|
||
_LoadResource ;via the resource manager
|
||
TST.L (A0) ;did we get it this time? <C949/08Nov87> DAF
|
||
BNE.S @1 ;yup, keep going <C949/08Nov87> DAF
|
||
MOVE.W #WDEFnFnd,D0 ;get error code <C949/08Nov87> DAF
|
||
_SysError ;and croak <C949/08Nov87> DAF
|
||
@1
|
||
|
||
; Some programmers are pretty slimy and load a WDEF that is empty. They then <LW4> fau
|
||
; stuff some code into it. However, since HLOCK does not flush the cache anymore, <LW4> fau
|
||
; the code that they stuff into it might not get written back to memory. To solve this, <LW4> fau
|
||
; we check here whether the WDEF resource size is less than, say, 32 bytes. If so, we <LW6> chp
|
||
; assume that they have already loaded theWDEF and modified it, so we flush the cache <LW4> fau
|
||
; for them.
|
||
|
||
_GetHandleSize ; How big is our WDEF Handle <LW4> fau
|
||
cmp.l #32,D0 ; Is it "small" <LW6> chp
|
||
bhi.s @RealWDEF ; no, don't flush the cache <LW4> fau
|
||
jsr ([jCacheFlush]) ; else, flush the caches. <LW4> fau
|
||
@RealWDEF ; <LW4> fau
|
||
_HLock ;lock the proc handle <C424/18Nov86> DAF
|
||
MOVE.L (A0),A0 ;get the proc pointer <C424/18Nov86> DAF
|
||
JSR (A0) ;call it
|
||
MOVE.L WindowDef(A3),A0 ;get the proc handle <C424/18Nov86> DAF
|
||
_HUnlock ;free the defproc <C424/18Nov86> DAF
|
||
MOVE.L (SP)+,D0 ;get the reply
|
||
|
||
MOVE.L (SP)+,A4 ;restore A4 <SM24>
|
||
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; CALLDWINDOW -- sends a draw message to the window
|
||
;
|
||
|
||
CallDWindow Proc Export
|
||
Import CallWindow
|
||
|
||
MOVEM.L D3,-(SP) ;preserve D3
|
||
MOVEQ #0,D3 ;zero D3 (draw all)
|
||
MOVEQ #WDrawMsg,D0 ;draw message
|
||
BSR.S CallWindow ;call it
|
||
MOVE.L (SP)+,D3 ;restore A3
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; UTILITY CallWCalc -- takes same parameters as call window and issues "calc your regions"
|
||
; message to the window if its visible. If the window isn't visible, it sets all the
|
||
; regions to empty.
|
||
;
|
||
|
||
CallWCalc Proc Export
|
||
Import CallWindow
|
||
|
||
MOVEQ #WCalcRgnMsg,D0 ;assume its visible
|
||
TST.B WVisible(A3) ;is it visible?
|
||
;;;; BNE.S CallWindow ;if so, ask the window defProc to do it <C106 EHB>
|
||
BEQ.S @1 ;=>if not, empty regions <C106 EHB>
|
||
|
||
LEA PortBounds(A3),A1 ;get portbounds <C106 EHB>
|
||
MOVE.L (A1)+,-(SP) ;save whatever's there <C106 EHB>
|
||
MOVE.L (A1)+,-(SP) ; <C106 EHB>
|
||
TST PortBits+RowBytes(A3) ;is it a new port <C106 EHB>
|
||
BPL.S @0 ;=>no <C106 EHB>
|
||
MOVE.L PortBits+BaseAddr(A3),A0 ;get the pixmap <C106 EHB>
|
||
MOVE.L (A0),A0 ;point to it <C106 EHB>
|
||
MOVE.L Bounds+botRight(A0),-(A1) ; <C106 EHB>
|
||
MOVE.L Bounds(A0),-(A1) ;set up bounds <C106 EHB>
|
||
@0
|
||
BSR CallWindow ;get the defproc to recalc <C106 EHB>
|
||
MOVE.L (SP)+,PortBounds+BotRight(A3) ;restore whatever was there <C106 EHB>
|
||
MOVE.L (SP)+,PortBounds(A3) ; <C106 EHB>
|
||
RTS
|
||
@1
|
||
;
|
||
; the window isn't visible so set its structure, content and visible regions to empty
|
||
;
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;zero the structure region
|
||
_SetEmptyRgn
|
||
MOVE.L CONTRGN(A3),-(SP) ;zero the content region
|
||
_SetEmptyRgn
|
||
MOVE.L VISRGN(A3),-(SP) ;zero the visRgn
|
||
_SetEmptyRgn
|
||
RTS ;all done with calcRgn
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE HiliteWindow(window: windowPtr; fHilite: Boolean);
|
||
;
|
||
; Hilite or unhilite a window, depending on the state of the fHilite
|
||
; boolean.
|
||
;
|
||
|
||
HiliteWindow Proc Export
|
||
Import SetWPort
|
||
Import ClipVStruct
|
||
Import CallDWindow
|
||
Import RestorePort
|
||
Import SixBytExit
|
||
|
||
MOVEM.L D3-D4/A3-A4,-(SP) ;save work registers
|
||
MOVE.L 22(SP),A3 ;get window pointer
|
||
MOVE.B 20(SP),D3 ;get fHilite boolean
|
||
BSR SETWPORT ;get into the wmgrPort
|
||
;
|
||
MOVE.B WHilited(A3),D0 ;get current hilite state
|
||
EOR D3,D0 ;compare with parameter
|
||
LSR #1,D0 ;just consider low bit
|
||
BCC.S SWDONE ;if so, nothing more to do
|
||
MOVE.B D3,WHILITED(A3) ;set the new state of the window
|
||
;
|
||
BSR.S ClipVStruct ;clip to windows above us
|
||
BSR CALLDWINDOW ;invoke the windowProc to draw it
|
||
;
|
||
SWDone
|
||
BSR RESTOREPORT ;restore old grafPort
|
||
MOVEM.L (SP)+,D3-D4/A3-A4 ;restore work registers
|
||
BRA SIXBYTEXIT ;standard exit saves code
|
||
EndProc
|
||
|
||
;
|
||
; ClipVStruct and ClipGAbove are code saving utilities that set the clipping region to
|
||
; exclude the windows above the on in A3. ClipVStruct also clips to the window's
|
||
; structure while ClipGAbove uses the gray region (the desk) instead
|
||
;
|
||
ClipVStruct Proc Export
|
||
Export ClipGAbove
|
||
|
||
MOVE.L StructRgn(A3),-(SP) ;push the structure
|
||
ClipCommon
|
||
_SetClip ;clip to it
|
||
MOVE.L A3,-(SP) ;push the window
|
||
_ClipAbove ;clipAbove does all the real work
|
||
RTS
|
||
;
|
||
ClipGAbove MOVE.L GrayRgn,-(SP) ;push the gray region
|
||
BRA.S ClipCommon ;let common code do the rest
|
||
EndProc
|
||
|
||
|
||
;
|
||
; PROCEDURE SizeWindow(window: WindowPtr; w,h: INTEGER; fUpdate: BOOLEAN);
|
||
;
|
||
; Change the size of the window to the width/height specified by w,h. If
|
||
; fUpdate is TRUE, generate the appropriate update events
|
||
;
|
||
|
||
TitleLeft EQU 32
|
||
|
||
SizeWindow Proc Export
|
||
Import SizeGuts
|
||
Import SetWPort
|
||
Export TenBytExit
|
||
|
||
MOVEM.L D3-D4/A3-A4,-(SP) ;save work registers
|
||
MOVE.L 22(SP),D3 ;w and h = 0? (get width, too)
|
||
BEQ.S SizeDone ;if so, don't do anything
|
||
|
||
MOVE.L 26(SP),A3 ;get the window pointer
|
||
|
||
MOVE 22(SP),D4 ;get the new height (already got width)
|
||
|
||
LEA PORTRECT(A3),A4 ;get a pointer to the portRect
|
||
ADD (A4)+,D4 ;bottom := top + height
|
||
ADD (A4)+,D3 ;right := left + width
|
||
MOVE.W D4,(A4)+ ;update bottom
|
||
MOVE.W D3,(A4)+ ;update width
|
||
;
|
||
; now that the portRect is set to the new size. Update the screen if necessary
|
||
;
|
||
TST.B WVISIBLE(A3) ;is the window visible?
|
||
BEQ.S SIZEDONE ;if so, we're done
|
||
BSR SETWPORT ;get into the window manager port
|
||
MOVE.L A3,-(SP) ;push the window pointer
|
||
_SaveOld ;SaveOld(window)
|
||
|
||
MOVE.B 20(SP),D3 ; pass update flag in D3 <9 Sep 85>
|
||
BSR.S SizeGuts ; call code shared with zoomWindow
|
||
|
||
MOVE.L A3,-(SP) ; push the window pointer <12May87 DAF>
|
||
_ActivatePalette ; and activate it's palette <12May87 DAF>
|
||
|
||
SizeDone
|
||
MOVEM.L (SP)+,D3-D4/A3-A4 ;recover registers
|
||
TenBytExit
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
ADD #10,SP ;pop off the paramters
|
||
JMP (A0) ;return to caller
|
||
EndProc
|
||
|
||
; SizeGuts is code shared between SizeWindow and ZoomWindow. The window's (A3) old
|
||
; regions have been saved by _SaveOld. This calculates the new regions and then
|
||
; draws the new window, updating the clobbered regions as necessary, and generating
|
||
; update events if D3 is TRUE. Before exiting, it gets out of the window manager port
|
||
; and back into the port saved in D4.
|
||
|
||
SizeGuts Proc Export
|
||
Import CallWCalc
|
||
Import ClipVStruct
|
||
Import CallDWindow
|
||
Import RestorePort
|
||
|
||
BSR CALLWCALC ; have window recalc its regions
|
||
|
||
BSR ClipVStruct ; clip to those above us
|
||
BSR CALLDWINDOW ; tell window to draw itself
|
||
|
||
MOVE.L A3,-(SP) ; push pointer to window
|
||
MOVE.B D3,-(SP) ; push update flag
|
||
_DrawNew ; update the screen image
|
||
|
||
BSR RESTOREPORT ; restore the port in D4
|
||
RTS
|
||
EndProc
|
||
|
||
|
||
; PROCEDURE ZoomWindow(window: windowPtr; partCode: Integer; front: BOOLEAN);
|
||
; 36 34 32
|
||
; ZoomWindow handles resizing the window in response to a click in the zoom box.
|
||
; It is usually called when the FindWindow classification code is "inZoomIn" or
|
||
; "inZoomOut". It resizes the window, leaving the local coordinates of the topLeft
|
||
; of the portRect unchanged (thus PortBounds are changed). It does not bring the
|
||
; window to the front.
|
||
|
||
; NOTE: This routine can only be called for window variation code 8 (hasZoomBox) or
|
||
; it will dereference bogus data from the wDataHandle. Also no provisions are made
|
||
; for the zooming of invisible windows.
|
||
|
||
ZoomWindow Proc Export
|
||
Import SetWPort
|
||
Import CallWCalc
|
||
Import MoveGuts
|
||
Import SizeGuts
|
||
Import SelWin1
|
||
Import TwoParmExit
|
||
|
||
MOVEM.L D3-D6/A2-A4,-(SP) ; save work registers
|
||
BSR SETWPORT ; get into window manager port (save old in D4)
|
||
MOVE.L 36(SP),A3 ; A3 = window pointer <EHB 03Nov85>
|
||
BSR CALLWCALC ; have window recalc its regions <EHB 29Aug85>
|
||
; this saves current size too <EHB 29Aug85>
|
||
MOVE.L A3,-(SP) ; push window pointer
|
||
_SaveOld ; save current structure & content regions
|
||
; DrawNew called by SizeGuts
|
||
MOVE.L wDataHandle(A3),A2 ; get the data handle
|
||
MOVE.L (A2),A2 ; and point to the data (smallSize,bigSize:Rect)
|
||
CMPI.W #inZoomIn,34(SP) ; was it zoom in?
|
||
BEQ.S @1 ; => yes, A2 points to smallSize
|
||
ADDQ #8,A2 ; else point A2 to bigSize
|
||
@1
|
||
MOVE.L StructRgn(A3),A4 ; get structure region into A4
|
||
MOVE.L (A2)+,D0 ; get new topLeft for common code
|
||
BSR MoveGuts ; share code with MoveWindow
|
||
|
||
; calculate new botRight by adding width and height to new topLeft
|
||
|
||
MOVE.W (A2)+,D0 ; get bottom of new rect
|
||
MOVE.W (A2)+,D1 ; get right of new rect
|
||
SUBQ #8,A2 ; rewind to beginning of rect
|
||
SUB.W (A2)+,D0 ; D0 = height
|
||
SUB.W (A2)+,D1 ; D1 = width
|
||
LEA PortRect(A3),A0 ; update portRect with new botRight
|
||
ADD.W (A0)+,D0 ; D0 = new bottom
|
||
ADD.W (A0)+,D1 ; D1 = new right
|
||
MOVE.W D0,(A0)+ ; set bottom
|
||
MOVE.W D1,(A0)+ ; set right
|
||
|
||
; call code that is shared with SizeWindow to recalculate and draw
|
||
; SizeGuts calls CALLWCALC which causes the window's position to be updated
|
||
|
||
MOVEQ #1,D3 ; pass update flag in D3
|
||
BSR.S SizeGuts ; share code with SizeWindow
|
||
|
||
TST.B 32(SP) ; bring to front flag set? <EHB 29Aug85>
|
||
BEQ.S @2 ; => no <EHB 29Aug85>
|
||
MOVE.L A3,-(SP) ; push the window <EHB 29Aug85>
|
||
MOVE.W #$FFFF,DragFlag ; bring to front <EHB 29Aug85><LW10>
|
||
BSR SelWin1 ; and select the window <EHB 29Aug85>
|
||
CLR.W DragFlag ; <SM29> CSS
|
||
@2
|
||
PEA PortRect(A3) ; invalidate the entire portRect
|
||
_InvalRect
|
||
|
||
MOVEM.L (SP)+,D3-D6/A2-A4 ; restore registers
|
||
BRA TwoParmExit ; and return
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION TrackGoAway(window: windowPtr; thePt: Point): BOOLEAN;
|
||
;
|
||
; TrackGoAway tracks a window's go away button. It is usually called when the
|
||
; FindWindow classification code is "inGoAway". The point parameter is usually
|
||
; the mousePoint attached with the mouseDown event (in global coordinates).
|
||
; TrackGoAway hilites/unhilites the go away button and returns true if the mouse
|
||
; went up in the goAway button and false otherwise.
|
||
;
|
||
|
||
TrackGoAway Proc Export
|
||
Import SetWPort
|
||
Import ClipVStruct
|
||
Import CallWindow
|
||
Import EORSymbol
|
||
Import CallDragHook
|
||
Import RestorePort
|
||
Import TenBytExit
|
||
Export TrackBox
|
||
|
||
MOVE.L (SP)+,A0 ; get RTS
|
||
MOVE.W #wInGoAway+2,-(SP) ; push "part code" to track
|
||
MOVE.L A0,-(SP) ; put RTS back
|
||
|
||
|
||
; FUNCTION TrackBox(window: windowPtr; thePt: Point; partCode: INTEGER): BOOLEAN;
|
||
; 14 10 8 18
|
||
;
|
||
; TrackBox tracks the part specified by partcode. It is used to track both the goAway
|
||
; box and the zoom box. TrackBox calls the defProc to hilite/unhilite the specified part
|
||
; and returns true if the mouse is released in the specified part. Keeps part in D6.
|
||
|
||
TrackBox
|
||
LINK A6,#-4 ;build a stack frame
|
||
MOVEM.L D3-D6/A3,-(SP) ;save some registers
|
||
|
||
BSR SetWPort ;remember old grafPort and set wmgrPort
|
||
|
||
LEA 8(A6),A0 ;get param addr in register
|
||
MOVE.W (A0)+,D6 ; keep part code in D6
|
||
SUBQ #2,D6 ; map to hit-test part number
|
||
MOVE.L (A0)+,-4(A6) ;init mousePt
|
||
MOVE.L (A0)+,A3 ;get the window
|
||
CLR.W (A0) ;assume result false
|
||
|
||
MOVEQ #0,D5 ;flag goAway button as un-hilited
|
||
|
||
BSR ClipVStruct ;clip to those above us
|
||
|
||
TrackGALoop
|
||
MOVEQ #WHitMsg,D0 ;its a hit-test message
|
||
MOVE.L -4(A6),D3 ;get the mouse point
|
||
BSR CallWindow ;tell window to hit test itself
|
||
|
||
CMP D6,D0 ; check the returned part
|
||
BEQ.S @1 ; if not our part, make it 0
|
||
MOVEQ #0,D0 ; otherwise, its zero
|
||
|
||
@1 CMP D0,D5 ;has it changed?
|
||
BEQ.S NextTrkGA ;if not, nothing to do
|
||
|
||
MOVE D0,D5 ;remember the change
|
||
BSR.S EORSymbol ;and reflect it on the screen
|
||
|
||
; keep tracking until the mouse goes up
|
||
|
||
NextTrkGA
|
||
PEA -4(A6) ;push mouse address
|
||
_GetMouse ;read the mouse
|
||
|
||
; call the users hook routine, if installed
|
||
|
||
BSR CallDragHook ;call user if installed
|
||
|
||
; loop till the mouse button goes up
|
||
|
||
CLR.W -(SP) ;make room for result
|
||
_WaitMouseUp ;is it still down?
|
||
TST.B (SP)+ ;well, is it?
|
||
BNE.S TrackGALoop ;if so, continue to loop
|
||
;
|
||
; the mouse button went up so flag the result and unhilite it if we have to
|
||
;
|
||
TST D5 ;were we in the button?
|
||
BEQ.S DoneGA ;if not, we're done
|
||
ADDQ.B #1,18(A6) ;flag it true, we're in the button
|
||
|
||
BSR.S EORSymbol ;unhilite the symbol
|
||
|
||
DoneGA
|
||
BSR RestorePort ;restore grafPort
|
||
MOVEM.L (SP)+,D3-D6/A3 ;restore work registers
|
||
UNLK A6
|
||
BRA TenBytExit
|
||
EndProc
|
||
|
||
;
|
||
; EORSymbol is a utility that exclusive ors the goAway button into the proper
|
||
; hilite state by invoking the windowProc to do the dirty work.
|
||
;
|
||
|
||
EORSymbol Proc Export
|
||
Import CallWindow
|
||
MOVEQ #WDrawMsg,D0 ;the message is draw
|
||
MOVEQ #0,D3 ; the param to the window defproc is a long <v1.6>
|
||
; so make sure that this word param has a
|
||
; clean hi word.
|
||
MOVE D6,D3 ; param is "GoAway"
|
||
BSR CallWindow ;call the window
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SelectWindow(theWindow: windowPtr);
|
||
;
|
||
; SelectWindow is called when the mouse button is clicked in a "behind"
|
||
; window. It unHilites the current FrontWindow, brings the new one to
|
||
; the front and then hilites it. It also posts activate/deactivate events.
|
||
; "DoActivate" is an alternative entry point that doesn't bother with the
|
||
; old top window at all.
|
||
;
|
||
|
||
SelectWindow Proc Export
|
||
Import BTF1
|
||
Import MakeDeactive
|
||
Import __ActiveWindow
|
||
Export SelWin1
|
||
Export DoActivate
|
||
|
||
CLR.W DragFlag ;clear implicit parm to BTF <LW10>
|
||
SelWin1
|
||
SUBQ #4,SP ;make room for FrontWindow result
|
||
JSR __ActiveWindow ;find out the old frontWindow <SM16> FM use ActiveWindow
|
||
MOVE.L 8(SP),-(SP) ;push the new window
|
||
JSR BTF1 ;bring it to the front
|
||
|
||
; We used to just assume that the BTF1 call made us the front window. When the <SM16> FM
|
||
; Layer manager was introduced they started checking which widnow ended up in front <SM16> FM
|
||
; after the BTF1 call with a call to __ActiveWindow. <SM16> FM
|
||
MOVE.L 8(SP),A0 ;get the window in A0
|
||
MOVE.B wVisible(A0),-(SP) ;save visible on stack
|
||
ST.B wVisible(A0) ;make it appear visible for ActiveWindow
|
||
|
||
SUBQ.L #4,SP ;Get the new frontwindow. This seems uncecessary <SM16> FM
|
||
JSR __ActiveWindow ;but thats the way the patch worked. <SM16> FM
|
||
MOVE.L 14(SP),A0 ;get the window in A0
|
||
MOVE.B 4(SP),wVisible(A0) ;restore wVisible
|
||
MOVE.L (SP)+,10(SP) ;its a side affect of layers. <SM16> FM
|
||
ADDQ #2,SP ; clear saved visible flag off the stack
|
||
|
||
MOVE.L (SP)+,D0 ;get the oldFrontWindow
|
||
BEQ.S DoActivate ;if NIL, don't bother
|
||
CMP.L 4(SP),D0 ;is it the same one?
|
||
BEQ.S SkipUnHilite ;if so, dont post events
|
||
|
||
JSR MakeDeactive ;go post the deactivate
|
||
|
||
; Note: Move D0 to curActivate before checking for window to activate. This clears
|
||
; curActivate if there are no (visible) windows left. <EHB 1/23/85>
|
||
|
||
DoActivate
|
||
MOVE.L 4(SP),D0 ;get the window to activate
|
||
MOVE.L D0,curActivate ;post the activate event <EHB 1/23/85>
|
||
BEQ.S NoActivate ;if none, skip <EHB 1/23/85>
|
||
SkipUnHilite
|
||
MOVE.L D0,-(SP) ;push the new window for HiliteWindow <12May87 DAF>
|
||
|
||
MOVE.L (SP),-(SP) ;copy it for ActivatePalette (actually HiliteWindow) <12May87 DAF>
|
||
|
||
ST -(SP) ;push "TRUE"
|
||
_HiliteWindow ;hilite the new one
|
||
|
||
_ActivatePalette ;activate its palette <12May87 DAF>
|
||
|
||
NoActivate MOVE.L (SP)+,(SP) ;strip the parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE BringToFront(window);
|
||
;
|
||
; bring the parameter window to the front of the list (right after the
|
||
; dialogWindow).
|
||
;
|
||
|
||
BLANKS ON
|
||
STRING ASIS
|
||
|
||
BringToFront Proc Export
|
||
Import SetWPort
|
||
Import GetNewRgn
|
||
Import PortToBitMap
|
||
Import NegWords
|
||
Import DeleteWindow
|
||
Import RestorePort
|
||
Export BTF1
|
||
|
||
CLR.W DragFlag ;we want to paint <LW10>
|
||
|
||
BTF1 MOVEM.L D3-D6/A2-A4,-(SP) ;save some work registers
|
||
MOVE.L 32(SP),A3 ;get the window pointer
|
||
BSR SETWPORT ;get into the wmgr port
|
||
LEA WindowList,A2 ;keep windowList ptr in A2
|
||
;
|
||
; check to see if its already on front -- if so, ignore the call
|
||
;
|
||
CMP.L (A2),A3 ;is it the front one?
|
||
BEQ BTFDone ;if so, we're done <27oct85> BBM
|
||
;
|
||
; calculate the union of all windows in front of us and then subtract this
|
||
; window from everyone who used to be on front
|
||
;
|
||
BSR GETNEWRGN ;allocate "clobbered" region
|
||
MOVE.L (SP)+,D3 ;keep clobbered in D3
|
||
MOVE.L (A2),A4 ;start with 1st window in list
|
||
BTFLoop
|
||
CMP.L A3,A4 ;done yet?
|
||
BEQ.S DONEUNION ;if so, exit loop
|
||
TST.B WVISIBLE(A4) ;is current one visible
|
||
BEQ.S NEXTBTF ;if not, don't bother unioning
|
||
;
|
||
MOVE.L A4,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),D6 ;get global topLeft of curWindow <C106 EHB>
|
||
MOVE.L VISRGN(A4),D5 ;get visRgn handle of curWindow
|
||
;
|
||
; offset the visRgn of current window to global coordinates, subtract the
|
||
; structRgn of the parameter window, then offset back to local coordinates
|
||
;
|
||
MOVE.L D5,-(SP) ;push the visRgn
|
||
MOVE.L D6,-(SP) ;push the offset point
|
||
BSR NEGWORDS ;negate offset
|
||
_OfsetRgn ;offset to global coordinates
|
||
;
|
||
MOVE.L D5,-(SP) ;push the visRgn
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;push the theWindow^.structRgn
|
||
MOVE.L D5,-(SP) ;result goes in visRgn
|
||
_DiffRgn ;visRgn := visRgn - structRgn
|
||
;
|
||
MOVE.L D5,-(SP) ;push the visRgn
|
||
MOVE.L D6,-(SP) ;push the offset
|
||
_OfsetRgn ;back to local coordinates
|
||
;
|
||
; add the structRgn of the current window to clobbered
|
||
;
|
||
MOVE.L STRUCTRGN(A4),-(SP) ;push curWindow^.structRgn
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
MOVE.L D3,-(SP) ;clobbered gets the result
|
||
_UnionRgn ;clobbered := clobbered + structRgn
|
||
|
||
NextBTF
|
||
MOVE.L NEXTWINDOW(A4),A4 ;get next window
|
||
MOVE.L A4,D0 ;is it NIL?
|
||
BNE.S BTFLOOP ;loop till done
|
||
;
|
||
; now that we have clobbered built, splice the window out of the list, insert it
|
||
; right behind the dialogWindow (i.e., the "front") and recalculate its visRgn
|
||
;
|
||
|
||
DoneUnion
|
||
MOVE.L A3,-(SP) ;push the window
|
||
BSR DELETEWINDOW ;splice it out of the list
|
||
;
|
||
; insert window as first one in list
|
||
;
|
||
MOVE.L (A2),NextWindow(A3)
|
||
MOVE.L A3,(A2)
|
||
;
|
||
; redraw the window, clipped to the union of those in front of it
|
||
;
|
||
TST.W DragFlag ;test if from MoveOptimized <LW10>
|
||
BNE.S DontPaint ;if so, we're done
|
||
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;push the structRgn of window
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
MOVE.L D3,-(SP) ;clobbered gets the result
|
||
_SectRgn ;make clobbered as small as we can
|
||
MOVE.L A3,-(SP) ;push the window pointer
|
||
MOVE.L D3,-(SP) ;push clobbered
|
||
|
||
; No need to calculate structure regions in the bring to front case because the window isn't moving <SM16> FM
|
||
move.l ExpandMem,a0 ;<SM16> FM
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; set the one-shot to keep from recalcing ancestor rgns
|
||
_PaintOne ;paint the window, clipped to clobbered
|
||
DontPaint
|
||
; Use CalcVBehind instead of CalcVis because of layers. <SM16> FM
|
||
MOVE.L A3,-(SP) ;push the window <SM16> FM
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;for now, everything's clobbered <SM16> FM
|
||
_CalcVBehind ;recalculate its visible region <SM16> FM
|
||
|
||
MOVE.L D3,-(SP) ;all done with clobbered region
|
||
_DisposRgn ;so we can dispose it
|
||
BTFDone
|
||
BSR RESTOREPORT ;set port back to what it was (was .S) <DAF 08-Apr-86>
|
||
MOVEM.L (SP)+,D3-D6/A2-A4 ;restore working registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
;
|
||
; NEGWORDS is a short utility intended to save code. It negates the two words on the
|
||
; top of the stack
|
||
;
|
||
|
||
NegWords Proc Export
|
||
NEG 4(SP) ;negate y coordinate
|
||
NEG 6(SP) ;negate x coordinate
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE SendBehind(window,behind: windowPtr)
|
||
;
|
||
; send a window behind another window, redrawing all exposed areas. If
|
||
; behind is NIL, send it to the back
|
||
;
|
||
; If SendBehind is actually moving a window to the front, we should paint starting with the window
|
||
; that ends up behind the window we are moving instead of the window that was behind it before we
|
||
; moved anything. To do this, we get the new “behind” window in A3, and then look through the list.
|
||
; If we never see that window in A3, then we know we should start painting there, but if we do see
|
||
; it, then we use the old code which paints from the old front window.
|
||
|
||
SendBehind Proc Export
|
||
Import SetWPort
|
||
Import DeleteWindow
|
||
Import InsertWindow
|
||
Import RestorePort
|
||
Import TwoParmExit
|
||
Import __ActiveWindow
|
||
|
||
MOVEM.L D3-D4/A2-A4,-(SP) ;save work registers
|
||
MOVE.L 28(SP),A3 ;get window pointer
|
||
BSR SETWPORT ;get into the window mgr port
|
||
;
|
||
SUBQ #4,SP ;make room for result
|
||
JSR __ActiveWindow ;figure out the frontmost window
|
||
CMP.L (SP)+,A3 ;is it this one?
|
||
BNE.S GoSendIt
|
||
;
|
||
; we're sending the frontMost window behind so go find the next visible window
|
||
; in the list and select it
|
||
;
|
||
MOVE.L A3,A0 ;get frontWindow in A0
|
||
|
||
@1 MOVE.L NextWindow(A0),A0 ;get the next window
|
||
MOVE.L A0,D0 ;is it NIL?
|
||
BEQ.S GoSendIt ;if so, dont call selectWindow
|
||
TST.B WVisible(A0) ;is it visible?
|
||
BEQ.S @1 ;if not, loop till we find one
|
||
|
||
MOVE.L A0,-(SP) ;we found one!
|
||
_SelectWindow ;select it
|
||
|
||
GoSendIt
|
||
MOVE.L A3,-(SP) ;push the window
|
||
BSR DELETEWINDOW ;splice it out of the list
|
||
MOVE.L STRUCTRGN(A3),D3 ;get its structRgn into a register
|
||
|
||
MOVE.L NEXTWINDOW(A3),-(SP) ;save the window currently behind the one we're moving
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
MOVE.L 32(SP),-(SP) ;push behind
|
||
BSR INSERTWINDOW ;insert it at the end of the list
|
||
|
||
; Check is the window moved forward or backward in the list.
|
||
move.l (sp),d0 ; get the window that WAS behind the window we moved
|
||
bra.s @start ; start with the NIL check
|
||
@loop
|
||
cmp.l d0,a3 ; if we find the window that is behind <34><35>
|
||
beq MovedBack ; we are moving window to the back
|
||
move.l d0,a0
|
||
move.l nextWindow(a0),d0
|
||
@start
|
||
bne.s @loop ; if we have another window, go looping
|
||
|
||
|
||
; Since we moved the window forward, nothing needs to be repainted except for the window we
|
||
; moved, which may now be exposed more. First, we calculate the visRgns of the moved window and all
|
||
; the windows behind it using CalcVBehind and the strucRgn of the moved window. Then, we figure out
|
||
; what part of the window was exposed by adding up all the strucRgns of the windows that it was
|
||
; moved in front of. We then use PaintOne to paint the window, but we set the flag that prevents
|
||
; CalcAncestorRgns, since this can never change the total region of windows in the layer.
|
||
MovedForward
|
||
move.l (sp)+,a4 ; save old behind window in non-volatile register
|
||
move.l a3,-(sp) ; calc the windows behind me
|
||
move.l d3,-(sp)
|
||
_CalcVBehind
|
||
|
||
; Union strucRgns of all windows that used to be in front of the window that moved,
|
||
; but are now behind it. We can find these windows by starting behind where the
|
||
; window is now, and stopping when we get where it was before it moved.
|
||
|
||
move.l nextWindow(a3),d0 ; start behind us
|
||
beq.s Done ; if nothing is behind us, we are done
|
||
move.l d0,a2 ; start with this window
|
||
|
||
subq #4,sp
|
||
_NewRgn
|
||
move.l (sp)+,d3 ; get a new region for unioning
|
||
|
||
@loop2
|
||
cmp.l a2,a4 ; check if we are done yet <36><39>
|
||
beq.s @doneUnionRgns ; if done => exit loop <39>
|
||
move.l structRgn(a2),-(sp) ; get the strucRgn
|
||
move.l d3,-(sp) ; union with our region
|
||
move.l d3,-(sp) ; destination in our region
|
||
_UnionRgn
|
||
move.l nextWindow(a2),a2 ; move to next window (will never be NIL before the end)
|
||
bra.s @loop2 ; <39>
|
||
@doneUnionRgns ; <39>
|
||
|
||
; Now we have a region including all windows that used to cover the window that
|
||
; moved but don’t cover it any more. By calling PaintOne with this region, we redraw
|
||
; only the newly revealed part of the window that moved.
|
||
|
||
move.l a3,-(sp)
|
||
move.l d3,-(sp) ; paint the newly exposed part of the moved window
|
||
move.l ExpandMem,a0
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; set the one-shot to keep from recalcing ancestor rgns
|
||
_PaintOne
|
||
|
||
move.l d3,-(sp)
|
||
_DisposeRgn ; get rid of that region
|
||
Done
|
||
bra Exit ;standard exit to save code
|
||
|
||
; Moved the window backwards in the list. This is the old SendBehind code mostly
|
||
|
||
MovedBack
|
||
move.l (sp),-(sp) ;2 copies for the next two calls…
|
||
MOVE.L D3,-(SP) ;push the structRgn
|
||
_CalcVBehind ;recalc the visRgns of guys below
|
||
MOVE.L D3,-(SP) ;push the structRgn
|
||
_PaintBehind ;redraw guys below us
|
||
;
|
||
Exit BSR RestorePort ;restore the users port
|
||
MOVEM.L (SP)+,D3-D4/A2-A4 ;restore registers
|
||
BRA TwoParmExit ;standard exit to save code
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE BeginUpdate(window: windowPtr);
|
||
;
|
||
; prepare a window for updating by saving its visRgn and then intersecting it
|
||
; with its update region. Remember the visRgn in global coordinates in case
|
||
; the user calls SetOrigin before calling EndUpdate.
|
||
;
|
||
|
||
BeginUpdate Proc Export
|
||
Import PortToBitMap
|
||
Import NegWords
|
||
IMPORT BeginUpdateOfLayersChildren
|
||
|
||
MOVEM.L D3-D4/A3,-(SP) ;save working registers
|
||
MOVE.L 16(SP),A3 ;get the windowPtr
|
||
|
||
MOVE.L A3,WMgrUpdate ; Copy the window pointer to a safe place.<SM16> FM
|
||
|
||
MOVE.L A3,-(SP) ; Check is this window is a layer <SM16> FM
|
||
JSR BeginUpdateOfLayersChildren ; And update its children if so… <SM16> FM
|
||
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),D3 ;get dh,dv (topLeft of boundsRect) <C106 EHB>
|
||
MOVE.L VISRGN(A3),D4 ;get the window's visRgn
|
||
;
|
||
MOVE.L D4,-(SP) ;push the visRgn
|
||
MOVE.L D3,-(SP) ;push dh,dv
|
||
BSR NEGWORDS ;negate offset (local -> global)
|
||
_OfsetRgn ;offset visRgn to global
|
||
;
|
||
; copy global version of visRgn into saveVisRgn
|
||
;
|
||
MOVE.L D4,-(SP) ;push visRgn
|
||
MOVE.L SAVEVISRGN,-(SP) ;make a copy of the visRgn
|
||
_CopyRgn ;in saveVisRgn
|
||
;
|
||
MOVE.L D4,-(SP) ;push visRgn
|
||
MOVE.L UPDATERGN(A3),-(SP) ;push the update region
|
||
MOVE.L D4,-(SP) ;the visRgn gets the result
|
||
_SectRgn ;intersect visRgn and updateRgn
|
||
;
|
||
MOVE.L D4,-(SP) ;push visRgn
|
||
MOVE.L D3,-(SP) ;push dh,dv
|
||
_OfsetRgn ;convert visRgn back to local
|
||
;
|
||
MOVE.L UPDATERGN(A3),-(SP) ;zero out the update region
|
||
_SetEmptyRgn ;zero it
|
||
|
||
; this was STDEXITONE ; <DAF>
|
||
|
||
MOVEM.L (SP)+,D3-D4/A3 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS
|
||
|
||
;
|
||
; PROCEDURE EndUpdate(window: windowPtr);
|
||
;
|
||
; EndUpdate is called by an application after completing an update to restore
|
||
; the window's visRgn back to normal
|
||
;
|
||
|
||
EndUpdate Proc Export
|
||
Import PortToBitMap
|
||
Import __CalcVis
|
||
|
||
; We should make sure that this endupdate call matches the BeginUpdate <SM16> FM
|
||
; Check WMgrUpdate to do this… <SM16> FM
|
||
|
||
MOVE.L WMgrUpdate, D0
|
||
CMP.L 4(SP), D0 ; Is it the right window?
|
||
BEQ.S @gotRightWindow ; Just CalcVis if not.
|
||
JMP __CalcVis ; exit now!
|
||
|
||
@gotRightWindow
|
||
CLR.L WMgrUpdate ; Clear the global.
|
||
|
||
MOVE.L A3,-(SP) ;save work register
|
||
MOVE.L 8(SP),A3 ;get the windowPtr
|
||
MOVE.L SAVEVISRGN,-(SP) ;push saved visRgn handle
|
||
MOVE.L (SP),-(SP) ;make a copy for later
|
||
MOVE.L (SP),-(SP) ;and another one
|
||
;
|
||
; offset global visRgn back to local
|
||
;
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),-(SP) ;push port.portBits.topLeft <C106 EHB>
|
||
_OfsetRgn ;global -> local
|
||
;
|
||
MOVE.L VISRGN(A3),-(SP) ;push current visRgn handle
|
||
_CopyRgn ;restore window's real visRgn
|
||
;
|
||
_SetEmptyRgn ;make saveVisRgn small to save space
|
||
;
|
||
MOVE.L (SP)+,A3 ;restore work register
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE DragWindow(window: windowPtr; startPt: Point; boundsRect: Rect);
|
||
;
|
||
; Drag a gray outline of a window around, tracking the mouse until the button goes up.
|
||
; Then use MoveWindow to move it to its new location
|
||
;
|
||
|
||
myKeyMap EQU -36 ;place to hold keyMap
|
||
WindowBounds EQU -16 ;rectangle for bounds when dragging
|
||
WindowFiller EQU -8 ;for historical reasons
|
||
|
||
DragWindow Proc Export
|
||
Import SetWPort
|
||
Import ClipGAbove
|
||
Import GetNewRgn
|
||
Import PortToBitMap
|
||
Import RestorePort
|
||
Import TwelveBytExit
|
||
|
||
LINK A6,#-36 ;allocate stack frame
|
||
MOVEM.L D3-D6/A3-A4,-(SP) ;save work registers
|
||
|
||
SUBQ #2,SP ;make room for result
|
||
_WaitMouseUp ;is mouse button stillDown?
|
||
TST.B (SP)+ ;well?
|
||
BEQ EXITDRAG ;if not, dont drag at all
|
||
;
|
||
; Set up window bounds and window slop rectangles based on the parameter boundsRect
|
||
;
|
||
MOVE.L 8(A6),A0 ;point to the users boundsRect
|
||
|
||
MOVE (A0)+,D0 ; get top
|
||
MOVE.W MBarHeight,D1 ; get height of menu bar <EHB 5Aug85>
|
||
ADDQ #4,D1 ; plus 4 <5Aug85>
|
||
CMP.W D1,D0 ; is the top at height+4 <5Aug85>
|
||
BHS.S SkipDrgPin ; if greater, we're cool
|
||
MOVE.W D1,D0 ; pin at height+4 <5Aug85>
|
||
SkipDrgPin
|
||
LEA WindowBounds(A6),A1 ;point to the DragTheRgn bounds
|
||
|
||
MOVE D0,(A1)+ ; move in bounds top
|
||
|
||
MOVE.W (A0)+,(A1)+ ;move in bounds left
|
||
MOVE.L (A0),(A1) ;move in bounds botRight
|
||
;
|
||
MOVE.L 12(A6),D3 ;get start point
|
||
MOVE.L 16(A6),A3 ;get window
|
||
BSR SETWPORT ;get into the wmgrPort
|
||
;
|
||
MOVE.L GrayRgn,-(SP) ;push grayRgn
|
||
_SetClip ;clip to the gray region
|
||
|
||
PEA myKeyMap(A6) ;push pointer to keyMap
|
||
_GetKeys ;read the keyMap
|
||
|
||
MOVE.B myKeyMap+6(A6),D6 ;command key down?
|
||
; Roll in patchDragGrayRgn from WindowMgrPatches.a <SM16> FM
|
||
; If the command key is down we want to clip above the window <SM16> FM
|
||
; we're dragging. If not we want to clip above the front most <SM16> FM
|
||
; window in this layer. <SM16> FM
|
||
|
||
BMI.S @commandKeyDown ;if so then clip above this window <SM16> FM
|
||
MOVE.L WindowList, A3 ;otherwise just ClipAbove the first window <SM16> FM
|
||
@commandKeyDown
|
||
BSR ClipGAbove ;clip to windows above us <SM16> FM
|
||
MOVE.L 16(A6),A3 ;get the window to drag back into A3 <SM16> FM
|
||
BSR GETNEWRGN ;allocate a region
|
||
MOVE.L (SP),A4 ;call it bodyRgn and keep in A4
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;copy the structure region
|
||
MOVE.L A4,-(SP) ;into the body
|
||
_CopyRgn ;do the copy
|
||
;
|
||
;room for result already on stack
|
||
MOVE.L A4,-(SP) ;push the region
|
||
MOVE.L D3,-(SP) ;push the mouse point
|
||
PEA WindowBounds(A6) ;push the boundsRect
|
||
MOVE.L (SP),-(SP) ;its also the slopRect
|
||
CLR.W -(SP) ;no axis constraints
|
||
CLR.L -(SP) ;no action proc
|
||
;
|
||
CLR.W DragFlag ; not dragging control thumb <SM29> CSS
|
||
_DragGrayRgn ;drag it until the mouse goes up
|
||
|
||
MOVE.L (SP)+,D5 ;get dV,dH
|
||
BEQ.S DontMove ;if it didn't move, handle special
|
||
CMP.W #$8000,D5 ;was it aborted?
|
||
BEQ.S DoneDrag ;if so, we're done
|
||
;
|
||
; figure out where to move the port to and move it
|
||
;
|
||
MOVE.L A3,-(SP) ;push the window for move call
|
||
MOVE.L PORTRECT(A3),D0 ;get the port rect topLeft
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
SUB.W BOUNDS+2(A0),D0 ;compute global x position <C106 EHB>
|
||
ADD D5,D0 ;add in delta X
|
||
MOVE.W D0,-(SP) ;push new x position
|
||
SWAP D0 ;get y in low part
|
||
SWAP D5 ;get deltaY in low part
|
||
SUB.W BOUNDS(A0),D0 ;compute global y position <C106 EHB>
|
||
ADD D5,D0 ;add in the y delta
|
||
MOVE.W D0,-(SP) ;push new y position
|
||
|
||
TST.B D6 ;command key down?
|
||
SPL -(SP) ;if not, push TRUE (bring to front)
|
||
_MoveWindow ;move it
|
||
|
||
DoneDrag
|
||
MOVE.L A4,-(SP) ;push temp region
|
||
_DisposRgn
|
||
;
|
||
BSR RESTOREPORT ;restore original port
|
||
|
||
ExitDrag
|
||
MOVEM.L (SP)+,D3-D6/A3-A4 ;restore register
|
||
UNLK A6 ;de-allocate stack frame
|
||
BRA TwelveBytExit ;standard exit saves code
|
||
|
||
;
|
||
; handle the case where the window didn't move
|
||
;
|
||
|
||
DontMove
|
||
TST.B D6 ;command key down?
|
||
BMI.S DoneDrag ;if so, we're done
|
||
|
||
MOVE.L A3,-(SP) ;push the window
|
||
_SelectWindow ;select it
|
||
BRA.S DoneDrag
|
||
EndProc
|
||
|
||
DragRegion Proc Export
|
||
Export DragGrayRgn
|
||
Export DragTheRgn
|
||
Export CallDragHook
|
||
Export WMgrGray
|
||
|
||
Import GetNewRgn
|
||
|
||
WMgrGray DC.W $AA55,$AA55,$AA55,$AA55
|
||
|
||
; alternate entry point to DragTheRgn that forces the drag pattern to gray
|
||
|
||
DragGrayRgn
|
||
MOVE.L WMgrGray,DragPattern ;copy into DragPattern
|
||
MOVE.L WMgrGray+4,DragPattern+4 ;better copy both halves
|
||
;
|
||
; FUNCTION DragTheRgn(theRgn,mousePt,boundsRect,slopRect,axis,actionProc): LongInt
|
||
;
|
||
; Drag the region around until the mouse button goes up. It respects the grafPort it
|
||
; is called from. It returns deltaX,deltaY (distance between final point and initial one)
|
||
; which will be $8000 if the button goes up outside the boundsRect. Don't drag the region
|
||
; out of the rect. The axis parameter is a 16-bit integer; if zero, there are no
|
||
; constraints, if its one it can only be dragged horizontally, if two only vertically.
|
||
;
|
||
; Parameter Equates
|
||
;
|
||
;
|
||
DragTheRgnFrame RECORD {A6Link},Decr
|
||
DragResult ds.l 1 ;long result -- amount moved
|
||
DRgn ds.l 1 ;region handle to input region
|
||
DMPoint ds.l 1 ;initial mouse point
|
||
DBoundsRect ds.l 1 ;the rect we can't leave
|
||
DSlopRect ds.l 1 ;the rect for throwaway decision
|
||
DAxis ds.w 1 ;integer specifying axis constraints
|
||
DActionProc ds.l 1 ;actionProc
|
||
retAddr ds.l 1
|
||
A6Link ds.l 1
|
||
Padding ds.w 1 ;not used, but in original equates
|
||
DSavePen ds.b psRec ;penState record (for wmgrPort)
|
||
DSaveCPen ds.b psRec ;penState record (for wmgrCPort)
|
||
OrigPort ds.l 1 ;incoming value of thePort
|
||
IsWMgrPort ds.w 1 ;true if thePort is a wmgrPort
|
||
FrameSize equ *
|
||
EndR
|
||
|
||
With DragTheRgnFrame
|
||
DragTheRgn LINK A6,#FrameSize ;make room for savePenState
|
||
MOVEM.L D3-D7/A3-A4,-(SP) ;reserve work registers
|
||
|
||
MOVE.L ExpandMem,A0 ;get ExpandMem globals <SM23>
|
||
ST ExpandMemRec.emIsDragging(A0) ;we're dragging <SM23>
|
||
|
||
LEA DMPoint(A6),A0 ;point to parameters
|
||
MOVE.L (A0)+,D3 ;get the mousePt
|
||
MOVE.L (A0)+,A3 ;get the region handle
|
||
CLR.L (A0) ;assume delta is zero
|
||
|
||
;
|
||
; save the penState before setting it to what we need for dragging
|
||
;
|
||
PEA DSavePen(A6) ;push pointer to savePenState
|
||
MOVE.L (SP),-(SP) ;dup for later restore
|
||
_GetPenState ;save the pen state
|
||
;
|
||
; set up the pen for dragging
|
||
;
|
||
PEA DragPattern ;XOR specified pattern
|
||
_PenPat
|
||
MOVE #14,-(SP) ;set pen mode to notPatXor
|
||
_PenMode
|
||
move.l OneOne,-(sp)
|
||
_PenSize ; Make sure that a thin outline is dragged
|
||
|
||
;
|
||
; since FrameRgn is too slow, build a region that is just the outline so we
|
||
; can paint it fast
|
||
;
|
||
|
||
bsr GetNewRgn
|
||
move.l (sp)+,a4 ; This is a scratch region for flicker free dragging
|
||
|
||
MOVE.L A3,-(SP) ;push full region on stack for later
|
||
BSR GETNEWRGN ;allocate another region
|
||
MOVE.L (SP),D4 ;keep in D4 (leave on stack)
|
||
_CopyRgn ;copy full region to temp in D4
|
||
|
||
MOVE.L D4,-(SP) ;push temp region
|
||
MOVE.L ONEONE,-(SP) ;inset by 1
|
||
_InsetRgn
|
||
MOVE.L A3,-(SP) ;push full region
|
||
MOVE.L D4,-(SP) ;push inset one
|
||
MOVE.L A3,-(SP) ;original one stays around
|
||
_DiffRgn ;turn it into a frame by subtracting
|
||
|
||
MOVE.L D4,-(SP) ;get rid of temp region
|
||
_DisposRgn
|
||
|
||
MOVE.L A3,-(SP) ;draw initial frame
|
||
bsr DrawDraggedRgn ;draw it <SM29> CSS
|
||
MOVEQ #-1,D5 ;flag it as visible and active
|
||
|
||
; so that we can use multiple screens, look to see if the bounds rect is derived from
|
||
; screenbits. If it is, then pin to the grayRgn instead of the boundsrect. Also pin to
|
||
; the grayRgn instead of the sloprect. If bounds not screenbits, then just use provided
|
||
; bounds and slop, but convert them to regions for ease of coding.
|
||
|
||
BSR GETNEWRGN ;;allocate bounds region
|
||
MOVE.L (SP)+,D6 ;;keep in D6
|
||
BSR GETNEWRGN ;;allocate slop region
|
||
MOVE.L (SP)+,D7 ;;keep in D7
|
||
|
||
MOVE.L GRAFGLOBALS(A5),A0 ;;point to grafGlobals
|
||
LEA SCREENBITS+BOUNDS(A0),A0;;point to screenbits.bounds
|
||
MOVE.L 4(A0),-(SP) ;;push botRight
|
||
MOVE.L (A0),-(SP) ;;push topleft
|
||
MOVE MBarHeight,D0 ;;get mbarHeight
|
||
ADD D0,TOP(SP) ;;bump top by mbarheight
|
||
ADD #30,TOP(SP) ;;and make room for ghost windows
|
||
MOVE.L SP,-(SP) ;;point to rect
|
||
MOVE.L #$00060006,-(SP) ;;inset bounds by six
|
||
_InsetRect
|
||
|
||
MOVE.L 4(SP),-(SP) ;;push botRight
|
||
MOVE.L 4(SP),-(SP) ;;push topLeft
|
||
|
||
CLR.B -(SP) ;;prepare for boolean result
|
||
PEA 2(SP) ;;push srcrect1
|
||
MOVE.L DBoundsRect(A6),-(SP) ;;push srcrect2
|
||
PEA 10(SP) ;;push dstrect = srcRect1
|
||
_SectRect ;;get intersection
|
||
TST.B (SP)+ ;;ignore result
|
||
|
||
CLR.B -(SP) ;;prepare for boolean result
|
||
PEA 10(SP) ;;push our original inset
|
||
PEA 6(SP) ;;push result of intersection
|
||
_EqualRect ;;are they equal
|
||
TST.B (SP)+ ;;test result
|
||
ADD #16,SP ;;strip 2 rectangles
|
||
BEQ.S NotEqual ;;=>no, do pinning old way
|
||
|
||
MOVE.L grayRgn,-(SP) ;;push grayRgn
|
||
MOVE.L D7,-(SP) ;;push slopRgn
|
||
_CopyRgn ;;slopRgn := grayRgn
|
||
MOVE.L D7,-(SP) ;;push slopRgn
|
||
MOVE.L #$00040004,-(SP) ;;inset gray rgn by four
|
||
_InsetRgn
|
||
|
||
MOVE.L D7,-(SP) ;;copy slopRgn
|
||
MOVE.L D6,-(SP) ;;to boundsRgn
|
||
_CopyRgn ;;boundsRgn := grayRgn
|
||
BRA.S DragLoop ;;=>dive into loop
|
||
|
||
NotEqual
|
||
MOVE.L D7,-(SP) ;;push slopRgn
|
||
MOVE.L DSlopRect(A6),-(SP) ;;push slopRect
|
||
_RectRgn ;;slopRgn := RectRgn(slopRect)
|
||
|
||
MOVE.L D6,-(SP) ;;push boundsRgn
|
||
MOVE.L DBoundsRect(A6),-(SP) ;;push boundsRect
|
||
_RectRgn ;;boundsRect := RectRgn(boundsRect)
|
||
|
||
;
|
||
; here is the main drag loop -- first read the mouse in our local coordinates
|
||
;
|
||
|
||
DragLoop
|
||
SUBQ #6,SP ;make room for results
|
||
MOVE.L SP,-(SP) ;push pointer to result buffer
|
||
_GetMouse ;read the current mouse position
|
||
MOVE.L (SP),D4 ;remember pt in D4 (keep on stack)
|
||
;
|
||
; see if the point is in the boundsRect; if it isn't, don't move the region
|
||
;
|
||
MOVE.L D6,-(SP) ;;push the bounds rgn
|
||
_PtInRgn ;;test if the point is inside the region
|
||
TST.B (SP)+ ;is it? (moved out of conditional) <C491/08Dec86> DAF
|
||
BEQ OutOfBounds ;if not, don't move
|
||
|
||
;
|
||
; get y in low part of D1, x in low part of D4
|
||
;
|
||
|
||
DragInBounds
|
||
MOVE.L D4,D1 ;copy whole point
|
||
SWAP D1 ;get y in low part
|
||
CMP.L D4,D3 ;did it move?
|
||
BEQ.S NOMOTION ;if not, skip
|
||
;
|
||
; it moved so compute dh,dv and move it
|
||
;
|
||
MOVE.L D4,-(SP) ;save current position
|
||
SUB D3,D4 ;compute Dx
|
||
SWAP D3
|
||
SUB D3,D1 ;compute Dy
|
||
;
|
||
; if we constrained, don't allow any motion in the axis we're constrained to
|
||
;
|
||
MOVE DAxis(A6),D0 ;any constraints?
|
||
BEQ.S NConstraint ;if not, skip
|
||
SUBQ #1,D0 ;horizontally?
|
||
BNE.S @1 ;if not, it must be vertical
|
||
CLR D1 ;make v offset 0 (h only)
|
||
BRA.S NConstraint
|
||
@1
|
||
CLR D4 ;make h offset 0 (v only)
|
||
;
|
||
; update the continuous offset result
|
||
;
|
||
|
||
NConstraint
|
||
ADD D1,DragResult(A6) ;accumulate y offset
|
||
ADD D4,DragResult+2(A6) ;accumulate x offset
|
||
|
||
;
|
||
; Make a copy of the dragging region
|
||
;
|
||
|
||
move.w d1,-(sp) ;Save D1 (y delta) Sure wish there was a free register! <SM39>
|
||
move.l a3,-(sp)
|
||
move.l a4,-(sp)
|
||
_CopyRgn
|
||
move.w (sp)+,d1 ;Restore D1 cuz CopyRgn doesn't preserve it Ernie! <SM39>
|
||
|
||
;
|
||
; offset the copy to new position and update the screen
|
||
;
|
||
|
||
MOVE.L a3,-(SP) ;push the region
|
||
MOVE.W D4,-(SP) ;push dx
|
||
MOVE.W D1,-(SP) ;push dy
|
||
_OfsetRgn ;offset to new position
|
||
|
||
tst.w d5 ; See if it’s visible
|
||
bnz.s @regionIsVisible ; If it is, do the Xor to do a combination erase/paint
|
||
move.l a3,-(sp) ; The drag region just came back into boundRect, so it needs to be draw anew
|
||
bsr DrawDraggedRgn ; Doing the Xor would also redraw the region in it’s last visible location, leaving garbage on the screen <SM29> CSS
|
||
bra.s @markOutlineVisible ; Just paint the region in it’s new position
|
||
|
||
@regionIsVisible
|
||
move.l a4,-(sp) ; Push the region before it was offset
|
||
move.l a3,-(sp) ; Push the region in it’s new location
|
||
move.l a4,-(sp) ; Mess with the copy
|
||
_XorRgn ; Make a region that’s the difference between the two locations
|
||
move.l a4,-(sp) ; Just paint this difference
|
||
bsr DrawDraggedRgn ; <SM29> CSS
|
||
@markOutlineVisible
|
||
MOVEQ #-1,D5 ;mark it active again
|
||
MOVE.L (SP)+,D3 ;update new position
|
||
NoMotion
|
||
MOVE.L DActionProc(A6),D0 ;get the actionProc
|
||
BSR CallDrg1 ;call it if we got one
|
||
BSR CallDragHook ;call the user if she's installed
|
||
;
|
||
; wait at least 2 ticks to avoid disappearing
|
||
;
|
||
MOVE.L Ticks,D0
|
||
ADDQ.L #2,D0 ;bump it two ticks
|
||
DragDelay
|
||
CMP.L Ticks,D0 ;has ticks caught up yet?
|
||
BHI.S DragDelay ;loop till it has <14Jan86>
|
||
;
|
||
SUBQ #2,SP ;make room for function result
|
||
_WaitMouseUp ;is button stillDown?
|
||
TST.B (SP)+ ;examine result
|
||
BNE.S DRAGLOOP ;loop if it is
|
||
;
|
||
; the mouse went up so remove outline (if visible), restore pen and we're done
|
||
;
|
||
TST D5 ;is it visible?
|
||
BEQ.S ItsClear ;if not, don't bother
|
||
|
||
MOVE.L A3,-(SP) ;push region handle
|
||
bsr DrawDraggedRgn ;remove outline of region <SM29> CSS
|
||
|
||
ItsClear
|
||
_SetPenState ;restore old pen state
|
||
|
||
; This is probably not necessary, but to avoid compatibility problems,
|
||
; make sure that the returned region is the (offset) frame of the original region.
|
||
|
||
MOVE.L (A3),A0 ;point at the region <C624>
|
||
CMP #$A,RgnSize(A0) ;is it rectangular? <C624>
|
||
BNE.S @NoRect ;=>no, not a rect <C624>
|
||
|
||
MOVE.L A3,-(SP) ;push full region on stack for later <C624>
|
||
MOVE.L D6,-(SP) ;push temp region <C624>
|
||
_CopyRgn ;copy full region to temp in D4 <C624>
|
||
|
||
MOVE.L D6,-(SP) ;push temp region <C624>
|
||
MOVE.L ONEONE,-(SP) ;inset by 1 <C624>
|
||
_InsetRgn
|
||
MOVE.L A3,-(SP) ;push full region <C624>
|
||
MOVE.L D6,-(SP) ;push inset one <C624>
|
||
MOVE.L A3,-(SP) ;original one stays around <C624>
|
||
_DiffRgn ;turn it into a frame by subtracting <C624>
|
||
|
||
@NoRect
|
||
@99
|
||
|
||
;
|
||
; if the last point isn't inside the slopRect, make sure we return an offset of 0
|
||
;
|
||
SUBQ #6,SP ;make room for results
|
||
MOVE.L SP,-(SP) ;push pointer to result buffer
|
||
_GetMouse ;read the current mouse position
|
||
MOVE.L D7,-(SP) ;push slopRect pointer
|
||
_PtInRgn ;is the point in the slopRect?
|
||
|
||
TST.B (SP)+ ;is it?
|
||
BNE.S @3 ;if so, skip zeroing offset
|
||
;
|
||
; flag it as aborted
|
||
;
|
||
MOVE.L #$80008000,DragResult(A6) ;set delta to large neg number
|
||
@3
|
||
MOVE.L D7,-(SP) ;dispose of slop region
|
||
_DisposRgn
|
||
MOVE.L D6,-(SP) ;dispose of bounds region
|
||
_DisposRgn
|
||
move.l a4,-(sp)
|
||
_DisposRgn ; Dispose of secondary dragging region
|
||
|
||
MOVE.L ExpandMem,A0 ;get ExpandMem globals <SM23>
|
||
CLR.B ExpandMemRec.emIsDragging(A0) ;we're done dragging <SM23>
|
||
|
||
MOVEM.L (SP)+,D3-D7/A3-A4 ;restore work registers
|
||
UNLK A6 ;deallocate stack frame
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
ADD #22,SP ;strip parameters
|
||
JMP (A0) ;return to caller
|
||
|
||
;
|
||
; CallDragHook calls the user's drag hook routine, if one is installed
|
||
;
|
||
|
||
CallDragHook
|
||
MOVE.L DragHook,D0 ;is there a hook routine?
|
||
CallDrg1
|
||
BEQ.S NoDHook ;if not, don't bother
|
||
MOVE.L D0,A0 ;get the hook routine
|
||
JSR (A0) ;call it
|
||
;
|
||
NoDHook RTS ;all done!
|
||
|
||
;
|
||
; OutOfBounds is called from the main loop when the mousePt is outside of the
|
||
; boundsRect. If its outside the slopRect turn it off, if its inside, turn it on
|
||
;
|
||
|
||
OutOfBounds
|
||
SUBQ #2,SP ;make room for result
|
||
MOVE.L D4,-(SP) ;push the mouse point
|
||
MOVE.L D7,-(SP) ;;push the slop region
|
||
_PtInRgn ;;is mouse in slop rgn
|
||
TST.B (SP)+ ;is it?
|
||
BNE.S InSlopRect ;if it is, go handle it
|
||
;
|
||
; its not in the slopRect so make it invisible
|
||
;
|
||
TST D5 ;is it visble
|
||
BEQ.S NoMotion ;if its already invisible, we're done
|
||
MOVEQ #0,D5 ;set its state to invisible
|
||
GoPaintRgn
|
||
MOVE.L A3,-(SP) ;push region again
|
||
bsr DrawDraggedRgn ;get rid of it <SM29> CSS
|
||
|
||
@Fast BRA.S NoMotion ;all done
|
||
|
||
;
|
||
; its in the slopRect, but not in the boundsRect. Make it visible again if it was
|
||
; invisible
|
||
;
|
||
|
||
InSlopRect
|
||
TST D5 ;examine visible state
|
||
BNE.S PinBounds ;if already visible, pin at bounds
|
||
MOVEQ #1,D5 ;flag it visible but frozen
|
||
BRA.S GoPaintRgn ;if not, go paint it
|
||
|
||
;
|
||
; we're out of the bounds so fake up a mouse point that's inside the bounds to pin at
|
||
; the edge
|
||
;
|
||
|
||
PinBounds
|
||
SUBQ #4,SP ;make room for result
|
||
MOVE.L DBoundsRect(A6),-(SP) ;push the boundsRect pointer
|
||
MOVE.L D4,-(SP) ;push the point
|
||
_PinRect ;figure out inside point
|
||
MOVE.L (SP)+,D4 ;get the pinned point
|
||
BRA DragInBounds ;pretend it was inside
|
||
|
||
; <SM29> CSS The following is a new routine to paint the dragging region to fix the
|
||
; scroll bar thumb appearing in yellow.
|
||
|
||
DrawDraggedRgn
|
||
tst.w DragFlag ; control manager dragging thumb?
|
||
bne.s @dragThumb ; Yes. Force black drag
|
||
|
||
; We’re doing normal outline dragging, so just paint the region.
|
||
|
||
@paintnormal
|
||
move.l 4(sp),-(sp) ; get rgn to paint
|
||
_PaintRgn
|
||
move.l (sp)+,(sp) ; strip parameter
|
||
rts
|
||
|
||
; To get the thumb to show up in color against the scroll bar’s gray background,
|
||
; force the region outline to draw in black.
|
||
|
||
@dragThumb
|
||
move.l ExpandMem,a0
|
||
move.L ExpandMemRec.emControlHandle(a0),d1 ; get control handle saved for us in _DragControl
|
||
beq.s @paintnormal ; do the normal painting if there's no controldefhandle. <LW11>
|
||
move.l d1,a0
|
||
move.l (a0),a0 ; get the ptr to control record
|
||
move.l contrlDefHandle(a0),d0 ; get the CDEF handle
|
||
_StripAddress
|
||
move.l d0,a0
|
||
move.l (a0),a0 ; get the ptr to CDEF
|
||
cmp.l #'CDEF',4(a0) ; just for yucks make sure this is a CDEF
|
||
bne.s @paintnormal ; paint normal if our handle is bad
|
||
btst #0,3(a0) ; Can CDEF handle this message?
|
||
beq @paintnormal ; no --> normal paint
|
||
move.l 4(sp),d0 ; get rgn to draw
|
||
clr.l -(sp) ; make room for function result
|
||
clr.w -(sp) ; zero variant
|
||
move.l d1,-(sp) ; save control handle
|
||
move.w #drawThumbOutlineMsg,-(sp) ; draw thumb rgn outline message
|
||
move.l d0,-(sp) ; rgn to draw
|
||
; note: we don't need to lock this handle
|
||
; because the client (of the control) should
|
||
; already have locked it.
|
||
jsr (a0) ; call the control
|
||
addq #4,sp ; strip function result
|
||
move.l (sp)+,(sp) ; strip parameter
|
||
rts
|
||
EndWith
|
||
EndProc
|
||
;
|
||
; PROCEDURE InvalRgn( badRgn: regionHandle);
|
||
;
|
||
; invalidate a region by adding it to the current window's update region. The region
|
||
; is assumed to be in local coordinates
|
||
;
|
||
|
||
InvalRgn Proc Export
|
||
Export IValCommon
|
||
Export GoExit1
|
||
Import PortToBitMap
|
||
Import NegWords
|
||
|
||
MOVEQ #0,D0 ;signal invalidate
|
||
|
||
;
|
||
; common code for invalRgn and valRgn
|
||
;
|
||
|
||
IValCommon
|
||
MOVEM.L D3-D5/A3,-(SP) ;save work registers
|
||
MOVE D0,D5 ;remember flag in D5
|
||
MOVE.L GrafGlobals(A5),A0 ;get LisaGraf globals base
|
||
MOVE.L THEPORT(A0),A3 ;get current window
|
||
MOVE.L 20(SP),D4 ;get region handle
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),D3 ;get port bounds topLeft <C106 EHB>
|
||
MOVE.L D4,-(SP) ;push the regionHandle
|
||
MOVE.L D3,-(SP) ;push topLeft
|
||
BSR NEGWORDS ;negate it
|
||
_OfsetRgn ;offset to global coordinates
|
||
;
|
||
MOVE.L UPDATERGN(A3),-(SP) ;push update region
|
||
MOVE.L D4,-(SP) ;push region to be unioned
|
||
MOVE.L UPDATERGN(A3),-(SP) ;result goes in update region
|
||
TST D5 ;union or difference?
|
||
BNE.S GODIFFIT
|
||
_UnionRgn ;union them together
|
||
BRA.S SKIP1DIFFIT
|
||
GoDiffIt
|
||
_DiffRgn
|
||
Skip1DiffIt
|
||
MOVE.L D4,-(SP) ;push parameter region
|
||
MOVE.L D3,-(SP) ;push portBounds
|
||
_OfsetRgn ;back to local coordinates
|
||
GoExit1
|
||
MOVEM.L (SP)+,D3-D5/A3 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE InvalRect(badRect: RECT);
|
||
;
|
||
; Invalidate a rectangular area by adding it to the current window's update region.
|
||
; The rectangle is assumed to be in local coordinates
|
||
;
|
||
|
||
InvalRect Proc Export
|
||
Export IRectCommon
|
||
Import IValCommon
|
||
Import GoExit1
|
||
|
||
MOVEQ #0,D0 ;flag that its inval
|
||
;
|
||
; common code for inval/val rect
|
||
;
|
||
|
||
IRectCommon
|
||
MOVEM.L D2-D5/A3,-(SP) ;save work registers (& one extra)
|
||
MOVE D0,D5 ;remember flag in D5
|
||
|
||
_NewRgn ;allocate a new region
|
||
MOVE.L (SP),D4 ;keep rgnHandle in D4 (leave on stack, too)
|
||
MOVE.L 24(SP),-(SP) ;push badRect pointer
|
||
_RectRgn ;set the region to the rectangle
|
||
MOVE.L D4,-(SP) ;push the region handle
|
||
MOVE D5,D0 ;get flag in D0
|
||
BSR.S IVALCOMMON ;invalidate it
|
||
;
|
||
MOVE.L D4,-(SP) ;push region handle
|
||
_DisposRgn ;de-allocate it
|
||
BRA GOEXIT1 ;standard exit saves code
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE ValidRgn(goodRgn: regionHandle);
|
||
;
|
||
; Validate a region by subtracting it from the current window's update region.
|
||
; The region is assumed to be in local coordinates. It shares lots of common code
|
||
; with InvalidRgn
|
||
;
|
||
|
||
ValidRgn Proc Export
|
||
Import IValCommon
|
||
|
||
MOVEQ #-1,D0 ;flag it as a val call
|
||
BRA IVALCOMMON ;let common code do the rest
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE ValidRect(goodRect: RECT);
|
||
;
|
||
; Validate a rectangular area by subtracting from to the current window's update region.
|
||
; The rectangle is assumed to be in local coordinates. It share lots of common code
|
||
; with InvalidRect.
|
||
;
|
||
|
||
ValidRect Proc Export
|
||
Import IRectCommon
|
||
MOVEQ #-1,D0 ;flag it as a val call
|
||
BRA IRECTCOMMON ;let common code do the rest
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION GrowWindow(window: windowPtr; mousePt: Point; bBox: Rect): LongInt;
|
||
;
|
||
; GrowWindow is called when the mouse goes down in the grow icon of a window
|
||
; It drags out a flickering outline by calling the window definition procedure
|
||
; and returns the new size as the result of the function. the bBox specifies
|
||
; the min and max size the window is limited to
|
||
;
|
||
|
||
GWRect EQU -8
|
||
GWPenState EQU -28
|
||
GWSRect EQU -36 ;;copy of size rect <C491/08Dec86> DAF
|
||
GWKeyMap EQU -72 ;;key map <C491/08Dec86> DAF
|
||
GWPenCState EQU -92
|
||
GWFrameSize EQU GWPenCState
|
||
|
||
GrowWindow Proc Export
|
||
Import WMgrGray
|
||
Import SetWPort
|
||
Import ClipGAbove
|
||
Import PortToBitMap
|
||
Import NegWords
|
||
Import CallGrow
|
||
Import GWCalcSize
|
||
Import DeltaPoint
|
||
Import GetPinMouse
|
||
Import CallDragHook
|
||
Import RestorePort
|
||
Export TwelveBytExit
|
||
|
||
LINK A6,#GWFrameSize ;build stack frame
|
||
MOVEM.L D3-D7/A3-A4,-(SP) ;save work registers
|
||
;
|
||
; save old grafPort in D4 and get into the window manager port
|
||
;
|
||
BSR SetWPort ;get into wmgrPort
|
||
MOVE.L 12(A6),D3 ;get the mouse point
|
||
MOVE.L 16(A6),A3 ;get the window
|
||
;
|
||
; clip to the windows above the current one
|
||
;
|
||
BSR ClipGAbove ;clip to windows above us
|
||
;
|
||
; preserve the current penState and then set up gray,notPatXor
|
||
;
|
||
PEA GWPenState(A6) ;push pen save area address
|
||
MOVE.L (SP),-(SP) ;dup for later restore
|
||
_GetPenState ;remember current state
|
||
_PenNormal ;reset pen to normal state
|
||
MOVE #notPatXor,-(SP) ;push desired xfer mode
|
||
_PenMode ;set the mode
|
||
PEA WMgrGray ;push the pattern
|
||
_PenPat ;set it
|
||
|
||
|
||
;
|
||
; build initial boundsRect and draw the initial grow outline
|
||
;
|
||
LEA GWRect(A6),A4 ;get window rect pointer
|
||
MOVE.L PortRect(A3),(A4) ;copy topLeft
|
||
MOVE.L PortRect+4(A3),4(A4) ;copy botRight, toop
|
||
MOVE.L A4,-(SP) ;push a pointer to the rect
|
||
MOVE.L A3,A0 ;get port pointer <C106 EHB>
|
||
BSR PortToBitMap ;convert to bit/pixmap pointer <C106 EHB>
|
||
MOVE.L BOUNDS(A0),-(SP) ;push bitmap.bounds.topLeft <C106 EHB>
|
||
BSR NegWords ;negate offset (local -> global)
|
||
_OffsetRect ;offset rect to global
|
||
BSR CallGrow ;draw the outline <27oct85> BBM
|
||
;
|
||
; remember the initial size before we start
|
||
;
|
||
BSR GWCalcSize ;calc the size of rect in A4
|
||
MOVE.L D0,D6 ;remember in D6
|
||
;
|
||
; compute offset from starting bottom right and keep in D5
|
||
;
|
||
SUBQ #4,SP ;make room for result
|
||
MOVE.L D3,-(SP) ;push mouse pt
|
||
MOVE.L BotRight(A4),-(SP) ;push bottom right
|
||
BSR DeltaPoint ;get the offset
|
||
MOVE.L (SP)+,D5 ;keep in D5
|
||
;
|
||
; here is the main loop -- read the mousePoint, compute difference from oldPoint.
|
||
; If it moved, adjust the rectangle and redraw it. Keep doing this until the
|
||
; mouse button goes up.
|
||
;
|
||
GDragLoop
|
||
MOVE.L D3,-(SP) ;remember old point
|
||
BSR GetPinMouse ;calculate the new bottom right <27oct85> BBM
|
||
MOVE.L (SP),D0 ;recover old point
|
||
MOVE.L D3,-(SP) ;push new point
|
||
MOVE.L D0,-(SP) ;push old point
|
||
BSR DeltaPoint ;compute difference
|
||
|
||
MOVE.L (SP)+,D7 ;get the offset
|
||
BEQ.S GDNextLoop ;if not, skip
|
||
;
|
||
; erase, set up new position, redraw
|
||
;
|
||
BSR.S CallGrow ;erase it
|
||
ADD.W D7,Right(A4) ;add delta x to right
|
||
SWAP D7 ;get v delta
|
||
ADD.W D7,Bottom(A4) ;add delta y to bottom
|
||
BSR CallGrow ;redraw in new position
|
||
;
|
||
; call the user's hook routine (if installed) and then loop while the mouse button
|
||
; is still down.
|
||
;
|
||
GDNextLoop
|
||
BSR CallDragHook ;call user if installed
|
||
CLR.W -(SP) ;make room for result
|
||
_WaitMouseUp ;is it still down?
|
||
TST.B (SP)+ ;well, is it???
|
||
BNE.S GDragLoop ;loop till it goes up
|
||
;
|
||
; the mouse button went up so get rid of the outline
|
||
;
|
||
BSR CallGrow ;undraw the outline
|
||
;
|
||
; now figure out the size of the rectangle and return that as the result
|
||
;
|
||
BSR GWCalcSize ;calculate the new size in D0
|
||
CMP.L D0,D6 ;save as it used to be?
|
||
BNE.S @1 ;if not, we're cool
|
||
MOVEQ #0,D0 ;if so, return 0
|
||
@1 MOVE.L D0,20(A6) ;return new size as function result
|
||
;
|
||
; Ok, we're all done -- restore penState, port and work registers before returning
|
||
;
|
||
_SetPenState ;remember current state
|
||
;
|
||
BSR RestorePort ;restore old grafPort
|
||
;
|
||
MOVEM.L (SP)+,D3-D7/A3-A4 ;restore work registers
|
||
UNLK A6 ;unbuild stack frame
|
||
TwelveBytExit
|
||
MOVE.L (SP)+,A0 ;get return address
|
||
ADD #12,SP ;strip parameters
|
||
JMP (A0) ;return to caller
|
||
;
|
||
; CallGrow issues the Grow message to a window to tell it to draw its grow frame
|
||
;
|
||
|
||
CallGrow Proc Export
|
||
Import CallWindow
|
||
|
||
MOVE.L D3,-(SP) ;preserve D3
|
||
MOVEQ #WGrowMsg,D0 ;get the grow message
|
||
MOVE.L A4,D3 ;the rectangle is the parameter
|
||
BSR CallWindow ;tell the window
|
||
MOVE.L (SP)+,D3 ;restore D3
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; GetPinMouse returns the current mouse position in D3. It sometimes lies
|
||
; to make sure it never exceeds the bounds specified by the SizeRect.
|
||
;
|
||
|
||
GetPinMouse Proc Export
|
||
Import DeltaPoint
|
||
Import GWCalcSize
|
||
|
||
MOVE.L BotRight(A4),-(SP) ;remember botRight
|
||
SUBQ #8,SP ;make room for mousePt, result
|
||
MOVE.L SP,-(SP) ;push ptr to mousePt buffer
|
||
_GetMouse ;get the current mouse position
|
||
|
||
; subtract base offset from mousePt
|
||
|
||
MOVE.L D5,-(SP) ;push the base offset
|
||
BSR DeltaPoint ;subtract it
|
||
|
||
MOVE.L 8(A6),A0 ;;point to size rect
|
||
LEA GWSRect(A6),A1 ;;point to our copy
|
||
MOVE.L (A0)+,(A1)+ ;;copy topleft
|
||
MOVE.L (A0)+,(A1)+ ;;copy botright
|
||
|
||
PEA GWKeyMap(A6) ;;push pointer to keyMap
|
||
_GetKeys ;;read the keyMap
|
||
TST.B GWKeyMap+6(A6) ;;command key down? <C970/22Nov87> DAF
|
||
BPL.S NoCmd ;;if not, restrict max size
|
||
MOVE.L #$7FFE7FFE,GWSRect+BotRight(A6) ;;else open up max size
|
||
|
||
NoCmd MOVE.L (SP)+,BotRight(A4) ;make it the new bottom right
|
||
BSR.S GWCalcSize ;calculate the new size into D0
|
||
MOVE.L (SP),BotRight(A4) ;restore original size
|
||
|
||
PEA GWSRect(A6) ;;point to fudged sizeRect
|
||
MOVE.L D0,-(SP) ;;push new size
|
||
_PinRect ;;and pin to fudged sizeRect
|
||
|
||
SWAP D5 ;get y offset
|
||
MOVE Top(A4),D3 ;get top value
|
||
ADD.W (SP)+,D3 ;compute pinned bottom
|
||
ADD.W D5,D3 ;add base offset
|
||
SWAP D3 ;get x
|
||
SWAP D5
|
||
MOVE Left(A4),D3 ;get left value
|
||
ADD.W (SP)+,D3 ;compute pinned right
|
||
ADD.W D5,D3 ;add base offset
|
||
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; GWCalcSize calculates the size of the rectangle pointed to by A4. It returns
|
||
; the size as a LisaGraf point in D0
|
||
;
|
||
|
||
GWCalcSize Proc Export
|
||
SUBQ #4,SP ;make room for result
|
||
MOVE.L BotRight(A4),-(SP) ;push bottom right
|
||
MOVE.L TopLeft(A4),-(SP) ;push topLeft
|
||
BSR DeltaPoint ;subtract them
|
||
MOVE.L (SP)+,D0 ;get the result
|
||
RTS
|
||
EndProc
|
||
|
||
;
|
||
; FUNCTION FindWindow(thePoint: Point;
|
||
; VAR theWindow: WindowPtr): INTEGER;
|
||
;
|
||
; FindWindow is the routine that correlates a mouse position with the logical
|
||
; data structure in that position. It passes back the window pointer of the
|
||
; window the point is in as well as a classification code further classifying
|
||
; the position.
|
||
;
|
||
|
||
__FindLayer Proc Export
|
||
Import CallMBarProc
|
||
Import CallWindow
|
||
Import TwoParmExit
|
||
|
||
MOVEM.L D1/D3/A3,-(SP) ;save work registers <23-Oct-85 EHB>
|
||
;
|
||
; assume classification code is zero (inDesk) and the windowPtr are NIL.
|
||
;
|
||
LEA 16(SP),A0 ;point to window ptr var <23-Oct-85 EHB>
|
||
MOVE.L (A0)+,A1 ;get pointer to windowPtr
|
||
CLR.L (A1) ;make it NIL
|
||
MOVE.L (A0)+,D3 ;get the mouse point
|
||
CLR.W (A0) ;set classification code to zero
|
||
;
|
||
; first check to see if the point is on the menu bar. This routine is amended to call the
|
||
; menuBar defproc on nuMac or Aladdin. It returns - for not in menubar,
|
||
; 0 for in menubar, but not in title, or + for in menu Title.
|
||
;
|
||
|
||
MBarHitMsg EQU 1 ; temporary equate <C424/18Nov86> DAF
|
||
|
||
MOVEQ #MBarHitMsg,D0 ; put hit message in D0 <C424/18Nov86> DAF
|
||
MOVE.L D3,D1 ; send point as parameter <C424/18Nov86> DAF
|
||
JSR CallMBarProc ; call menuBar defproc <C424/18Nov86> DAF
|
||
TST.L D0 ; test the result <C424/18Nov86> DAF
|
||
BMI.S NotOnMBar ; if +, then not on bar <C424/18Nov86> DAF
|
||
|
||
;
|
||
MOVEQ #inMenuBar,D0 ;return "inMenuBar" classification code
|
||
BRA.S GoDoneFW ;all done with findWindow
|
||
;
|
||
; scan through the windowList starting at the front to see which window the point is in.
|
||
;
|
||
|
||
NotOnMBar
|
||
MOVE.L WindowList,A3 ;alertWindow is the frontmost window
|
||
;
|
||
; here is the loop where we hit-test the point against all visible windows
|
||
;
|
||
FWLoop
|
||
MOVE.L A3,D0 ;is it NIL (the end of the list)?
|
||
BEQ.S DoneFW1 ;if so, we're done (its inDesk) <27oct85> BBM
|
||
;
|
||
TST.B WVisible(A3) ;is this window visible?
|
||
BEQ.S NextFW ;if not, don't test it
|
||
;
|
||
; first check to see if its in the structure region of the window
|
||
;
|
||
CLR.W -(SP) ;make room for function result
|
||
MOVE.L D3,-(SP) ;push the point
|
||
MOVE.L STRUCTRGN(A3),-(SP) ;push the structure region
|
||
_PtInRgn ;is the point in the structure region?
|
||
TST.B (SP)+ ;examine result
|
||
BEQ.S NextFW ;if its not, go examine next one
|
||
;
|
||
; its in the window somewhere so call the window definition procedure to classify it
|
||
;
|
||
MOVEQ #WHitMsg,D0 ;its a hit-test message
|
||
BSR CallWindow ;ask the window about it
|
||
TST.W D0 ;D0 has the result
|
||
BNE.S FoundWindow ;if its non-zero, we've found it!
|
||
;
|
||
; it isn't the current window so keep looking until we run off the end of the window list
|
||
;
|
||
|
||
NextFW
|
||
MOVE.L NextWindow(A3),A3 ;get the next window in the list
|
||
BRA.S FWLoop ;loop till we find one
|
||
;
|
||
; at this point we've found the window the point is in. Update the result and
|
||
; return to the caller.
|
||
;
|
||
|
||
FoundWindow
|
||
MOVE.L 16(SP),A0 ;get pointer to window result <23-Oct-85 EHB>
|
||
MOVE.L A3,(A0) ;update window result
|
||
;
|
||
; check for if its a system window (The kind is < 0)
|
||
;
|
||
TST WindowKind(A3) ;check out the kind parameter
|
||
BPL.S GoChkDrag ;if not a system(<0), skip
|
||
MOVEQ #inSysWindow,D0 ;return "inSystemWindow"
|
||
GoDoneFW
|
||
BRA.S DoneFWindow ;we're done
|
||
|
||
;
|
||
; if its in the drag area or grow area of the window, no further classification needed
|
||
;
|
||
|
||
GoChkDrag CMP #wInDrag,D0 ;is it in the content area?
|
||
BLT.S ItsInContent ;if its in content, return that
|
||
BGT.S itsInGrow ;if greater, its in grow area
|
||
MOVEQ #inDrag,D0 ;return "inDragArea"
|
||
BRA.S DoneFWindow ;we're done
|
||
|
||
itsInGrow ADDQ #2,D0 ;return "inGrowArea" or "inGoAway"
|
||
BRA.S DoneFWindow
|
||
;
|
||
; its in the content area of a user window so waltz through the controlList to see
|
||
; if its in any of the controls. First get into the window's port and convert
|
||
; the mouse point into local coordinates
|
||
;
|
||
|
||
ItsInContent
|
||
MOVEQ #inContent,D0
|
||
DoneFWindow
|
||
MOVE D0,24(SP) ;update classification code result <23-Oct-85 EHB>
|
||
MOVEM.L (SP)+,D1/D3/A3 ;restore work registers <23-Oct-85 EHB>
|
||
BRA TwoParmExit ;standard exit saves code
|
||
|
||
;
|
||
; its in the desk, so if someones in the deskHook, return "inSysWindow"
|
||
;
|
||
|
||
DoneFW1
|
||
MOVE.L DeskHook,D0 ;is someone installed in deskHook?
|
||
BEQ.S DoneFWindow ;if not, return "inDesk"
|
||
MOVEQ #inSysWindow,D0 ;return "inSysWindow
|
||
BRA.S DoneFWindow ;all done
|
||
EndProc
|
||
|
||
;
|
||
; PROCEDURE DrawGrowIcon(theWindow: WindowPtr);
|
||
;
|
||
; DrawGrowIcon draws the grow icon in the window by asking the defProc to
|
||
; do it.
|
||
;
|
||
|
||
DrawGrowIcon Proc Export
|
||
Import SetWPort
|
||
Import CallWindow
|
||
Import RestorePort
|
||
|
||
MOVEM.L A3/D4,-(SP) ;save work registers
|
||
MOVE.L 12(SP),A3 ;get the window ptr
|
||
BSR SetWPort ;get in the window manager port
|
||
|
||
MOVEQ #WGIconMsg,D0 ;get message ID
|
||
BSR CallWindow ;invoke the defProc
|
||
|
||
BSR RestorePort ;restore user's grafPort
|
||
|
||
MOVEM.L (SP)+,A3/D4 ;restore work registers
|
||
MOVE.L (SP)+,(SP) ;strip parameter
|
||
RTS ;return to caller
|
||
EndProc
|
||
|
||
;
|
||
; procedure SetDeskCPat (newDeskPat : PixPatHandle);
|
||
;
|
||
; SetDeskCPat sets the low-memory location DeskCPat to point at the supplied pixPat,
|
||
; then causes a redraw of the desktop. This change to the desktop cPat does not
|
||
; cross application boundaries, but DeskPatDisable does.
|
||
; Stack Fixed <C835/20Feb87> DAF
|
||
;
|
||
|
||
SetDeskCPat Proc Export
|
||
|
||
TST.L 4(SP) ; is the newPat NIL? <1.2>
|
||
BEQ.S @TurnOff ; yes, so switch back to binary <C666/22Jan87> DAF
|
||
MOVE.L DeskCPat,D0 ; get the current deskCPat <1.2>
|
||
BEQ.S @1 ; if NIL, then continue <1.2>
|
||
CMP.L MinusOne,D0 ; continue if uninitialized, too <1.2>
|
||
BEQ.S @1 ; <1.2>
|
||
|
||
MOVE.L D0,-(SP) ; push old desk pix pat <1.2>
|
||
_DisposPixPat ; flush the old one <1.2>
|
||
|
||
@1 MOVE.L 4(SP),DeskCPat ; set it <1.2>
|
||
|
||
BSET #7,pCDeskPat ; if you called this you must want the pixPat <C666/22Jan87> DAF
|
||
@DrawIt
|
||
CLR.L -(SP) ; push a NIL pointer for DrawIt, make space for TurnOff <C835/20Feb87> DAF <C841>
|
||
MOVE.L grayRgn,-(SP) ; gray rgn is clobbered <C491/08Dec86> DAF
|
||
|
||
; No need to recalculate regions since we aren't moving any windows.
|
||
move.l ExpandMem,a0
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; set the one-shot to keep from recalcing ancestor rgns
|
||
_PaintOne ; redraw the desktop
|
||
MOVE.L (SP)+,A0 ; get the return address
|
||
ADDQ #4,SP ; flush the parameter
|
||
JMP (A0) ; and return
|
||
|
||
@TurnOff
|
||
SUBQ #4,SP ; make room for GetPattern result <C841/21Feb87> DAF
|
||
MOVE #deskPatID,-(SP) ; push pattern ID of deskPattern <C666/22Jan87> DAF
|
||
_GetPattern ; tell resource manager to get it <C666/22Jan87> DAF
|
||
MOVE.L (SP)+,A0 ; get the pattern handle <C666/22Jan87> DAF
|
||
MOVE.L (A0),A0 ; get pattern pointer <C666/22Jan87> DAF
|
||
MOVE.L (A0)+,DeskPattern ; init the deskPattern <C666/22Jan87> DAF
|
||
MOVE.L (A0),DeskPattern+4 ; don't forget 2nd half of it <C666/22Jan87> DAF
|
||
BCLR #7,pCDeskPat ; disable the cPat <C666/22Jan87> DAF
|
||
BRA.S @DrawIt ; redraw the desktop <C666/22Jan87> DAF
|
||
EndProc
|
||
|
||
;
|
||
; procedure SetWinColor ( theWindow:windowPtr; newColorTable:CTabHandle );
|
||
;
|
||
; This procedure changes the awCTable field of the theWindow's auxWinRec.
|
||
; If newColorTable is equal to the default record's CTabHandle, then
|
||
; the auxWinRec is deallocated. If this window does not have an
|
||
; auxWinRec, then one is allocated at the head of the list. If theWindow
|
||
; is NIL, then the default colors are changed. If a record gets deallocated,
|
||
; it's colorTable is disposed unless it has it's resource bit set (then the
|
||
; app must take responsibility)
|
||
;
|
||
; Most of this code is shared with the control manager. Since the auxRec
|
||
; offsets are the same for both types of auxrecs, the code should be OK,
|
||
; even though the code uses the auxWinRec names.
|
||
;
|
||
|
||
SetWinColor Proc Export
|
||
Export SetCtlColor
|
||
Import GetAuxGuts
|
||
IMPORT GetRearWindow
|
||
|
||
MOVEM.L A2/A3,-(SP) ;get some address registers
|
||
MOVE.L AuxWinHead,A2 ;get the list head
|
||
LEA AuxWinHead,A3 ;in case we need to deallocate
|
||
BSR SetGuts ;bsr so that we can redraw on return <C491/08Dec86> DAF
|
||
MOVE.L 16(SP),D0 ;get windowPtr <C687/24Jan87> DAF
|
||
BNE.S GotWindow ; <SM16> FM Was the window NIL?
|
||
|
||
; <SM16> The RedrawAll code is used by SetCtlColor/SetWinColor for the case when the
|
||
; <SM16> caller passes NIL as a control/window to indicate that they want to replace the
|
||
; <SM16> default color table.
|
||
|
||
move.l ExpandMem,a0 ; <SM16>
|
||
st ExpandMemRec.ancestorRgnsCalced(a0) ; <SM16> set the one-shot to keep from recalcing ancestor rgns
|
||
|
||
RedrawAll bsr GetRearWindow ; <SM16> Returns rearmost window in A1
|
||
move.l a1,-(sp) ; <SM16> Paint from the rearmost window on up
|
||
move.l GrayRgn,-(sp) ; <SM16> Use the entire desktop as the clobbered region
|
||
_PaintOne ; <SM16> Draw all the windows
|
||
BRA SetEnd
|
||
|
||
GotWindow MOVE.L D0,A2 ; Put the window in A2
|
||
TST.B portVersion(A2) ; is it a new window? <SM16> <1.5/23Jul89 DAF>
|
||
|
||
BPL.S @1 ; don't set bkColor in old windows <1.5/23Jul89 DAF>
|
||
SUBQ #4,SP ; make a placeholder for the current port <C687/24Jan87> DAF
|
||
PEA (SP) ; push pointer to placeholder <C687/24Jan87> DAF
|
||
_GetPort ; get thePort <C687/24Jan87> DAF
|
||
MOVE.L A2,-(SP) ; make this port the current port <C687/24Jan87> DAF
|
||
_SetPort ; set it <C687/24Jan87> DAF
|
||
|
||
MOVE.L 16(SP),A0 ; copy cTabHandle to A-reg <C687/24Jan87> DAF
|
||
MOVE.L (A0),A0 ; get cTabPtr <C687/24Jan87> DAF
|
||
|
||
MOVE.W CTSize(A0),D1 ; get the color table size <C687/24Jan87> DAF
|
||
MULU #CTEntrySize,D1 ; convert to color table index <C687/24Jan87> DAF
|
||
@LegalIndex
|
||
CMP.W #wContentColor,CTTable+value(A0,D1) ; is this the one? <C687/24Jan87> DAF
|
||
BEQ.S @FoundIt ; if equal, then done <C687/24Jan87> DAF
|
||
SUB.W #CTEntrySize,D1 ; try the previous one <C687/24Jan87> DAF
|
||
BGE.S @LegalIndex ; loop while index positive <C687/24Jan87> DAF
|
||
MOVEQ #0,D1 ; OK, use the first one <C687/24Jan87> DAF
|
||
@FoundIt
|
||
PEA CTTable+rgb(A0,D1) ; push the address of the color to use <C687/24Jan87> DAF
|
||
_RGBBackColor ; set the background color <C687/24Jan87> DAF
|
||
_SetPort ; restore thePort <C687/24Jan87> DAF
|
||
@1
|
||
TST.B wVisible(A2) ;if not visible, all done <C687/24Jan87> DAF
|
||
BEQ.S SetEnd ;
|
||
MOVE.L A2,-(SP) ;push windowPtr <C687/24Jan87> DAF
|
||
MOVE.L StructRgn(A2),-(SP) ;push structure rgn as clobbered <C687/24Jan87> DAF
|
||
_PaintOne ;redraw it <C491/08Dec86> DAF
|
||
BRA.S SetEnd ; <C491/08Dec86> DAF
|
||
|
||
SetCtlColor
|
||
MOVEM.L A2/A3,-(SP) ;get some address registers
|
||
MOVE.L AuxCtlHead,A2 ;get the list head
|
||
LEA AuxCtlHead,A3 ;in case we need to deallocate
|
||
BSR.S SetGuts ; <C491/08Dec86> DAF
|
||
MOVE.L 16(SP),D0 ;<SM16> FM get the control handle <C491/08Dec86> DAF
|
||
|
||
;<SM16>FM A NIL control handle means the caller wants to replace the default color table
|
||
;<SM16>FM We did that in SetGuts so now we should refresh all of the windows…
|
||
BEQ RedrawAll ;<SM16> FM Go refresh all the windows
|
||
|
||
|
||
MOVE.L D0,A0 ;<SM16> FM Get the control handle in A0
|
||
MOVE.L (A0),A1 ;get the control pointer <C491/08Dec86> DAF
|
||
TST.B contrlVis(A1) ;is it visible? <C491/08Dec86> DAF
|
||
BEQ.S SetEnd ;nope, so we're done <C491/08Dec86> DAF
|
||
MOVE.L A0,-(SP) ;push control handle <C491/08Dec86> DAF
|
||
_Draw1Control ;redraw it <C616/12Jan87> DAF
|
||
SetEnd
|
||
MOVEM.L (SP)+,A2/A3 ;restore the saved registers
|
||
MOVE.L (SP)+,A0 ;get the return address
|
||
ADDQ #8,SP ;flush the parameters
|
||
JMP (A0) ;and go home
|
||
|
||
SetGuts
|
||
|
||
tWind EQU $18 ;some equates for parameters
|
||
nCTab EQU $14 ; after LINK (don't forget the movem above!)
|
||
|
||
LINK A6,#0 ;no globals
|
||
CLR.L -(SP) ;return AuxWinHandle here
|
||
CLR.W -(SP) ;function return here
|
||
CLR.L -(SP) ;NIL for default
|
||
PEA 6(SP) ;pointer to the placeholder
|
||
MOVE.L A2,A1 ;set up list head for GetAuxGuts
|
||
BSR GetAuxGuts ;get the default record
|
||
ADDQ #2,SP ;ignore boolean result
|
||
MOVE.L (SP)+,A0 ;get the default handle
|
||
MOVE.L (A0),A0 ;get a pointer
|
||
MOVE.L awCTable(A0),A0 ;get the cTabHandle <1.5>
|
||
CMP.L nCTab(A6),A0 ;if the same then deallocate <1.5>
|
||
BEQ DeAlAux ;
|
||
CMP.L #-1,nCTab(A6) ;if -1, then allocate a rec with default table <C591/04Jan87><C767> DAF<C767>
|
||
BEQ.S SpecAlloc ; <C591/04Jan87><C767> DAF
|
||
MOVE.L A0,-(SP) ;save a reg (yuck, but registers are tight!) <C687/24Jan87><C767> DAF
|
||
MOVE.L nCTab(A6),A0 ;get the new color table handle <C687/24Jan87><C767> DAF
|
||
MOVE.L (A0),A0 ;get a pointer <C687/24Jan87><C767> DAF
|
||
CMP.W #-1,ctSize(A0) ;is ctSize -1? <C687/24Jan87><C767> DAF
|
||
MOVE.L (SP)+,A0 ;get the register back (don't change flags) <C687/24Jan87><C767> DAF
|
||
BEQ.S SpecAlloc32 ;If so, alloc a rec with default table <1.5 DAF>
|
||
CLR.L -(SP) ;temp for returned handle
|
||
CLR.W -(SP) ;for function return
|
||
MOVE.L tWind(A6),-(SP) ;here's the ID field
|
||
PEA 6(SP) ;pointer to handle placeholder
|
||
MOVE.L A2,A1 ;set up list head (again!)
|
||
BSR GetAuxGuts ;get this record
|
||
MOVE.B (SP)+,D0 ;get the result (set flags)
|
||
MOVEA.L (SP)+,A0 ;get the auxrec handle too
|
||
BEQ.S AllocAux ;if result FALSE, then allocate a new one
|
||
|
||
MOVE.L (A0),A0 ;dereference the handle
|
||
MOVE.L nCTab(A6),awCTable(A0) ;and set the field <1.5>
|
||
SWCDone
|
||
UNLK A6
|
||
RTS
|
||
|
||
; if this routine is called in 24-bit mode, then it falls through to SpecAlloc and makes
|
||
; a new auxWinRec with a copy of the default colortable. If it is called in 32-bit
|
||
; mode, then it finds the window's pre-existing auxWinRec (one is always guaranteed to
|
||
; exist) and sets it's colortable to be a copy of the default colortable handle.
|
||
|
||
SpecAlloc32
|
||
TST.B MMU32Bit ; are we in 32-bit mode? <1.5/DAF>
|
||
BEQ.S SpecAlloc ; no, so allocate a new record with a copy of the default colors <1.5/DAF>
|
||
MOVE.L A0,nCTab(A6) ; stick the default colors in the stack frame <1.5/DAF>
|
||
CLR.L -(SP) ; return AuxWinHandle here <1.5 DAF>
|
||
CLR.W -(SP) ; leave room for return value here <1.5/DAF>
|
||
MOVE.L tWind(A6),-(SP) ; find this window <1.5 DAF>
|
||
PEA 6(SP) ; point to placeholder <1.5 DAF>
|
||
MOVE.L A2,A1 ; set up list head for GetAuxGuts (windows or controls) <1.5 DAF>
|
||
BSR GetAuxGuts ; get it (it will always be here in 32-bit mode) <1.5 DAF>
|
||
ADDQ #2,SP ; the result should have always returned true <1.5/DAF>
|
||
MOVE.L (SP)+,A0 ; get the win/ctl rec handle <1.5 DAF>
|
||
MOVE.L (A0),A0 ; get a pointer <1.5 DAF>
|
||
MOVE.L nCTab(A6),awCTable(A0) ;and set the default colortable (in nCTab) field <1.5 DAF>
|
||
BRA.S SWCDone ; <1.5 DAF>
|
||
|
||
; this routine is a little unsavory- it sticks the default cTabHandle (in A0) in the
|
||
; stack frame, then falls through to AllocAux. This routine ALWAYS makes a new
|
||
; auxWinRec whose color table is the same as the default.
|
||
|
||
SpecAlloc
|
||
MOVE.L A0,nCTab(A6) ; stick the default colors in the stack frame <1.5/DAF>
|
||
|
||
; this utility allocates an auxRec at the beginning of the AuxWinList
|
||
; remember that A2=(AuxListHead), A3=AuxListHead
|
||
AllocAux
|
||
MOVE.L #AuxWinSize,D0 ;set up for newHandle
|
||
_NewHandle ,clear ;allocate a new record
|
||
MOVE.L A0,(A3) ;put the new element at the head of the list
|
||
MOVE.L (A0),A0 ;dereference the new element
|
||
MOVE.L A2,awNext(A0) ;reconnect the list <1.5>
|
||
MOVE.L nCTab(A6),awCTable(A0) ;attach the color table <1.5>
|
||
MOVE.L tWind(A6),D0 ; get this in a reg <1.4/DAF>
|
||
_StripAddress ;
|
||
@1
|
||
MOVE.L D0,awOwner(A0) ; put in the ID field <1.5/DAF>
|
||
BRA.S SWCDone
|
||
|
||
; this utility deallocates an auxRec and its colortable. Note that the offset to awNext
|
||
; is zero, so that the first dereference will work.
|
||
|
||
DeAlAux
|
||
MOVE.L A0,A2 ;save the default CTabH in A2 <C591/04Jan87> DAF
|
||
MOVE.L A3,A1 ;prime the pointers
|
||
@1
|
||
MOVE.L awNext(A1),D1 ;get handle to next <1.5>
|
||
MOVE.L D1,A0 ;get copy of handle (doesn't change flags)
|
||
BEQ.S @4 ;never delete the default record <C407/16Nov86> DAF
|
||
MOVE.L (A0),A0 ;dereference
|
||
MOVE.L awOwner(A0),D0 ;get owner ID <1.5>
|
||
CMP.L tWind(A6),D0 ;test for match
|
||
BEQ.S @2 ;eliminate when matched
|
||
MOVE.L A0,A1 ;copy current to previous
|
||
BRA.S @1
|
||
@2
|
||
MOVE.L awNext(A0),-(SP) ; save link if we need to remove <1.4/1.5>
|
||
MOVE.L awCTable(A0),A0 ;get handle to colortable <1.5>
|
||
_HGetState ;get handle tag byte <C491/08Dec86> DAF
|
||
BTST #resource,D0 ;is it a resource? Then don't dispose <C491/08Dec86> DAF
|
||
BNE.S @3 ;if it is, don't dispose <C612/11Jan87> DAF
|
||
_DisposHandle
|
||
@3
|
||
TST.B MMU32Bit ;are we running 32-bit? <C666/22Jan87> DAF
|
||
BEQ.S @10 ;no, so dispose the record <C591/04Jan87> DAF
|
||
MOVE.L D1,A0 ;move handle to an A-reg <C591/04Jan87> DAF
|
||
MOVE.L (A0),A0 ;dereference it <C591/04Jan87> DAF
|
||
MOVE.L A2,awCTable(A0) ;put it in the auxRec <1.5>
|
||
ADDA #4,SP ;we won't link around this record <1.4>
|
||
BRA.S @4 ;and continue
|
||
@10
|
||
MOVE.L D1,A0 ;get handle to auxRec
|
||
_DisposHandle
|
||
MOVE.L (SP)+,awNext(A1) ; remove the disposed record from the list <1.4/1.5>
|
||
@4
|
||
BRA SWCDone
|
||
EndProc
|
||
|
||
|
||
;
|
||
; function GetAuxWin (theWindow:windowPtr; var AWHndl:AuxWinHandle) : boolean;
|
||
;
|
||
; GetAuxWin finds the handle to the appropriate auxWinRec for the
|
||
; windowRec pointed to by theWindow. If theWindow is NIL, the handle to
|
||
; the default record is returned. The boolean returns TRUE if a unique
|
||
; AuxWinHandle for that windowPtr is found, FALSE if the default record
|
||
; handle is returned. {and TRUE if theWindow was NIL, but should I change that?}
|
||
;
|
||
;
|
||
|
||
GetAuxWin Proc Export
|
||
Export GetAuxCtl
|
||
Export GetAuxGuts
|
||
|
||
MOVE.L AuxWinHead,A1 ;get the list head
|
||
BRA.S GetAuxGuts
|
||
GetAuxCtl
|
||
MOVE.L AuxCtlHead,A1
|
||
GetAuxGuts
|
||
MOVE.B #1,12(SP) ;set the boolean to TRUE
|
||
MOVE.L 8(SP),D0 ;get the ID field
|
||
_StripAddress ; make it 32-bit OK
|
||
@1
|
||
MOVE.L (A1),A0 ;dereference to ptr
|
||
CMP.L awOwner(A0),D0 ;do they match? <1.5>
|
||
BEQ.S @3
|
||
MOVE.L A1,D2 ;save this handle (if returning default)
|
||
MOVE.L awNext(A0),D1 ;move down the chain (set flags) <1.5>
|
||
MOVE.L D1,A1 ;copy to address register
|
||
BNE.S @1 ;if next = NIL, then at the end
|
||
TST.L D0 ;was it a default request?
|
||
BEQ.S @3 ;if so, then handle is OK
|
||
MOVE.B #0,12(SP) ;set the boolean to FALSE
|
||
MOVE.L D2,A1 ;and put this handle back
|
||
@3
|
||
MOVE.L 4(SP),A0 ;get a pointer to var result
|
||
MOVE.L A1,(A0) ;save the result
|
||
|
||
; <SM16> The routines that need to get at a window’s color table generally call GetAuxWin first to
|
||
; <SM16> get the color table handle. That makes this a good place to reload the color table if it’s
|
||
; <SM16> been purged.
|
||
|
||
move.l (A1), A0 ; <SM16> FM Aux[Win|Ctl]Ptr in A0
|
||
move.l awCTable(A0), A0 ; <SM16> FM Color table handle (resource handle) in A0
|
||
tst.l (A0) ; <SM16> FM is the master pointer NIL?
|
||
bnz.s @exit ; <SM16> FM if so then we should reload the table
|
||
move.l A0, -(SP) ; <SM16> FM push the resource handle
|
||
_LoadResource ; <SM16> FM try to get it back in memory
|
||
|
||
@exit MOVE.L (SP)+,A0 ;get the return address
|
||
ADDQ #8,SP ;flush the parameters
|
||
JMP (A0) ;and go home
|
||
EndProc
|
||
END
|
||
|