mac-rom/Toolbox/MenuMgr/StandardMBDF.a
Elliot Nunn 4325cdcc78 Bring in CubeE sources
Resource forks are included only for .rsrc files. These are DeRezzed into their data fork. 'ckid' resources, from the Projector VCS, are not included.

The Tools directory, containing mostly junk, is also excluded.
2017-12-26 09:52:23 +08:00

3124 lines
119 KiB
Plaintext

;
; File: StandardMBDF.a
;
; Contains: menu bar definition procedure
;
; Written by: David Fung
;
; Copyright: © 1986-1992 by Apple Computer, Inc., all rights reserved.
;
;
; Change History (most recent first):
;
; <SM3> 10/22/92 CSS Change some branch short instructions to word branches.
; <49> 4/30/92 DTY #1027995 <KSM>: SetTitleColor expects a4 to point to a MenuInfo
; record on entry. The BannerMsg routine calls SetTitleColor
; without setting up a4. This kinda makes sense, since the menu
; bar doesnÕt have a MenuInfo record. However, if A4 contains
; trash, an error will occur. Make a4 nil in BannerMsg, and have
; SetTitleColor check to see if A4 contains nil. If it is, jump
; directly to @TryMenuBar.
; <48> 4/4/92 KSM #1019367,<DTY>: Allow for slop factor before dropping System
; menus when app menus are too long.
; <47> 10/28/91 SAM/KSM Rolled in Regatta file.
;
; Regatta Change History:
;
; <3> 8/8/91 SAM Adding HardwarePrivateEqu.a
; <2> 5/28/91 SAM Removed Gestalt check for Square menu bar cuz this code gets called
; so frquently. Replaced it with a slightly less cool lomem check.
; <1> 8/8/91 SAM Split off from 7.0 GM sources.
;
; 7.0 Change History:
;
; <46> 6/11/91 gbm Take out conditional for Regatta... we want that to be
; "standard" now
; <45> 4/3/91 SAM Added GestaltEqu.a to the list of includes (for the Regatta
; build).
; <44> 4/2/91 SAM Changed the "If we have a Portable ROM then dont round the menu
; bar corners" check to ask Gestalt if there should be square menu
; bars (for the Regatta build).
; <43> 4/2/91 VL KSM,#86088: Fixed the problem of a crash drawing an icon to the
; Application Menu when the Application Menu is not in the
; MenuList. This is done by adding another exit condition to the
; loop finding the Application Menu.
; <42> 3/21/91 KSM dty,#84128: If DrawMenuBar is called with a hilited title, it
; will only restore the bits of the hilited menu.
; <41> 3/19/91 KSM ngk,#83253: BUT Gifford showed why letting the TITLE bits be
; purgable was not too swift.
; <40> 3/13/91 KSM ddc,#83253: Call SaveRestoreBits with purgable bits option (why
; didnÕt we do this before?)
; <39> 3/4/91 dba dty: get rid of SysVers conditionals
; <38> 2/22/91 VL KSM, #82413: ClipToTempRect didn't respect MBarHeight and that
; caused icons to be drawn even when the MBar is not visible (i.e.
; MBarHeight = 0). Fixed ClipToTempRect to use the minimum of
; MBarHeight and actual height of TempRect.
; <37> 1/21/91 DFH (KSM) Process Menu is now called Application Menu.
; <36> 1/7/91 JDR (dba) Changing the includes of Icons.a to IconUtilsPriv.a.
; <35> 11/13/90 KSM <dcc>Remove some deadwood (redundant compare).
; <34> 9/23/90 KSM <smb>Fix a hit testing bug when no system menus are installed.
; <33> 9/19/90 KSM Fix MBDF to not call PenMode (supposed to call TextMode).
; <32> 9/15/90 KSM Better plotting of color apple menu icon.
; <31> 9/11/90 KSM Fix to BannerMsg- calls HiliteMenu(0) before drawing the menubar
; string to prevent the flash of dehiliting the menu later.
; <30> 9/6/90 KSM Change CALC (#2) message to add system menus iff there is an
; apple menu. Fix up some TO DO's to be current.
; <29> 8/17/90 dvb grayishTextCopy->grayishTextOr
; <28> 8/14/90 KSM Oops, fix the previous fix.
; <27> 8/10/90 PN Fix graying for non-color machines since drawstring on these
; machines does not recognize _PenPat(grayishtext).
; <26> 8/9/90 DC changed apple menu to use Icon Suite in stead of cicn. Fixed up
; color handling of icons again.
; <25> 8/6/90 DC fixed color environment arount ploticonsuite to allow for menu
; colorizers (Kolor, et al.)
; <24> 7/26/90 KSM fix hierarchical menu title hiliting bug by ignoring the
; parameter when told to unhilite a menu title
; <23> 7/20/90 DVB Fix for classic machines...
; <22> 7/17/90 DVB Add grayish items
; <21> 7/16/90 VL Added new messages (MoveICSToAM, MoveSICNToPM and MoveICSToPM)
; for Notification Mgr. MoveSIcon is renamed to MoveSICNToAM.
; <20> 6/8/90 dba use Begin/EndDrawingOffscreen
; <19> 6/8/90 dba create code for buffering redraws of the whole menu bar to avoid
; flicker; made many branches short ones
; <18> 6/5/90 KSM FIx bug in drawing menu items when 2 (or more) system menus are
; not draw because the app menus have encroached upon it (A11
; fix).
; <17> 5/31/90 KSM Bug fix in HitBar-high word of D4 not cleared. Tweek system
; menus left 1 pixel for rt just. Also fixed A10 bugs MF(A6).
; Fixed IconUtils to be Icons.a
; <16> 5/31/90 KSM Bug fix in HitBar-high word of D4 not cleared. Tweek system
; menus left 1 pixel for rt just. Also fixed A10 bugs MF(A6).
; Fixed IconUtils to be Icons.a
; <15> 5/22/90 DC Changed name of PlotBestIcon to PlotIconSuite
; <14> 5/9/90 KSM New message (#15): BannerMsg (for Finder).
; <13> 5/9/90 KSM New message (#14) added: GetTitleRect.
; <12> 5/7/90 KSM Rect for system menus are now aligned with right side of title
; hilite.
; <11> 4/30/90 KSM Handle all the nasty issues when the app menus begin to encroach
; on system menus.
; <10> 4/29/90 KSM Changed the routine dispatch table to use the stack frame macros
; (since I'm about to add new calls). Forced drawing apple in B&W
; when monitor is in multi-bit B&W mode to avoid the ugly, striped
; apple. Cleaned up rectangle calcs for hilighting titles. Apple
; menu and Application Menu are now perfectly symmetrical.
; <9> 4/24/90 dba fix error I made in previous change (move addq.w inside the
; conditional)
; <8> 4/21/90 dba I is a idiot; it instead of if
; <7> 4/20/90 dba get rid of the two special anti-aliased color icons for apple on
; black and apple on white
; <6> 4/20/90 KSM Fix bug munging locked menulist handle. Use new interface to
; SaveRestoreBits calls.
; <5> 4/13/90 DFH Fixed DrawCommon to properly transform iconic title
; when hilighted.
; <4> 4/11/90 KSM Update calls to _GetAuxMenuItem to include itemnum param and add
; support for color icons.
; <3> 4/10/90 dba use SaveBits and RestoreBits; use fancy color Apple icons;
; include KevinÕs changes to support system menus; added support
; for icon menu titles; put in stupid kludge to make things work
; on the Mac II
; <2> 1/31/90 RLC Update HelpMgr calls and conditionally build in macros.
; <2.2> 9/26/89 CCH Added conditionals around references to SysVers equate for ROM.
; Minor fixes to changes from version 2.1 (hierarchical menu
; placement).
; <2.1> 9/25/89 DFH Added ExpandItem to get extra menu item information.
; <2.0> 8/29/89 RLC Changed calling structure to the HelpMgr (_Pack14).
; <1.9> 8/22/89 SES Removed references to nFiles.
; <1.8> 8/12/89 dba NEEDED FOR 6.0.4: reintroduced a bug fix lost in the transition
; from 6.0.3 sources; fixes problems with hierarchical menus above
; the menu bar
; <1.7> 8/10/89 RLC Changed selector message to Help Mgr Pack to MOVEQ #select,D0
; <1.6> 6/2/89 KSM Updated conditionals for ROM/SYS build AGAIN.
; <1.5> 6/2/89 KSM Updated conditionals for ROM/SYS build.
; <1.4> 6/1/89 KSM BALLOON HELP support added.
; <1.3> 3/1/89 MSH Dave F provided the first pass at external video support
; (Topanga) and I tweaked it until it worked.
; <1.4> 2/10/89 DAF Modified MBDF for Harpo. This includes a number of
; modifications: 1) onLCDMac stack variable created to identify
; Harpo. 2) Rounded corner framing draws white or black depending
; on video mode iff on Harpo 3) Menubar is framed if on Harpo
; internal display, is one pixel taller, and titles start one
; pixel in.
; <1.2> 2/9/89 EMT Courtesy Walter Smith, fixed bug in GetMenuAscent.
; <1.1> 11/11/88 CCH Fixed Header.
; <1.0> 11/9/88 CCH Adding to EASE.
; <¥1.2> 9/23/88 CCH Got rid of inc.sum.d and empty nFiles
; <¥1.1> 3/22/88 EMT Roll in menu manager patches from 6.0 system.
; <S423> 3/9/88 EMT Fix empty menu bug
; PMAB364> 1/23/88 EMT Fix Pop-up menus to come up on any screen
; <S358> 1/12/88 EMT Fix orphaned handles in MBDF
; <S334> 12/15/87 EMT Remove call to PurgeSpace in MBDF
; <S321> 12/3/87 EMT MBDF now uses MultiFinder temporary memory allocation.
; <S297> 10/20/87 EMT Change FullClip to use QD wideOpen region. Modify Draw message
; to include single title draw. Added MoveSIcon message for
; Notification Manager. Miscellaneous optimizations.
;
; System 4.2
;
; 7/20/87 FJL MoveQ #0,D0 in several places to ensure parameter to _NewHandle
; is ok.
; 3/26/87 FJL Save and restore pen state for the application Tempo.
; 3/6/87 FJL Clean up all OnNuMac conditionals for System Disk --> Universal
; defproc
; 2/10/87 FJL C784 Leave TextMode srcOr, fixes BusFileVision
; 11/18/86 FJL A428 Lock handle for non-nuMac in SaveDemBits. Change
; DrawMenuBar so draws selected item after all titles are drawn,
; rather than in loop.
; 11/15/86 FJL C408 Added support for color menus
; 11/5/86 FJL CXXX General clean up and documentation.
; 10/27/86 FJL A278 Force menu font to be system font at all times. Hacked up
; HiliteMenu so it inverts/inverts on menu select/unselect for
; Alladin. (removed during clean up)
; 10/8/86 FJL C175 Expanded stackframe. Lock and unlock MenuList handle.
; Utility GetAscent. Fixed DrawMenu loop, and HiliteBar. Added
; 4-bit color apple. Utility CheckForApple. Fixed SaveBits
; problem. Fixed incorrect rect size in MakeUpdate.
; 9/15/86 DAF New today
;
; FUNCTION MenuBarProc ( selector: INTEGER;
; message: INTEGER;
; parameter1: INTEGER;
; parameter2: LONGINT): LONGINT
;
; Msg Selector Param1 Param2 Result
;--------- -------------- -------------- -------------- -------------
; 0 Draw mbVariant none -1 = clear none
; 0 = all none
; <pos> = 6 B.O. none
; 1 Hit mbVariant none mouse point 0 = in bar, no hit
; -1= not in bar
; <pos> = 6 B.O.
; 2 Calc mbVariant none 0 = all none
; <pos> = 6 B.O. none
; 3 Init mbVariant none size none
; 4 Dispos mbVariant none none none
; 5 Hilite mbVariant none <packed> none
; 6 Height mbVariant none none none
; 7 Save mbVariant 6 B.O. ptr to menuRect none
; 8 Restor mbVariant none none none
; 9 GetRect mbVariant none <packed2> ptr to menuRect
;10 SaveAlt mbVariant none 6 B.O. none
;11 ResetScroll mbVariant none 6 B.O. none
;12 GetMenuRgn mbVariant none region handle region handle
;13 MoveSICNToAM mbVariant distance sicon handle 0 = keep current icon
; 0=replace 0 = use title -1 = go to next icon
;14 GetTRect mbVariant <pos> = 6 B.O. ptr-to-menuRect none
; 0 = MenuBarRect
; -1 = Rect enclosing visible app menus
; -2 = Rect enclosing visible system menus
;15 BannerMsg mbVariant <special> ptr to pString none
; lo byte=scriptID
; hi byte=teJust for textbox
;16 MoveICSToPM mbVariant distance ics handle 0 = keep current icon
; 0=replace 0 = use title -1 = go to next icon
;17 MoveICSToAM mbVariant distance ics handle 0 = keep current icon
; 0=replace 0 = use title -1 = go to next icon
;18 MoveSICNToPM mbVariant distance SICN handle 0 = keep current icon
; 0=replace 0 = use title -1 = go to next icon
;
; NOTES: 6 B.O. == 6 byte offset into menuList
; <packed> == hiword -- 0=normal, 1=selected, 2=disabled, 3=busy,
; 128+=SICN rsrcID to be blitted
; loword -- 0=flip bar, positive value=6 byte offset
; <packed2> == hiword -- if =0 then is normal menu,
; else contains vertical mouse pt for HMenu top calc
; loword -- 6 B.O.
;
;ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
LOAD 'StandardEqu.d'
INCLUDE 'InternalMacros.a'
INCLUDE 'MFPrivate.a'
INCLUDE 'IconUtilsPriv.a'
INCLUDE 'MenuMgrPriv.a'
INCLUDE 'Balloons.a'
INCLUDE 'GestaltEqu.a'
INCLUDE 'HardwarePrivateEqu.a'
selectBeginDrawingOffscreen EQU 4
paramWordsBeginDrawingOffscreen EQU 4
MACRO
_BeginDrawingOffscreen
DoDispatch _SaveRestoreBits,selectBeginDrawingOffscreen,paramWordsBeginDrawingOffscreen
ENDM
selectEndDrawingOffscreen EQU 5
paramWordsEndDrawingOffscreen EQU 2
MACRO
_EndDrawingOffscreen
DoDispatch _SaveRestoreBits,selectEndDrawingOffscreen,paramWordsEndDrawingOffscreen
ENDM
if &type('useAntiAliasedApples') = 'UNDEFINED' then
useAntiAliasedApples: equ 0
endif
MACRO
_DMSG &msg
if &msg = '' then
_Debugger
else
BRA.S @overstring
@dbgStrBase:
DC.B &msg
ALIGN 2
@overstring:
PEA @dbgStrBase
_DebugStr
endif
ENDM
;--------------------------------------------------------------------------------------------
; value for itemIconSize (but not itemCmd) <2.1>
LargeIconCmd EQU $1F ; large icon plotted
; special values of the itemCmd field before expansion <2.1>
ShrunkenIconCmd EQU $1D ; itemCmd == $1D ==> large icon plotted in 16x16
SmallIconCmd EQU $1E ; itemCmd == $1E ==> small icon plotted
; resource IDs of color icons that look like the Apple logo
;rAppleOnWhite equ -16385 ; anti-aliased apple on a white background
;rAppleOnBlack equ -16386 ; anti-aliased apple on a black background
rAppleSuite equ -16386 ; I'm hijacking the assigned resource number of rAppleOnBlack <DCC 8/8/90>
rAppleWithMask equ 20 ; less attractive apple that works on any background
; Switches for drawing the icons
; bit 0 is for icon type and bit 1 is for menu type
SICNInAppleMenu equ $00
SICNInApplicationMenu equ $02
ICSInAppleMenu equ $01
ICSInApplicationMenu equ $03
;____________________________________________________________________________________________
;
; StackFrame and Global Definitions
;
;____________________________________________________________________________________________
MenuBarDefProc PROC EXPORT
MBDFRegSave REG D3-D6/A2-A4
mTitleSpace EQU 13 ; Space between menu titles in menu bar
; Stack Frame Definition for MBarProc
; FUNCTION MenuBarProc ( selector: INTEGER; message: INTEGER;
; parameter1: INTEGER; parameter2: LONGINT): LONGINT;
resultsStackFrame
Result DS.L 1
parametersStackFrame
Selector DS.W 1
Message DS.W 1
Param1 DS.W 1
Param2 DS.L 1
localsStackFrame
MenuRect DS.W 4
colorPortP DS.L 1
appleRect DS.W 4
applePixMapH DS.L 1
SelectFlag DS.W 1
TitleBackFlag DS.W 1
PixelDepth DS.W 1
theGDColorTbl DS.L 1
MenuDir DS.W 1
VMousePt DS.W 1
saveBackColor DS.W 3
saveForeColor DS.W 3
tempHandle DS.L 1
saveD3 DS.W 1
onLCDMac DS.B 1 ; if high bit is set, then internal Harpo display active<DAF 10Feb89><v1.4>
onColorMachine DS.B 1 ; <FJL 96Mar87>
; the following are for offscreen buffering of the menu in response to the draw message
menuBarBuffer ds.l 1 ; handle to the offscreen buffer
; The following defines are for GetItemHeight which was copied from MDEF (UGGHHLLYYYY!)
MFHeight DS.W 1
MWidMax DS.W 1
MDescent DS.W 1
MAscent DS.W 1
MInfoRec EQU MAscent ; <1Aug85>
; Extensions to a menu item <2.1>
itemScript DS.W 1 ; item text script code
itemIconGray DS.W 1 ; whether icon should be grayed
itemIconSize DS.W 1 ; full-sized/small/shrunken
itemIconHandle DS.L 1 ; handle to icon (or nil)
itemHierarchicalID DS.W 1 ; hierarchical menu ID
itemOrigAttrs DS.B 4 ; original attributes
itemStackBase EQU *
endStackFrame
; -------------------------------------------------------------------------------------
FirstMBMsg EQU 0
LastMBMsg EQU 18 ; <EMT S297>
;--------------------------------------------------------------------------------------------
;
; Start of Code -- save work registers and dispatch on message number.
;
; Set up: A2 -- WMgrPort
; A3 -- ptr to menu list
;
;--------------------------------------------------------------------------------------------
BRA.S StartMBDF
; Standard Header
MBDFFlags DC.W 0 ; flags word
DC.l ('MBDF') ; resource type
DC.W 0 ; resource ID
DC.W 13 ; version 0 = onNuMac ROM
; version 10 = Universal
; version 12 = Universal 6.0 <PMAB364 23Jan88 EMT>
; version 13 = System 7.0
StartMBDF
linksave MBDFRegSave
subq.l #4,sp ; make room for saved port on the stack
move.l sp,-(sp) ; Point to that result
_GetPort
clr onColorMachine(a6) ; clear color machine flag (and onLCDMac) <FJL 06Mar87> <DAF 10Feb89><v1.4>
cmpi.w #$3FFF, ROM85 ; color machine ?
sls onColorMachine(a6) ; set byte to 1s if yes
MOVE.W HwCfgFlags,D0 ; Get them Hardware Config Flags
BTST.L #hwCbPwrMgr,D0 ; Do we have a PowerMgr?
BEQ.S @100 ; -> Nope, assume rounded menu bar
TST.B NTSC ; is it on the internal display? <DAF 10Feb89>
BNE.S @100 ; nope, so skip this <DAF 10Feb89>
BSET #7,onLCDMac(A6) ; set high-bit to mark internal display <DAF 10Feb89>
@100
tst.b onColorMachine(a6)
beq.s @SetBWPort
move.l WMgrCPort,a2 ; get color port
bra.s @SetPort
@SetBWPort
MOVE.L WMgrPort,a2 ; get non-color port
@SetPort
MOVE.L A2,-(SP) ; set the WMgrPort
_SetPort
; start by setting the window manager font to the system font
clr.l -(sp) ; clear stack for next 2 calls <FJL A278>
_TextFont ; set font to system font <FJL A278>
_TextFace ; set style to plain <FJL A278>
MOVE.L MenuList,A0 ; get the menuList handle <FJL C175>
TST.L (A0) ; has it been purged? <FJL C175>
BNE.S @menuListOK ; => yes, go to purgeatory
MOVEQ #MenuPrgErr,D0 ; get our error code
_SysError ; and roast in eternal damnation
@menuListOK ; lock the MenuList so a3 ptr doesn't move <FJL C175>
_HLock ; lots of alloc'ing in color apple routines <FJL C175>
MOVE.L (A0),A3 ; and get the pointer
LEA GoBarProc,A0 ; get the dispatch table base
MOVE.W message(A6),D0 ; get the message number
cmpi #LastMBMsg, d0 ; is the message within bounds?
bhi.s @InvalidMsg ; oops, its too high
cmpi #FirstMBMsg, d0 ;
blo.s @InvalidMsg ; oops, its too low
ADD.W D0,D0 ; double to get words
ADD.W GoBarProc(D0.w),A0 ; compute the dispatch address
JSR (A0) ; do the routine
@InvalidMsg
_SetPort ; restore the caller's port
move.l menuList, a0 ; set up to unlock menuList handle <FJL C175>
_HUnlock ; and unlock it <FJL C175>
restoreUnlinkReturn
GoBarProc Table
DT.W DrawBar ; draw is message #0
DT.W HitBar ; hit test is message #1
DT.W CalcBar ; calculate menu edges #2
DT.W InitBar ; init is message #3
DT.W DisposeBar ; dispose is message #4
DT.W HiliteBar ; hilite a title #5
DT.W HeightBar ; calculate mBar height #6
DT.W SaveBitsBar ; save menuBits #7
DT.W RestoreBitsBar ; restore menuBits #8
DT.W GetRectBar ; get menu's rectangle #9
DT.W SaveAltBar ; save other data #10
DT.W ResetScrollBar ; reset scrolling globals #11
DT.W ReturnMenuRgn ; return menu's region #12
DT.W MoveSICNToAM ; move small icon #13 <EMT S297>
DT.W GetTRect ; return title rect #14 <KSM><13>
DT.W BannerMsg ; Use menubar as banner #15 <KSM><14>
DT.W MoveICSToPM ; Move icon suite #16
DT.W MoveICSToAM ; Move icon suite to Apple Menu #17
DT.W MoveSICNToPM ; Move SICN to Application Menu #18
;******************************************************************************************
;* *
;* IF YOU ADD ANOTHER MESSAGE YOU MUST UPDATE THE VARIABLE "LastMBMsg" FOUND ABOVE !!!!!! *
;* *
;******************************************************************************************
;-----------------------------------------------
; FullClip -- set clip wide open
;-----------------------------------------------
FullClip
MOVE.L GrafGlobals(A5), A0 ; <EMT S297>
MOVE.L wideOpen(A0), -(SP) ; set the clip to wide open <EMT S297>
_SetClip ; <EMT S297>
rts
;--------------------------------------------------------------------------------------------
;
; Msg #3 -- Init -- allocate storage for saving bits behind for up to 5 menus
;
;--------------------------------------------------------------------------------------------
; <FJL C222>
; The Init Message initializes a data structure in which it stores information
; on up to 5 menus showing on the screen at once. This structure is documented
; in nToolEqu.a. It is allocated only once, the first time this message is passed
; after system startup.
InitBar
cmpi.l #-1, mbSaveLoc ; If first time after system start up, mbSaveLoc
; will have -1 in it
bne.s @clearIt ; if not first time then just clear lastMBSave
; else, alloc space
move.l #mbSaveSize, d0 ; alloc space for x-byte header plus
; 5 x-byte menu entries
_NewHandle SYS,CLEAR ; alloc handle on system heap and clear it
move.l a0, mbSaveLoc ; store the handle in low memory
@clearIt move.l mbSaveLoc, a0 ; get mbSaveLoc
move.l (a0), a0 ; dereference
clr lastMBSave(a0) ; ===> no menus showing
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #4 -- Dispose -- nothing for now since we leave mbSaveLoc handle in sys heap all the
; time, never mind the fact that no one sends this message.
;
;--------------------------------------------------------------------------------------------
DisposeBar ; <FJL C222>
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #6 -- Calc MB Height -- get MB Height into low memory global MBarHeight.
;
;--------------------------------------------------------------------------------------------
;
; the Height Message just calculates the lomem variable MBarHeight
; It's here for backward compatibility with the original ROM usage.
HeightBar
BSR.S GetMenuInfo ; get font info for wmgr port
MOVEQ #3,D1 ; get white space into D1
ADD.W D0,D1 ; add descent
SWAP D0 ; get ascent
ADD.W D0,D1 ; add ascent
MOVE.W D1,MBarHeight ; save it in low memory
RTS
;-----------------------------------------------
; Utility -- GetMenuInfo
;-----------------------------------------------
;
; GetMenuInfo is a utility that returns the ascent of the window manager's font in the high
; half of D0, and the descent in the low half. It trashes only insignificant registers.
GetMenuInfo
SUBQ #8,SP ; make room for a font info record
MOVE.L SP,-(SP) ; point to 8 byte info record
_GetFontInfo ; get font info for the system font
MOVE.L (SP)+,D0 ; return ascent, descent in D0
SWAP D0 ; get ascent in lo-word <FJL 22Jan87>
ADD 2(SP), D0 ; add leading to ascent <FJL 22Jan87>
ADDQ #1, D0 ; add one for good measure <FJL 22Jan87>
SWAP D0 ; restore D0 <FJL 22Jan87>
ADDQ #4,SP ; flush record
RTS
;-----------------------------------------------
; Utility -- GetMenuAscent
;-----------------------------------------------
;
; GetMenuAscent is a utility that returns the y-value for drawing the <FJL C175>
; font above the menu bar in D4.
GetMenuAscent
BSR.S GetMenuInfo ; get the font ascent
SWAP D0 ; get ascent in lo half
ADD.W portRect+top(A2),D0 ; add in portRect offset <1.2>
MOVEQ #0,D4 ; clear hi half of register
MOVE.W D0,D4 ; get the ascent + leading <FJL 22Jan87>
RTS
;-----------------------------------------------
; Utility -- ClipMBar
;-----------------------------------------------
;
; ClipMBar is a utility that sets the port's clipRgn to the menu bar.
; <EMT S297>
ClipMBar
MOVE.L CLIPRGN(A2),-(SP) ; push a handle to the clipRgn
; use portRect instead of assuming topLeft is (0,0) <FJL CXXX>
move portRect+Left(a2), -(sp); left
move portRect+Top(a2), -(sp) ; top
move PortRect+Right(A2),-(SP); right
move portRect+Top(a2), -(sp) ; bottom = top + mBarHeight
move MBarHeight, d0
add d0, (sp)
_SetRecRgn ; clip to the menu bar
RTS
;-----------------------------------------------
; Utility -- ClipToTempRect <11>
;-----------------------------------------------
;
; ClipToTempRect is a utility that sets the port's clipRgn to the application's menu area.
ClipToTempRect
LEA TempRect, A0 ; Get the base address of TempRect
MOVE.L CLIPRGN(A2),-(SP) ; push a handle to the clipRgn
MOVE.W left(A0), -(sp) ; left
MOVE.W top(A0), -(sp) ; top
move.w MBarHeight,d0 ; MBarBottom = top+MBarHeight <38>
move.w bottom(a0),d1 ; bottom <38>
add.w (sp),d0 ; sp points to top of TempRect <38>
cmp.w d1,d0 ; use MIn(bottom,MBarBottom) <38>
blt.s @useMBarHeight ; <38>
move.w d1,d0 ; <38>
@useMBarHeight ; <38>
MOVE.W right(A0), -(sp) ; right
move.w d0,-(sp) ; <38>
_SetRecRgn ; clip to TempRect
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #0 -- Draw the MB
;
;--------------------------------------------------------------------------------------------
;
; the Draw Message simply(!) draws the entire menu bar, if parameter is 0. If parameter is -1,
; then draw just a cleared menu bar. Otherwise, draw one title. No result is returned
DrawBar
; Set the clip region to the menu bar. If we are called to just clear the menu bar
; then the clip will stay set to this, else it will be set wide open
BSR.s ClipMBar ; <EMT S297>
MOVE.L Param2(A6), D3 ; Get the parameter <EMT S297>
BGT Its1Title ; Skip if it's a 1 Title draw <EMT S297>
cmp.l #-1,d3 ; if clear, donÕt use buffer <19>
beq.s @skipBuffering ; ignore the error <19>
rsrv.w ; room for error <20>
move.l clipRgn(a2),a0 ; start with the clipRgn <20>
move.l (a0),a0 ; dereference it <20>
pea rgnBBox(a0) ; pass the bounding box <20>
pea menuBarBuffer(a6) ; pass place for buffer <20>
_BeginDrawingOffscreen ; make the buffer <20>
free.w ; ignore the error <20>
@skipBuffering
; start by clearing the menubar area to the proper background color
tst.b onColorMachine(a6)
beq.s @DoErase
bsr SaveCurrentColors ; save current colors in stackframe
bsr GetPixelDepth ; put the current pixel depth in the stack frame
cmpi.w #2, PixelDepth(a6) ; is this 2+ mode, and color ?
blt.s @DoErase ; no, its 1 bit mode, so don't set color
subq #4, sp ; save space for result
clr.l -(sp) ; ID=0, Item=0 ===> menubar entry
_GetMCEntry ; get the color entry
move.l (sp)+, d0 ; get the result, and set z-flag if necessary
beq.s @DoDefault ; zero ===> no entry so use default
; we got a menu bar entry from the color table, so use it to color the menu bar
;
; normally we would set the forecolor to black for the erase rounded corners, but Quickdraw now
; assumes that if both fore/back "revert" to black (or white) in one bit mode then it reverses
; the backcolor, so we have to set the forecolor to the default title color here, then reset
; the colors for the rounded corner erase.
move.l d0, a0 ; get ptr to color entry in a0
pea mctRGB1(a0) ; push fore color
pea mctRGB4(a0) ; push back color
_RGBBackColor ; set the back color
_RGBForeColor ; set the fore color
bra.s @DoErase
@DoDefault ; default is always black on white
pea RGBBlack
pea RGBWhite
_RGBBackColor
_RGBForeColor
@DoErase
PEA PORTRECT(A2) ; push a pointer to full screen rectangle
BTST #7,onLCDMac(A6) ; is this Harpo <DAF 10Feb89><v1.4>
BZ.S @regErase ; if so, then do usual <DAF 10Feb89>
_EraseRect
BRA.S @doneErase
@regErase
MOVE.L #SCREENRADIUS,-(SP) ; push roundRect parameter
_EraseRoundRect ; paint the menuBar white
@doneErase
; erase around rounded corners because multiple screens leave little pieces of deskpat there
tst.b onColorMachine(a6)
beq.s @notColor
pea RGBBlack ; set black on white for erasing rounded corners
pea RGBWhite
_RGBBackColor
_RGBForeColor
@notColor
move.l portRect(a2), TempRect ; copy top, left
move.l portRect+Bottom(a2), TempRect+Bottom ; copy bottom, right
LEA TempRect,A0 ; get temp rect address
BTST #7,onLCDMac(A6) ; is this Harpo <DAF 10Feb89><v1.4>
BNZ.S @skipFrame ; if so, then no framing <DAF 10Feb89>
MOVE.L A0,-(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
LEA TempRect, A0 ; get temp rect address again
MOVE.L A0,-(SP) ; push the temp rect
MOVE.L #$00160016,-(SP) ; and a radius for nice rounding
_FrameRoundRect ; and black out the corners
@skipFrame
_PenNormal ; fix the pen back up <v1.4>
; use portRect instead of assuming topLeft is (0,0) <FJL CXXX>
MOVE.W PortRect+Right(A2),-(SP) ; push extreme right
move portRect+Left(a2), d0 ; get left in lo-byte
swap d0 ; put it in hi-byte
move portRect+Top(a2), d0 ; get top
add MBarHeight,D0 ; add menu bar height to get bottom
SUBQ.W #1,D0 ; need bottom-1
MOVE.W D0,-(SP) ; push vertical for LineTo
SWAP D0 ; get vertical in high word
MOVE.L D0,-(SP) ; and push point for MoveTo
_MoveTo ; move to left of line
_LineTo ; draw the line
bsr ResetPreviousColors ; reset colors before leaving
; if the parameter is -1, then return (just clear the bar). LEAVE CLIP SET TO MENU BAR !!!
CMP.L #-1,Param2(A6)
BEQ DrawDoneNoUnclipNoBuffering
; get ready to draw the menuList on the menuBar
TST.W (A3) ; any menus in the menuList?
BEQ DrawDone ; if not, we're done
clr.w saveD3(a6) ; assume no title hilited <FJL A428>
MOVEQ #6,D3 ; start with first (leftmost) entry
;---------------------------------------------------------
; main drawing loop
;---------------------------------------------------------
;
; This is the loop that draws the titles on the menu bar. It handles hiliting
; and graying out.
;
; on entry A3 MenuListP menu list pointer. Note: handle is locked
; D3 index index into menu list (#6 byte offsets)
; calc'ed A4 MenuInfoP Ptr into menu data for currently drawn menu.
;
; TODO: DrawMenuBar with a hilited menu leaves a handle around. The handle
; contains the bits behind the previously hilited menu! The reason is that
; Excel was screwing around with the menubar and we couldn't be sure that
; the handle in mbBitsBehind actually contained a handle to the bits behind
; the hilited menu. So, we couldn't dispose of the menu without Excel
; blowing up every time. Aaghhh!!!
DrawMLoop
move d3, d0 ; set up for GetTitleRect <FJL C175>
BSR GetTitleRect ; get this title's rect in TempRect <FJL C175>
move.l menuOH(A3,D3),A0 ; get the selected menuHandle <FJL C175>
_HLock ; lock it down <FJL C175>
MOVE.L (A0),A4 ; and dereference handle <FJL C175>
BSR Draw1Title ; use utility to draw text and <FJL C175>
; disable if necessary <FJL C175>
move.w theMenu, d0 ; get ID of hilited menu <FJL C175>
move.l menuOH(A3,D3),A4 ; reset a4, get the selected menuHandle <FJL C175>
MOVE.L (A4),A4 ; dereference handle <FJL C175>
cmp.w menuID(a4), d0 ; should this one be hilited? <FJL C175>
bne.s NextDraw ; no, then branch <FJL C175>
move d3, saveD3(a6) ; save d3 on the stack for use later <FJL A428>
; we're done processing one menu -- bump to the next one and loop if there's more to do
NEXTDRAW
move.l menuOH(A3,D3),A0 ; get the selected menuHandle <FJL C175>
_HUnlock ; unlock it <FJL C175>
SkipSysLoop
ADDQ #6,D3 ;bump index to next in list
CMP (A3),D3 ;compare d3 with lastMenu. Are we done?
BGT.S DONEDRAWMLOOP ; we're done
MOVE.L menuOH(A3,D3), A0 ; get the selected menuHandle <18>
MOVE.L (A0), A0 ; Get the menuptr
MOVE.W menuID(A0), D0 ; Get the menuID
CMP.W #-16384,D0 ; Is it a system menu
BGE.S DrawMLoop ; Nope, keep going
MOVE.W lastRight(A3), D0 ; Find right edge of reg menus
CMP.W menuLeft(A3,D3), D0 ; Is it after right edge?
BLE.S DrawMLoop ; Yes, it is
BRA.S SkipSysLoop ; Skip this menu
; select the item that is selected (if any) now, AFTER drawing all the titles
DONEDRAWMLOOP
BSR ClipMBar ; Restore the clip to the whole menu bar <10>
move saveD3(a6), d0 ; get savedID of hilited menu <FJL A428>
beq DrawDone ; branch if none <FJL A428> <SM3> CSS
move d0,d3 ; and put it in d3 too <FJL A428>
bsr GetTitleRect ; get selected title's rect <FJL A428>
move.l menuOH(a3,d3),a0 ; get selected menuHandle <FJL A428>
_HLock ; lock it down <FJL A428>
move.l (a0), a4 ; dereference <FJL A428>
bsr DoSelected ; and select it <FJL A428>
move.l menuOH(a3,d3),a0 ; get selected menuHandle <FJL A428>
_HUnlock ; unlock it <FJL A428>
BSR ClipMBar ; Restore the clip to the whole menu bar <42>
BRA.S DrawDone ; <EMT S297>
Its1Title ; <EMT S297>
CMP.W (A3), D3 ; Is it in the legal range? <EMT S297>
BGT.S DrawDone ; Skip if not <EMT S297>
MOVE.L D3, D0 ; Set up for GetTitleRect <EMT S297>
BSR GetTitleRect ; Get this title's rect in TempRect <EMT S297>
lea TempRect,a0 ; pass the item rectangle <19>
bsr BeginMenuBuffering ; make a buffer for this item <19>
MOVE.L menuOH(A3, D3), A0 ; Get the selected menuHandle <EMT S297>
_HLock ; Lock it down <EMT S297>
MOVE.L (A0), A4 ; And dereference handle <EMT S297>
BSR.S Draw1Title ; Draw it <EMT S297>
MOVE.W theMenu, D0 ; Get ID of highlighted menu <EMT S297>
CMP.W menuID(A4), D0 ; Should it be highlighted? <EMT S297>
BNE.S Its1Done ; Skip if not <EMT S297>
BSR DoSelected ; Select it <EMT S297>
Its1Done ; <EMT S297>
MOVE.L menuOH(A3, D3), A0 ; Get the menuHandle <EMT S297>
_HUnlock ; Unlock it <EMT S297>
; be a good citizen and set the clip rgn to full open
DrawDone
rsrv.w ; make room for error <20>
push.l menuBarBuffer(a6) ; hereÕs where we stored it <20>
_EndDrawingOffscreen ; finish buffering, and draw something <20>
free.w ; discard error <20>
bsr FullClip
DrawDoneNoUnclipNoBuffering
RTS
;--------------------------------------------------------------
; Utility -- Draw1Title -- draw one title in the menu bar
;--------------------------------------------------------------
;
; Here is the code that draws a title on the menu bar. It handles
; hiliting and graying out. It shares DrawCommon with DoSelected.
; It also sets the proper title colors for color and black/white
; machines.
;
; on entry A3 MenuList menu list pointer!
; A4 menu ptr selected menu pointer
; D3 index index into menu list (#6 offsets)
; D0 param2
; calc here D4 font info font ascent + leading (see GetMenuInfo)
Draw1Title
clr.w SelectFlag(a6) ; clear select flag ==> draw normal mode
CMP.W #6, D3 ; Is it the apple menu? <EMT S297>
BNE.S DrawCommon ; Skip if not <EMT S297>
MOVE.L mbSaveLoc, A0 ; Get handle to save data <EMT S297>
MOVE.L (A0), A0 ; Dereference it <EMT S297>
MOVE.W #-1, mbIconState(A0) ; Reset icon rotation <EMT S297>
DrawCommon
bsr GetMenuAscent ; returns y-val in D4
MOVE MENULEFT(A3,D3),-(SP) ; x coordinate is menuLeft[index]+8
move portRect+Left(a2), d0 ; <FJL CXXX>
add d0, (sp) ; adjust for portRect <FJL CXXX>
ADDQ #8,(SP) ; indent a little
MOVE.W D4,-(SP) ; set y coordinate
_MoveTo ; position the point to start drawing
clr TitleBackFlag(a6) ; calling SetTitleColor from DrawTitle
bsr SetTitleColor ; set color for title/background
pea TempRect ; clear the title rect to the backColor
_EraseRect
; DrawSimple is a simplified DrawCommon. It draws the title at the given pen point.
DrawSimple
bsr ClipToTempRect ; Keep drawing contained <11>
move.w #srcOr, -(sp) ; set text mode to srcOr
_TextMode
tst.b onColorMachine(a6)
beq.s DrawATitle
cmpi.w #$0114, menudata(a4) ; is the title the AppleMark?
bne.s DrawATitle ; no, so branch
BSR GetPixelDepth ; Get the current pixel depth <EMT S297>
CMP.W #4, PixelDepth(A6) ; 4+ pixel depth? <EMT S297>
BLT.S DrawATitle ; Wrong depth, use system font <EMT S297>
BSR IsBWMode ; Check to see if we are in B&W mode <10>
BEQ.S DrawATitle
if useAntiAliasedApples then
subq.w #6,sp ; make room for a color
move.l sp,-(sp)
_GetBackColor ; check background color
cmp.l #$FFFFFFFF,(sp) ; is it white?
bne.s @notWhite
cmp.w #$FFFF,4(sp) ; is it white?
bne.s @notWhite
@white
move.w #rAppleOnWhite,d0 ; get the apple on white
bra.s @gotID
@notWhite
tst.l (sp) ; is it black?
bne.s @notBlack
tst.w 4(sp) ; is it black?
bne.s @notBlack
@black
move.w #rAppleOnBlack,d0 ; get the apple on black
bra.s @gotID
@notBlack
moveq #rAppleWithMask,d0 ; get the (less attractive) apple for any background
@gotID
addq.w #6,sp ; get rid of the color
endif
BSR CalcRightRectSize
SUBQ.L #2, SP ; Make room for return value <DCC 8/8/90>
PEA TempRect ; push the address of the dest rectangle <DCC 8/8/90>
MOVEQ #atCenterTop, D0 ; get the alignment code <DCC 8/8/90>
MOVE.W D0, -(SP) ; push it. <DCC 8/8/90>
BTST #0, menuEnable+3(a4) ; is the title disabled? <DCC 8/8/90>
BNE.S @notGray ; if not, then don't use a transform <DCC 8/8/90>
MOVEQ #ttDisabled, D0 ; else use ttDisabled <DCC 8/8/90>
BRA.S @transform ; <DCC 8/8/90>
@notGray MOVEQ #ttNone, D0 ; <DCC 8/8/90>
@transform MOVE.W D0, -(SP) ; push the transform <DCC 8/8/90>
MOVE.W #rAppleSuite, -(SP) ; push the id of the color apple icon suite <DCC 8/8/90>
_PlotIconID ; plot the puppy <DCC 8/8/90>
ADDQ.L #2, SP ; Don't care about the result <DCC 8/8/90>
bsr ResetPreviousColors ; reset to original fore/back colors
rts ; and return
DrawATitle
cmp.b #5,menuData(a4) ; is the string at least 5 bytes long?
blo.s @notIcon
cmp.b #1,menuData+1(a4) ; is the first character a 1?
bne.s @notIcon
BSR.S CalcRightRectSize
subq #2, SP ; make room for result
PEA TempRect ; push the title rect
move.w #atAbsoluteCenter, -(sp) ; No need to do centering since the rect is of the right size
btst #0, menuEnable+3(a4) ; is the title disabled? <DCC 8/06/90>
bne.s @noTransform ; if not, then don't use a transform <DCC 8/06/90>
moveq #ttDisabled, d0 ; else use ttDisabled <DCC 8/06/90>
bra.s @pushTransform ; <DCC 8/06/90>
@noTransform moveq #ttNone, d0 ; <DCC 8/06/90>
@pushTransform move.w d0, -(sp) ; push the transform <DCC 8/06/90>
move.l menuData+2(a4), -(sp) ; push the icon handle
; bsr ResetPreviousColors ; Reset the title colors <DCC 8/06/90>
; tst.w selectFlag(a6) ; Is this sucker selected <DCC 8/06/90>
; beq.s @colorsOK ; if not, go ahead and plot <DCC 8/06/90>
; bsr ResetPreviousColors ; restore the old colors so they will be saved by setTitleColor <DCC 8/06/90>
; clr.w selectFlag(a6) ; lie about the select state <DCC 8/06/90>
; bsr SetTitleColor
; not.w selectFlag(a6) ; restore the select state <DCC 8/06/90>
@colorsOK
_PlotIconSuite
addq #2, SP ; dump the result
bsr ResetPreviousColors ; set up old colors <DCC 8/06/90>
rts ; run away <DCC 8/06/90>
; bra.s ChkDisable ; <DCC 8/06/90>
@notIcon
PEA MenuData(A4) ; push pointer to title string
MOVE #srcOr,-(SP) ; Just to be sure grayish isnt happening
_TextMode
TST.B onColorMachine(A6)
BNE.S @DrawStringOnColorMachine
_DrawString
btst #0, menuEnable+3(a4) ; is the title disabled?
bne.s dontchk ; no, continue
bsr PaintTitleDisable ; disable the title by painting with gray
bra.s dontchk
@DrawStringOnColorMachine
btst #0, menuEnable+3(a4) ; is the title disabled?
bne.s @notDisabledOnColorMachine
MOVE #grayishTextOr,-(SP) ; special funny mode
_TextMode
@notDisabledOnColorMachine
_DrawString
MOVE #srcOr,-(SP) ; should be txMode!!!
_TextMode
dontchk
bsr ResetPreviousColors ; reset to original fore/back colors
rts ; and return
CalcRightRectSize
MOVEM.L A0/D0, -(SP)
LEA TempRect,A0
move.w right(A0), D0 ; Get the right side
sub.w left(a0), D0 ; find the width
cmp.w #$10, D0 ; Is it big enough to fit a small icon?
ble.s @tooSmall
asr.w #2, D0 ; Divide the gap in half
add.w left(A0), D0 ; offset the left side
move.w D0,left(A0) ; update Left
add.w #1, top(A0) ; Tweek the top a bit
@tooSmall
move.l topLeft(A0),D0 ; get the top and left
swap D0 ; put top in low word
add.w #16, D0 ; add 16
swap D0 ; put left in low word
add.w #16, D0 ; add 16
move.l D0, botRight(A0) ; Update bottom and right
MOVEM.L (SP)+, A0/D0
RTS
;-----------------------------------------------
; Utility -- SaveCurrentColors
;-----------------------------------------------
SaveCurrentColors
pea saveBackColor(a6) ; push address of var parm
_GetBackColor ; get the background color
pea saveForeColor(a6) ; push address of var parm
_GetForeColor ; get foreground color
rts
;-----------------------------------------------
; Utility -- SetTitleColor
;-----------------------------------------------
; Set the foreground/background color for this
; title. If has colorQD then use real colors
; else just use black/white
;
SetTitleColor
tst.b onColorMachine(a6)
beq @SetBW
BSR.S SaveCurrentColors ; Save current colors in stack frame <EMT S297>
TST.W TitleBackFlag(A6) ; DrawTitle = 0, DrawStruct = 1 <PMAB364 23Jan88 EMT>
BEQ.S @FromTitle0 ; Branch if from DrawTitle <PMAB364 23Jan88 EMT>
LEA menuRect(A6), A0 ; RGetPixelDepth uses menu rect <PMAB364 23Jan88 EMT>
BRA.S @GetDepth ; Go get depth <PMAB364 23Jan88 EMT>
@FromTitle0
LEA portRect(A2), A0 ; RGetPixelDepth uses menu bar <PMAB364 23Jan88 EMT>
@GetDepth
BSR RGetPixelDepth ; Get the current pixel depth <PMAB364 23Jan88 EMT>
cmpi.w #2, PixelDepth(a6) ; is this 2+ mode, and color ?
blt.s @DefaultColors ; no, its 1 bit mode or mono
move.l a4,d0 ; <49> Are we pointing to a MenuInfo record?
bz.s @TryMenuBar ; <49> No. Get the color entry for the menu bar
subq #4, sp ; save space for result
move menuID(a4), -(sp) ; push ID
clr -(sp) ; push Item=0 ===> title entry
_GetMCEntry ; get the color entry
move.l (sp)+, d0 ; get the result, and set z-flag if necessary
beq.s @TryMenuBar ; nope no title entry, try menu bar entry
; got menu title entry, so put colors on stack
move.l d0, a0 ; get entry address in a0
tst TitleBackFlag(a6) ; called from DrawTitle = 0, DrawStruct = 1
beq.s @FromTitle1 ; branch if from DrawTitle
pea mctRGB1(a0) ; foreground unimportant for DrawStruct
pea mctRGB4(a0) ; get specified background color
bra.s @SetColors
@FromTitle1
pea mctRGB1(a0) ; push title color
pea mctRGB2(a0) ; push menu bar color
bra.s @SetColors
; didn't get title entry, so try to get menu bar entry for menu color
@TryMenuBar
subq #4, sp ; save space for result
clr.l -(sp) ; ID=0, Item=0 ===> menubar entry
_GetMCEntry ; get the color entry
move.l (sp)+, d0 ; get the result, and set z-flag if necessary
beq.s @DefaultColors ; zero ===> no entry so use default
; got menu bar entry, so set colors
move.l d0, a0 ; get entry address in a0
tst TitleBackFlag(a6) ; called from DrawTitle = 0, DrawStruct = 1
beq.s @FromTitle2
pea mctRGB3(a0) ; foreground unimportant for DrawStruct
pea mctRGB2(a0) ; get default background from menubar entry
bra.s @SetColors
@FromTitle2
pea mctRGB1(a0) ; push default title color
pea mctRGB4(a0) ; push menu bar color
bra.s @SetColors
; set colors for default title
@DefaultColors
pea RGBBlack ; set foreground color to black
pea RGBWhite ; set background color to white
; colors are on the stack for normal title, switch them if this is a selected title
@SetColors tst.w selectFlag(a6) ; normal or selected?
beq.s @1 ; normal ===> addresses ok on stack
move.l (sp), a0 ; selected ===> switch addresses on stack
move.l 4(sp), (sp)
move.l a0, 4(sp)
@1 _RGBBackColor ; color addresses are on the stack
_RGBForeColor
bra.s @DoneSetTitleColor
; set colors for selected title
@SetBW moveq #WhiteColor, d0 ; set foreground color to white
move.l d0, -(sp)
moveq #BlackColor, d0 ; set background color to black
move.l d0, -(sp)
tst.w selectFlag(a6) ; normal or selected?
beq.s @BWNormal ; normal, so branch
_BackColor ; colors are on the stack
_ForeColor
bra.s @DoneSetTitleColor
@BWNormal
_ForeColor ; do calls in reverse if normal
_BackColor
@DoneSetTitleColor
rts
;-----------------------------------------------
BeginMenuBuffering
; Create an off-screen buffer for the menu bar, or a part of it.
; Then, attach this buffer to the port passed.
; The bits in the buffer are not initialized (must draw over the whole thing).
; This must be balanced by an EndMenuBuffering, which will blast the bits onto the screen.
;
; In:
; a0 pointer to rectangle for size of buffer
rts
;-----------------------------------------------
; Utility -- ResetPreviousColors
;-----------------------------------------------
; Reset the foreground/background color for this
; title. If has colorQD then use saved colors
; else just use black/white
;
ResetPreviousColors
tst.b onColorMachine(a6)
beq.s @ResetBW
pea saveForeColor(a6) ; push addresses of color records
pea saveBackColor(a6)
_RGBBackColor ; set the background color
_RGBForeColor ; get the foreground color
bra.s @ResetDone
@ResetBW
moveq #BlackColor, d0 ; force foreground color to black
move.l d0, -(sp)
moveq #WhiteColor, d0 ; force background color to white
move.l d0, -(sp)
_BackColor
_ForeColor
@ResetDone
rts
;-----------------------------------------------
; Utility -- PaintTitleDisable
;-----------------------------------------------
; If the title is disabled and there is no
; colorQD then paint TempRect with Gray
;
; Save and restore pen state for the application Tempo. <FJL 26Mar87>
PaintTitleDisable
btst #0, menuEnable+3(a4) ; is the title disabled?
bne.s @EndCheck ; no, so just return
suba #psRec, sp ; save space for pen state on the stack
move.l sp, -(sp) ; push pen state rec address
_GetPenState ; get the pen state
MOVE.L (A5),A0 ; get QuickDraw globals
PEA Gray(A0) ; push gray
_PenPat ; make that the pen pattern
move #PatBIC,-(SP) ; set bit clear mode
_PenMode ; set the penMode
pea TempRect ; push the rect addr
_PaintRect ; bit clear with gray
move.l sp, -(sp) ; push pen state rec address
_SetPenState ; reset to previous pen state
adda #psRec, sp ; remove pen state rec from stack
@EndCheck
rts
;-----------------------------------------------
; Utility -- GetPixelDepth
;-----------------------------------------------
;
; Utility to get current pixel depth and put it in the stack frame.
; RGetPixelDepth uses the rectangle pointed to by A0. <PMAB364 23Jan88 EMT>
GetPixelDepth
LEA portRect(A2), A0 ; Use WMgr's portRect <PMAB364 23Jan88 EMT>
RGetPixelDepth ; <PMAB364 23Jan88 EMT>
subq #4, sp ; space for GDHandle return
MOVE.L A0, -(SP) ; rect for GetMaxDevice <PMAB364 23Jan88 EMT>
_GetMaxDevice ; get max pixel device
MOVE.L (sp)+, A0 ; get the grafDevice
MOVE.L (A0),A1 ; hndl->ptr <PMAB364 23Jan88 EMT>
MOVE.L GDPMap(A1),A1 ; get the device's pixmap <PMAB364 23Jan88 EMT>
MOVE.L (A1),A1 ; hndl->ptr
move.w pmPixelSize(a1), PixelDepth(a6) ; and store the value
rts
;-----------------------------------------------
; Utility -- IsBWMode
;-----------------------------------------------
;
; Utility to test the monochrome/color information for the menu's monitor.
; Returns: Z-Flag means Monochrome, otherwise not B&W
IsBWMode
subq #2+4, sp ; space for boolean and for GDHandle <19>
PEA portRect(A2) ; Use WMgr's portRect
_GetMaxDevice ; get max pixel device
MOVE.W #gdDevType,-(SP) ; And we want to test the gdDevType
_TestDeviceAttribute ; Go get it
TST.B (SP)+ ; Set the Z-flag
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #1 -- Hit Test -- is the mouse in the title bar, or in a menu, or in neither.
;
;--------------------------------------------------------------------------------------------
;
; The Hit Message takes a point in parameter, and determines whether the mouse
; point is in a title rect of the MenuBar.
; 1. If point in title or menu return menu's index
; 2. If point in title bar but not in title return 0
; 3. If point not in any title or menu then return -1
;
; To allow for multiple screens the menu bar extends for the width of the portRect only <FJL CXXX>
; Don't include the line under the menu bar as a hit, otherwise it is possible to <FJL CXXX>
; to choose the first menu item immediately <FJL CXXX>
;
HitBar
MOVE.L Param2(A6),D1 ; get the point
SWAP D1 ; get the vert coord in lo word
move portRect+Top(a2),d0 ; get top of menu bar in d0 <FJL CXXX>
cmp d0, d1 ; above menu bar ?
blt @NotInBar
add MBarHeight, d0 ; get bottom of menu bar in d0
cmp d0, d1 ; below menu bar ?
bge.s @NotInBar ; don't include line at bottom of menu <FJL CXXX>
; else can choose first item immediately
; Check the left and right sides of the menu bar
SWAP D1 ; get the horiz coord in lo word
move portRect+Left(a2),d0 ; get left of menu bar in d0 <FJL CXXX>
cmp d0, d1 ; to the left of the menu bar ?
blt.s @NotInBar
move portRect+Right(a2),d0 ; get right of menu bar in d0
cmp d0, d1 ; to the right of the menu bar ?
bgt.s @NotInBar
; it's in the bar, check if it's in a menu title
; NOTE: all title bounds (e.g. lastRight and menuLeft) are zero-based offsets, before <FJL CXXX>
; we start checking D1 against these we must first adjust it for portRect+Left(a2) <FJL CXXX>
MOVE.W portRect+Right(a2), D0 ; Right edge of menu bar
SUB.W #mbMenu1Loc,D0 ; Right edge of right-hand system menu ;<KSM <4>>
CMP.W D0, D1 ; Is point to the right of it? ;<KSM <4>>
BGT.S @NoTitle ; No way itÕs in a title ;<KSM <4>>
SUB.W portRect+Left(a2), D1 ; adjust D1 for portRect+Left
CMP.W #mbMenu1Loc, D1 ; is it to the left of the first title ?
BLT.S @NoTitle
;______________________<11>
; Notes on new hit testing:
; 1) We donÕt return a hit on a system menu whose left edge is <= lastRight (it "fell off").
; CalcBar set lastRight to the left edge of the last system menu if there were too many
; application menus, thus the last system menu can never "fall off."
; 2) We donÕt return a hit on any application menu whose left edge is past lastRight, but if
; if lastRight is somewhere in the middle of the menu, it will be allowed to hit in
; the area from itÕs left up to lastRight.
; Check either system set or application set
; _DMSG 'Welcome to Hitbar'
MOVEQ #0,D4 ; Courtesy Microsoft Corp., Excel Division <16>
MOVE.W lastMenu(A3), D4 ; D4 = lastMenu
BEQ.S @NoTitle
MOVE.W lastRight(A3), D3 ; D3 = lastRight
BSR FindFirstSystemMenu6BO ; Put offset to first system menu in D0
BEQ.S @NoSystemMenusHitEntry ; OOPS, no system menus!
CMP.W D3, D1 ; IF pt.h <= lastRight THEN
BLE.S @CheckAppMenus ; Hit was in app list somewhere
; Check system menus for allowable hit range
@sysChkLoop
MOVE.W menuLeft(A3,D0.W), D2 ; Get the menu.left
CMP.W D3, D2 ; WHILE menu.left < lastRight
BGE.S @HitLoop ; Found 1st visible title, regs set up already
CMP.W D4, D0 ; Is this the last menu?
BGE.S @NoTitle ; If not, there are no visible system menus(?)
ADD.W #6, D0 ; go to next menu
BRA.S @sysChkLoop
; Check application menus for allowable hit range
@regChkLoop
MOVE.W menuLeft(A3,D0.W), D2 ; Get the menu.left
CMP.W D3, D2 ; WHILE menu.left >= lastRight
BLT.S @foundLastVisRegMenu ; Found last visible title
@CheckAppMenus
SUB.W #6, D0 ; Move to the previous menu
BNE.S @regChkLoop ; And loop
BRA.S @NoTitle ; Well, we put the check in for this above...
@foundLastVisRegMenu
; We want to hit test from D0 -(downto)-> firstmenu
MOVE.W D0, D4 ; D0 is where we want to start
@NoSystemMenusHitEntry
CMP.W D3, D1 ; IF pt.h <= lastRight THEN
BGT.S @NoTitle ; bra if no sysmenus but hit beyond app menus
MOVEQ #6, D0 ; the first menu 6BO
; Hit loop: loop D4 downto D0
@HitLoop
CMP.W menuLeft(A3,D4), D1 ; IF pt.h >= menu.left THEN we got it!
BGE.S @HitThisOne ; Yeah!
CMP.W D0,D4 ; Are we done?
BEQ.S @NoTitle ; Yep
SUB.W #6, D4
BRA.S @HitLoop
;______________________<11>
@HitThisOne
MOVE.L D4,result(A6) ; return the menu
@HitDone
RTS
@NoTitle
CLR.L result(A6) ; if in menubar but no title, return menu number 0
BRA.S @HitDone ; and return
; Point not in bar, so check if in the rectangle of any menu on screen. Notice that this <FJL C222>
; loop checks thru the menus backwards, starting with the last one up, which is correct. <FJL C222>
@NotInBar
move.l mbSaveLoc, a0 ; get handle to mbar's save data
move.l (a0), a3 ; dereference
move.w lastMBSave(a3),d3 ; are there any menus?
beq.s @NotInAnyMenu ; no, so return -1
@RectLoop
clr.w -(sp) ; make room for PtInRect result
move.l param2(a6), -(sp) ; push the point
pea mbRectSave(a3,d3) ; push the rect address
_PtInRect ; test if point in rect
tst.b (sp)+ ; was it?
bne.s @FoundMenu ; yes, so return menuIndex (6 byte offset)
subi #mbEntrySize, d3 ; move to next index
beq.s @NotInAnyMenu ; if index == 0 then checked them all
bra.s @RectLoop ; index != 0 so check some more
; return the menuIndex in the lo-word of the result
@FoundMenu
clr.l result(a6) ; clear hi-word of result
move.w mbMLOffset(a3,d3), result+2(a6)
bra.s @HitDone ; and return
@NotInAnyMenu
MOVE.L MinusOne,result(A6) ; if not in bar return -1
BRA.S @HitDone
;--------------------------------------------------------------------------------------------
;
; Msg #2 -- Calc -- Calculate left edges for some or all Menus in menuList data structure
;
;--------------------------------------------------------------------------------------------
;
; The Calc Message recalculates left edge starting points for each menu,
; starting at the menuIndex passed in parameter. If parameter is zero,
; the entire menu structure is recalculated. Other than updating the MenuList,
; this routine returns no result.
; NOTE: These calculations are all zero-based. That is, if portRect+Left(a2) is non-zero
; the values calculated here are unaffected. Adjustments are made for portRect+Left
; when the values are used.
; Dave found a bug in this due to assumption of D4's value at start of routine
; now D4 is set explicitly (somebody used D0, then changed to D4 without proper initialization)
CalcBar
tst lastMenu(a3) ; are there any menus to calculate ?
beq CalcDone ; no, so nothing to calculate
MOVE.L SystemMenuList, A0 ; Get system menulist
MOVE.L (A0), A1 ; deref system menulist handle
TST.W lastMenu(A1) ; Are there any system menus?
BEQ SystemMenusAreIN ; Well, there aren't any -- so they are all in! <SM3> CSS
BSR FindFirstSystemMenu6BO ; See if the system menus are in.
BNE.S SystemMenusAreIN ; Yes, they are (D0 is offset to 1st one)
MOVEQ #6,D0
MOVE.L menuOH(A3,D0.W),A1 ; Get menuhandle of leftmost menu
MOVE.L (A1),A1 ; menuhandle -> menuptr
CMPI.W #$0114,menuData(A1) ; Is it an apple menu?
BNE.S SystemMenusAreIN ; NE means no apple menu, donÕt add system menus
_HLock ; Lock SysList before munging (weÕre pointing into it)
MOVE.L (A0),A1 ; handle -> ptr
MOVEQ #0, D1 ; Clear the high word
MOVE.W lastMenu(A1),D1 ; Get # of bytes of system menus
ADDQ.L #6, A1 ; Point A1 to first system menu entry
MOVEQ #6, D0 ; Get offset of 1st menu entry
ADD.W lastMenu(A3), D0 ; D1 = Offset past lastMenu entry
; long = Munger(menulist, offset past regular menus, NIL, 0, ptr to 1st system menu, len sys menus)
SUBQ.L #4, SP ; Make room for result
MOVE.L MenuList,A0 ; Get the menulist
MOVE.L A0, -(SP) ; handle -- Menulist handle pushed
MOVE.L D0, -(SP) ; offset = past last one in existing list
MOVE.L #0, -(SP) ; ptr1 = NIL
MOVE.L #0, -(SP) ; len1 = 0 -- means insert (ptr2,len2) at offset
MOVE.L A1, -(SP) ; ptr2 = first system menu
MOVE.L D1, -(SP) ; len2 = #Bytes of system menus
ADD.W D1, lastMenu(A3) ; Just for luck, add up the new stuff we're adding
_HUnlock ; DonÕt Munge locked handles!
_Munger ; oooh baby, munge me!
MOVE.L MenuList, A0 ; Get (potentially) new menulist handle
_HLock
MOVE.L (A0), A3 ; Restore A3 to new value
MOVE.L SystemMenuList, A0 ; Get system menulist
_HUnlock ; Unlock it
ADDQ.L #4, SP ; Ignore the results
; BRA.S MenusExist ; There are menus in the menulist now
SystemMenusAreIN
; Now start the regular calc stuff
; tst lastMenu(a3) ; are there any menus to calculate ?
; beq CalcDone ; no, so nothing to calculate
MenusExist
MOVE.L Param2(A6),D4 ; get the menuIndex to start in
TST.W D4 ; pick up as long, but treat as word <FJL C222>
BEQ.S @entireBar ; if it's zero, then do entire bar
CMP.W (A3),D4 ; is it in the legal range?
BGT CalcDone ; if greater, then skip
MOVE.W menuLeft(A3,D4),D3 ; get the left edge for the starting title
BRA.S CalcLoop ; and continue
@entireBar
MOVEQ #mbMenu1Loc,D3 ; first menu starts ten pixels in
MOVEQ #6,D4 ; first menu's info starts at byte 6
MOVE.W D3,menuLeft(A3,D4) ; write it's menuLeft into the MenuList
; get the menu title string and measure it
CalcLoop
MOVE.L menuOH(A3,D4),A0 ; get the menuHandle
MOVE.L (A0),A0 ; dereference it
cmp.b #1,menuData+1(a0) ; is the first character a 1?
bne.s @notSysMenu
add.w #15,d3 ; all icons are 16 pixels wide, but do 15 <10>
bra.s @done
@notSysMenu
SUBQ.L #2,SP ; make room for function return
PEA menuData(A0) ; push a pointer to the menu text
_StringWidth ; get the size of it
ADD.W (SP)+,D3 ; add to this item's left edge
@done
ADD.W #mTitleSpace,D3 ; add space (determined empirically)
ADDQ #6,D4 ; move to the next menu
CMP.W (A3),D4 ; was this the last menu
BGT.S CalcLoopDone ; it is, so leave this loop
MOVE.W D3,menuLeft(A3,D4) ; place in the left edge of next
BRA.S CalcLoop ; loop back
CalcLoopDone
MOVE.W D3,lastRight(A3) ; set right edge always (even tho we may update it)
BSR FindFirstSystemMenu6BO ; Find first system menu
MOVE.W D0,D4 ; Are there any? (Save offset in D4)
BEQ CalcDone
MOVE.W menuLeft(A3,D0.w), D0 ; Get the 1st system menu's left
MOVE.W D0, lastRight(A3) ; Make that the last right of regular menus
; Compute the distance by which the last system menu's left edge should be adjusted
; and add this to each left edge of system menus, thereby right justifing them.
MOVE.W lastMenu(A3),D0 ; Get the last system menu offset
MOVE.W menuLeft(A3,D0),D0 ; Get the last system menuLeft as calculated
MOVEQ #0, D1 ; Clear out high word
SUB.W D0, D3 ; Last.right - Last.left + 1 [width of menu]
ADD.W #1, D3 ; Width of menu as computed elsewhere (it guides this)
ADD.W #mbMenu1Loc, D3 ; Width + mbMenu1Loc [symmetrical offset from right edge]
MOVE.W portRect+right(A2),D1 ; Get the right edge of the world
SUB.W D3, D1 ; Where the actual left edge should be
SUB.W D0, D1 ; Distance between computed and actual lefts
MOVE.W menuLeft(A3,D4), D0 ; Get left edge of the menu we are moving
; MOVE.W D0, lastRight(A3) ; Save as new last right (last one is correct)
SysOffsetLoop
ADD.W D1, menuLeft(A3,D4) ; Offset system menuÕs left edge (D4 is 1st sys)
CMP.W lastMenu(A3),D4 ; was this the last menu
BEQ.S SysOffsetLoopDone ; it is, so leave this loop
ADDQ.W #6, D4 ; go to next one
BRA.S SysOffsetLoop
SysOffsetLoopDone ; <48> (the rest of this routine)
; At this point, D1 is the pixels we moved the system menus
; If D1 >= 0 then they moved right and there is space between
; the app menus and the system menus, so no overlap checking is necessary
; and lastRight is correct.
TST.W D1
BGE.S CalcDone ; D1 > 0, there is no overlap: weÕre done.
; Bummer, app menus overlap the system menus.
; Find the "hard lastRight" - the left edge of the leftmost system menu we must keep
BSR.S FindFirstSystemMenu6BO ; Find first system menu
MOVE.W D0,D3
MOVE.W lastMenu(A3),D4 ; Must keep the app menu no matter what
MOVE.W MBDFFlags,D1 ; Get the flags
BEQ.S D4IsHardEdge6BO ; No special case
LSR.W #4,D1 ; Only "keep count" bits
ANDI.W #$F,D1
BEQ.S D4IsHardEdge6BO ; And weÕve got the 6B0 of the menu containing the hard edge
ADD.W D1,D1 ; 2x
MOVE.W D1,D0 ; 2x copy
ADD.W D0,D0 ; 2x + 2x = 4x
ADD.W D1,D0 ; 4x + 2x = 6x
SUB.W D0,D4 ; lastMenu - 6B0 of savings
CMP.W D3,D4 ; is computed menu < 1st system menu
BGE.S D4IsHardEdge6BO ; no, use computed menu as hard right
MOVE.W menuLeft(A3,D3), D0 ; Get 1st system menu left edge
D0IsNewLR MOVE.W D0, lastRight(A3) ; Left edge is this
; So there's not much else to say, App menus overlap
; and we have to keep all the system menus....
CalcDone RTS
D4IsHardEdge6BO
MOVE.W lastRight(A3),D1 ; cache last right
MOVE.W menuLeft(A3,D4),D2 ; prime menuLeft
transSearchLoop MOVE.W menuLeft(A3,D4),D0 ; get menuLeft
CMP.W D1,D0 ; Is menuLeft < lastRight?
BLT.S foundTransMenu
MOVE.W D0,D2 ; Save this one
SUBQ #6,D4 ; Point to next previous system menu
CMP.W D3,D4 ; At the last one?
BGE.S transSearchLoop
foundTransMenu
MOVE.W MBDFFlags,D1 ; Get the flags
ANDI.W #$F,D1 ; Only slop bits
LSL.W #1,D1 ; Two pixel increments
ADD.W D0,D1 ; menuLeft = menuLeft + slop
CMP.W lastRight(A3),D1 ; Is menuLeft + slop >= lastRight ?
BGE.S D0IsNewLR ; Keep this menu (above slop threshold)
MOVE.W D2,D0 ; menuLeft is new last right
BRA.S D0IsNewLR
;______________________________________________________________________________________________
; Utility -- FindFirstSystemMenu6BO
; Returns the 6B0 of the 1st system menu found in the menulist in D0 (conditions set).
; Returns zero if no system menus are in the current menu bar.
; All registers (except D0 of course) are preserved.
; NOTE: We walk from last menu -> first since there usually are fewer system menus
; and they are at the end of the menu list
FFSMSaveReg REG A0/A1
FindFirstSystemMenu6BO
MOVEM.L FFSMSaveReg, -(SP) ; Save our regs
MOVE.L MenuList, A0 ; Get the current menulist
MOVE.L (A0), A0 ; dereference
MOVEQ #0, D0 ; Clear high word
MOVE.W lastMenu(A0), D0 ; Get the last menu offset
BEQ.S @done ; If there are none, done
@nextMenu
MOVE.L menuOH(A0,D0.w), A1 ; Get the menu handle
MOVE.L (A1), A1 ; dereference
CMP.W #-16384, menuID(A1) ; IF menuID >= -16384 THEN
BGE.S @pastSysMenus ; GOTO pastSysMenus
SUBQ #6, D0 ; point to the next one in the menulist
BNE.S @nextMenu ; and continue
; Falling out of loop, D0=0 and 1st is system menu
@bumpAndExit
ADDQ #6, D0 ; Bump D0 to point to next entry
BRA.S @done ; And weÕre outa here
@pastSysMenus
CMP.W lastMenu(A0), D0 ; were there any system menus at all?
BLT.S @bumpAndExit ; D0 moved, so we found at least 1 system menu
MOVEQ #0,D0 ; Show that there is no partition
@done
MOVEM.L (SP)+, FFSMSaveReg ; Restore our regs
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #5 -- Hilite -- do the indicated menu hiliting
;
;--------------------------------------------------------------------------------------------
;
; The Hilite message redraws a single title to the hilite state specified
; in the hi word of parameter. States are:
; 0 unhilited/normal appearance --
; restore the bits behind the title rect
; 1 selected appearance --
; save the bits behind the menu title and draw the selected title
; 2 disabled appearance --
; redraw the title using the "disabled" pattern as an overlay
; NOT SUPPORTED CURRENTLY
; 3 busy appearance --
; redraw the title using the "busy" pattern as an overlay
; NOT SUPPORTED CURRENTLY
; 128+ blit SICN resource onto screen --
; NOT SUPPORTED CURRENTLY
;
; The index of the title to perform hiliting on is in the lo-word of parameter
; (if 0, then the whole bar is hilited).
;
; NOTICE: The way we handle normal and selected menu titles is very different now.
; On MacPlus selecting a menu caused the menu title to be inverted, and
; unselecting it (HiliteMenu(0)) just inverted it again. This meant that
; menu titles were unreadable on programs that use the full screen. In this
; new model when a menu is selected the bits behind are saved, and the
; title is drawn in the reverse colors (e.g. white on black). HiliteMenu(0)
; then causes the bits behind to be restored.
; INTERESTING...: Because most apps that play with multiple heaps (e.g. TurboPascal) already
; know about the menuList, the handle to the bits behind a hilited title
; are saved in the menuList rather than the mbarproc private data. That
; way we don't have to worry about having multiple menus hilited under
; twitcher either (though we still can't have menus down across several
; apps at the same time)
;
; ASSUMPTIONS:
; 1. The menuID is valid, i.e. the menu is found in the menuList.
;
; On entry A3 MenuList menu list pointer. Its handle is locked.
;
; Calc values for A4 menu ptr selected/unselected menu ptr
; D3 index index into menu list (#6 offsets)
; D4 font info font ascent + leading (see GetMenuInfo)
HiliteBar
BSR ClipMBar ; <EMT S297>
MOVE.W param2+2(A6),D0 ; get the hilite selector
BEQ FlipBar ; if index = 0 then flip bar <FJL C175><35> <SM3> CSS
CMP.W #1,param2(a6) ; hi-word has hilite
BGT.S DoneHilite ; if not in range we support then bye-bye
blt.s Unhilite ; unhiliting is totally different from hiliting
CMP.W lastMenu(A3),D0 ; is it a legal menu title? <10>(lastRight->lastMenu)
BGT.S DoneHilite ; nope, so return
moveq #0, d3 ; clear d3 <FJL C175>
move.w d0, d3 ; keep 6 byte offset here
BSR GetTitleRect ; get this title's rect in TempRect
; If we got here then everything is valid, so lock down the selected menuHandle
MOVE.L menuOH(A3,D3),A0 ; get the selected menuHandle <FJL C175>
_HLock ; lock it down <FJL C175>
move.l (a0), a4 ; get selected menu ptr
bsr.s DoSelected ; call save bits and draw routine
move.l menuOH(A3,D3),A0 ; get the selected menuHandle <FJL C175>
_HUnlock ; and unlock it <FJL C175>
; be a good citizen and set clip full open before we leave
DoneHilite
bsr FullClip ; set clip wide open <FJL C428>
RTS
; unhiliting works no matter what menu offset is passed in, since we just restore the bits
Unhilite
bsr DoNormal
bra.s DoneHilite
;-------------------------------------------------------------------
; Hilite State is 0 -- unhilited/normal appearance -- restore bits
;-------------------------------------------------------------------
DoNormal
; we clear TheMenu here because DrawMenuBar may be called by
; RestoreBits and we don't want to draw and later un-hilite the bits
clr.w TheMenu
move lastMenu(a3), d0 ; get last regular menu
addq #6, d0 ; offset to HMenu header info
subq #2, sp ; make room for result
move.l menuTitleSave(a3,d0.w),-(sp) ; get title handle
clr.l menuTitleSave(a3,d0.w) ; and clear out saved handle
_RestoreBits
addq #2, sp ; ignore the result
clr.l SavedHandle ; set lomem to NIL
rts
;-------------------------------------------------------------------
; Hilite State is 1 -- selected appearance -- save bits, draw title <FJL C222>
;-------------------------------------------------------------------
DoSelected
moveq #0,d0 ; Title bits should NEVER be purgable <41>
; title rect is already in TempRect
bsr SaveDemBits ; get the bits behind the title rect
move lastMenu(a3), d0 ; get last regular menu
addq #6, d0 ; offset to HMenu header info
move.l SavedHandle, menuTitleSave(a3,d0.w) ; store new handle
clr.l SavedHandle ; clear out lomem
move.w #1, SelectFlag(a6) ; set select flag <FJL C175>
bsr DrawCommon ; use common code to draw
rts
;-----------------------------------------------
; Utility -- FlipBar
;-----------------------------------------------
; use the hilite color to flip the bar to be sure hiliting happens
FlipBar
tst.b onColorMachine(a6)
beq.s @DoInvert
bsr SaveCurrentColors ; save current colors in stackframe
bsr GetPixelDepth ; put the current pixel depth in the stack frame
cmpi.w #2, PixelDepth(a6) ; is this 2+ mode, and color ?
blt.s @DoInvert ; no, its 1 bit mode, so don't set color
subq #4, sp ; save space for result
clr.l -(sp) ; ID=0, Item=0 ===> menubar entry
_GetMCEntry ; get the color entry
move.l (sp)+, d0 ; get the result, and set z-flag if necessary
beq.s @DoDefault ; zero ===> no entry so use default
; we got a menu bar entry from the color table, so use it to color the menu bar
move.l d0, a0 ; get ptr to color entry in a0
pea mctRGB1(a0) ; push fore color
pea mctRGB4(a0) ; push back color
bra.s @DoColorSet
@DoDefault ; default is always black on white
pea RGBBlack
pea RGBWhite
@DoColorSet _RGBBackColor
_HiliteColor
bclr #HiliteBit, HiliteMode ; set hilite bit so uses hilite color
@DoInvert ; finally we can invert the dang thing
; Set clip to intersection of screen's round rect and menu bar rect
subq #4, sp ; alloc space for rgn handle
_NewRgn ; alloc and leave on the stack
_OpenRgn ; create rgn containing rounded screen
pea portRect(a2) ; push portRect
BTST #7,onLCDMac(A6) ; is this Harpo <DAF 10Feb89><v1.3>
BZ.S @2 ; if not, then skip this <DAF 10Feb89>
_FrameRect
BRA.S @3
@2 move.l #ScreenRadius, -(sp) ; push rounding factor
_FrameRoundRect
@3 move.l (sp), -(sp) ; push rgn handle
_CloseRgn ; close and rgn on the stack
move.l (sp), -(sp) ; srcA is rounded screen
move.l clipRgn(a2), -(sp) ; srcB is currently set to menu bar rect
move.l clipRgn(a2), -(sp) ; dest is same as srcB
_SectRgn ; do intersect
_DisposRgn ; rgn is on the stack
PEA portRect(A2) ; push screen bounds rect
_InverRect
bsr ResetPreviousColors ; and restore colors before leaving
BRA DoneHilite
;-----------------------------------------------
; Utility -- GetTitleRect
;-----------------------------------------------
;
; GetTitleRect is a utility that returns the adjusted bounding rect of the
; title whose menu title number is in the lo half of D0.
; The resultant rect is returned in TempRect. For titles, the rect is
; not the full bounds of the title, but the portion that is modified
; by hilite. If the requested title is 0, then the entire menu bar rect is
; returned including the topmost and bottommost lines.
;
; use portRect instead of assuming topLeft is (0,0) <FJL CXXX>
GetTitleRect
TST.W D0 ; superflous test, but just to be safe
BEQ WholeBar ; if 0, then return entire MBar rect
LEA TEMPRECT,A0 ; get address of the rectangle
move portRect+Top(a2), (a0) ; get top of menubar <FJL CXXX>
addq #1,(A0)+ ; top is one <FJL CXXX>
MOVE MENULEFT(A3,D0),(A0) ; left is menuLeft[index]
move portRect+Left(a2), d1 ; <FJL CXXX>
add d1, (a0) ; offset from portRect properly <FJL CXXX>
SUBQ #1,(A0)+ ; really want left-1
move portRect+Top(a2), (a0) ; get top of menu bar <FJL CXXX>
move MBarHeight, d1 ; <FJL CXXX>
add d1,(A0) ; bottom = top + mbarheight <FJL CXXX>
SUBQ #1,(A0)+ ; need bottom-1
; _DMSG 'Welcome to GetTitleRect'
move portRect+Left(a2), (a0) ; set up for menu right <FJL CXXX>
MOVE.L A0, -(SP) ; Save A0
MOVE.L menuOH(a3,d0), A0 ; get the menu handle
MOVE.L (A0), A0 ; handle -> ptr
CMP.W #-16384, menuID(A0) ; Is it a system menu?
MOVE.L (SP)+,A0 ; Restore A0
BGE.S @notSysMenu ; Wasn't a system menu
CMP LASTMENU(A3),D0 ; is it the last one?
BEQ.S @DoLastSysMenu ; The last one is a sys menu (use portRect.right)
MOVE.W menuLeft(a3,d0), d1 ; get the left of this menu
ADDQ #6,D0 ; bump to next slot
MOVE.W menuLeft(a3,d0), d0 ; get the left of next menu
CMP.W lastRight(a3), d1 ; Is menu.left < lastRight?
BLT.S GTDone ; No, all or part is obscured
BRA.S @useD0 ; Otherwise use menu.right
@notSysMenu
MOVE.W D0, D1 ; Save off 6B0 target
BSR FindFirstSystemMenu6BO ; Get the 1st system menu
BNE.S @1 ; There are system menus, so prev is last
MOVE.W LASTMENU(A3), D0 ; DO the comparison against last
bra.s @2
@1
SUB.W #6, D0 ; Bump down the comparison
@2
EXG D0, D1 ; d0<=target d1<=6B0 of last reg menu
CMP D0, D1 ; is it the last regular menu?
BEQ.S @useLastRight ; The last one is a regular menu (use lastRight)
@notLast
move menuLeft(a3,d0), d1 ; get the left of this menu
ADDQ #6,D0 ; bump to next slot
move menuLeft(a3,d0), d0 ; get the left of next menu
cmp.w lastRight(a3), d1 ; Is menu.left > lastRight?
bgt.s GTDone ; Yes, the menu is into the last system menu
cmp.w lastRight(a3), d0 ; Is menu.right > lastRight?
ble.s @useD0 ; No, use menu.right else use lastRight
@useLastRight
move.w lastRight(a3), d0 ; use lastRight
bra.s @useD0
@DoLastSysMenu
move portRect+right(a2), d0 ; Get the right edge of the screen
sub.w #mbMenu1Loc, d0 ; symmetrical w/ apple menu
move D0, (A0) ; Slam the value
bra.s GTDone ; And we're outa here
@useD0
ADDQ #4,(A0) ; leave some margin on right
add d0,(A0) ; right is lastRight <FJL CXXX>
GTDone RTS ; return to caller
WholeBar
LEA TempRect,A0 ; get address of the rectangle
move portRect+Top(a2), (a0)+ ; top <FJL CXXX>
move portRect+Left(a2),(a0)+ ; left <FJL CXXX>
move portRect+Top(a2), (a0) ; bottom = top + mbarheight <FJL CXXX>
move MBarHeight, d1 ; <FJL CXXX>
add d1,(A0)+ ; <FJL CXXX>
MOVE.W PortRect+Right(A2),(A0) ; right is screen right
BRA.S GTDone ; all done...
;--------------------------------------------------------------------------------------------
;
; Msg #7 -- SaveBitsBar -- save bits behind menu, clear to proper color, and draw struct
;
;--------------------------------------------------------------------------------------------
;
; The SaveBitsBar call saves the bits in a pulldown's menuRect,
; then clears and frames the rect. It takes the menuIndex to act on in
; param. This code now stores the menu's menuRect and SavedHandle in the structure
; inited by the mbarproc (see InitBar msg above), and returns a pointer to the
; menuRect field in that structure.
SaveBitsBar
bsr FullClip ; set clip wide open <FJL C428>
BSR RemoveAnyBalloon ; remove any help balloons that are showing
; Copy the passed menu rectangle into the stackframe
move.l param2(a6), a0
lea menuRect(a6), a1
move.l Top(a0), Top(a1)
move.l Bottom(a0), Bottom(a1)
; Copy the menu's rectangle to TempRect, and expand it by 4 pixels so that we save the bits
; behind the structure too. SaveDemBits expects the expanded rect in TempRect.
LEA TEMPRECT,A0 ;point to the rectangle
LEA menuRect(A6),A1 ;get menuRect of current menu
MOVE.L A0,-(SP) ;push pointer to tempRect, too
MOVE.W Top(A1),Top(A0) ; copy menuRect into tempRect
ADDQ.W #3,Top(A0) ; save bottommost pixel in menu bar <FJL C222>
MOVE.W Left(A1),Left(A0) ; copy left
MOVE.L Bottom(A1),Bottom(A0) ; copy botRight,too
MOVE.L #$FFFCFFFC,-(SP) ; push -4,-4
_InsetRect ; expand saveRect by 4 pixels
moveq #1,d0 ; Allow these bits to be purgable <41>
bsr SaveDemBits ; save the bits into a bitmap or pixmap <FJL C222>
DrawStruct
SUBQ #2,SP ; make room for result
PEA menuRect(a6) ; push pointer to menuRect <S423 09Mar88 EMT>
_EmptyRect ; look for an empty menu
TST.B (SP)+ ; otherwise nothing will cast a shadow
BNE SaveBitsDone ; => and we wouldn't want that to happen
tst.b onColorMachine(a6)
beq.s @DoErase
move param1(a6), D0 ; get menuList offset from param1
MOVE.L menuOH(A3,D0),A1 ; get the menuData handle
move.l (a1), a4 ; get menu ptr in a4 for SetTitleColor
move #1, TitleBackFlag(a6) ; message that calling SetTitleColor from here
clr selectFlag(a6) ; drawing normal (unselected) object
bsr SetTitleColor ; set the proper background color
@DoErase lea menuRect(a6), a4 ; load address of menuRect into a4
move.l a4, -(sp) ; push pointer to menuRect
_EraseRect ; erase the menuRect
tst.b onColorMachine(a6)
beq.s @noColor
bsr ResetPreviousColors ; and reset the previous colors
@noColor
; paint the boundary and shadow -- first set up the pen
_PenNormal
move Left(a4), -(sp) ;
subq #1, (sp) ; want Left-1
move (sp), -(sp) ; push it again
move (sp), -(sp) ; and again
move Top(a4), -(sp) ;
_MoveTo ; MoveTo(Left-1, Top)
move Bottom(a4), -(sp) ; push
_LineTo ; LineTo(Left-1, Bottom)
move Right(a4), -(sp)
move Bottom(a4), -(sp)
_LineTo ; LineTo(Right, Bottom)
move Right(a4), -(sp)
move Top(a4), -(sp)
subq #1, (sp) ; want Top-1
_LineTo ; LineTo(Top-1, Right)
move Top(a4), -(sp)
subq #1, (sp) ; want Top-1
_LineTo ; LineTo(Left-1, Top-1)
; paint a drop shadow for the menu
MOVE.L #$00020002,-(SP) ;push shadow factor
_PenSize ;make penSize = shadow factor
MOVE RIGHT(A4),D0 ;get right of menuRect
MOVE D0,-(SP) ;push right
MOVE TOP(A4),-(SP) ;push top
ADD #2,(SP) ;want top+shadow
MOVE D0,-(SP) ;push right
MOVE BOTTOM(A4),D0 ;get bottom
MOVE D0,-(SP) ;push bottom
MOVE LEFT(A4),-(SP) ;push left
ADD #2,(SP) ;want left+shadow
MOVE D0,-(SP) ;push bottom
_MoveTo ;MoveTo(left+shadow,bottom)
_LineTo ;LineTo(right,bottom)
_LineTo ;LineTo(right,top+shadow)
_PenNormal ;restore normal pen
SaveBitsDone
; First need to calculate MenuDir in stackframe <FJL 03Mar87>
move #mbRightDir, MenuDir(a6) ; assume it went "right"
move.l mbSaveLoc, a0 ; get handle to mbarproc data storage
move.l (a0), a0 ; dereference
move lastMBSave(a0), d0 ; any menus saved yet?
beq.s @gotDir ; no ==> therefore store "right"
move mbRectSave+Left(a0,d0), d1 ; get left edge of previous menu
cmp menuRect+Left(a6), d1 ; left of prev. menu < current menu left?
blt.s @gotDir ; yes ==> menu went "right"
move #mbLeftDir, MenuDir(a6) ; no ==> menu went "left"
@gotDir
; Place the menuRect and SavedHandle in the mbar's structure. <FJL C222>
addi.w #mbEntrySize, lastMBSave(a0) ; update count of num menus on screen
move.w lastMBSave(a0), d0 ; get num menus
move.l menuRect(a6), mbRectSave(a0,d0.w) ; copy adjusted menuRect into save area
move.l menuRect+4(a6), mbRectSave+4(a0,d0.w)
move.l SavedHandle, mbBitsSave(a0,d0.w) ; copy handle to bits behind
move.w MenuDir(a6), mbMenuDir(a0,d0.w) ; copy menu direction
move.w Param1(a6), d1
move.w d1, mbMLOffset(a0,d0.w) ; copy menuList offset
move.l menuOH(a3,d1.w), mbMLHandle(a0,d0.w) ; copy menuList handle
RTS
;-----------------------------------------------
; Utility -- CalcMenuRect
;-----------------------------------------------
; Utility shared with msg #9 GetRect when the
; rect needs to calculated rather than just
; retrieved from the mbarproc data structure
CalcMenuRect
MOVE.L param2(A6),D0 ; get the param (6 byte offset into menuList)
move.w param2(a6), VMousePt(a6); store vertical mouse pt in stackframe <FJL C222>
; notice that it is move.w not move.l !!<FJL C222>
MOVE.L menuOH(A3,D0),A1 ; get the menuData handle
MOVE.W menuLeft(A3,D0),D3 ; get the menuLeft too
add portRect+Left(a2), d3 ; adjust for portRect <FJL CXXX>
MOVE.L (A1),A0 ; dereference it
TST.L MENUWIDTH(A0) ; is size valid?
BPL.S @SkipCalcSize ; yes, no need to recalc
MOVE.L A1,-(SP) ; save menu record handle <FJL C175>
MOVE.L A1,-(SP) ; push handle for calc
_CalcMenuSize ; get valid MENUWIDTH,MENUHEIGHT
MOVE.L (SP)+,A0 ; get handle to menuRecord again <FJL C175>
move.l (a0), a0 ; and get the pointer for MakeMRect <FJL C175>
@SkipCalcSize
BSR.s MakeMRect ; calc the MenuRect in stack frame
rts
;-----------------------------------------------
; Utility -- MakeMRect
;-----------------------------------------------
;
; MakeMRect is a utility which calculates the boundsRect for the menu whose
; menuLeft is in D3, and whose menuData pointer is in A0. It returns
; this rect in the stack frame. It trashes D0-D1/A1 and modifies D3.
;
; use portRect instead of assuming topLeft is (0,0) <FJL CXXX>
MakeMRect
; set up the menuRect -- first adjust menuLeft to ensure the menu stays on the screen
MOVE.W VMousePt(a6), d1 ; if != 0 ===> is a hierarchical menu <FJL C222>
BNE MakeHMRect ; branch if hierarchical menu <FJL C222>
MOVE.W #mbRightDir, MenuDir(a6); assume menu going right <FJL C222>
MOVE.W portRect+Top(a2), d1 ; get top of menubar <FJL CXXX>
add MBarHeight,D1 ; bottom = top + mbarheight <FJL CXXX>
MOVE.W D3,D0 ; get menuLeft in D0
ADD MENUWIDTH(A0),D0 ; get right edge
ADDQ #8,D0 ; leave a little margin
CMP PortRect+Right(A2),D0 ; compare with size of screen
BLE.S StoreRect ; if smaller, we're cool
; adjust menuLeft so the menu fits on the screen
MOVE.W #mbLeftDir, MenuDir(a6) ; change menu's direction <FJL C222>
; <11>
MOVE.W menuID(A0), D0 ; Get this menuID
CMP.W #-16384, D0 ; Is it a system menu ( < 16384 )
BLT.S @AdjustMenuForSystemLook
MOVE.W PortRect+Right(A2),D3 ; get right edge
SUBQ #8,D3 ; leave some margin
SUB MENUWIDTH(A0),D3 ; compute where left should be
BRA.S StoreRect
@AdjustMenuForSystemLook
; GetTitleRect writes into TempRect, so save off a copy first...
LEA TempRect, A1 ; Get TempRect
MOVE.L topLeft(A1), -(SP) ; Save topLeft
MOVE.L botRight(A1), -(SP) ; Save botRight
MOVE.L param2(A6), D0 ; Get the 6B0 into low word
MOVEM.L A0/D1, -(SP) ; Save off regs for a sec
BSR GetTitleRect ; Get the title rect into temprect
MOVEM.L (SP)+, A0/D1 ; Restore regs
MOVE.W right(A1), D3 ; Get the right edge of the title
SUB.W MENUWIDTH(A0),D3 ; compute where left should be
SUB.W #1,D3 ; the Pauline tweek <16>
MOVE.L (SP)+, botRight(A1) ; Restore botRight
MOVE.L (SP)+, topLeft(A1) ; Restore topLeft
CMP.W PortRect+Left(A2),D3 ; IF assumedLeft <= portRect.left THEN
BGT.S StoreRect ; Don't branch
MOVE.W PortRect+Left(A2),D3 ; Get a new left
ADD.W #4, D3 ; Add a slop factor
StoreRect
LEA MenuRect(A6),A1 ; get address of rectangle
MOVE.W D1,(A1)+ ; set up top of menuRect <EHB 5Aug85>
MOVE.W D3,(A1)+ ; set up menuLeft
ADD.W MENUHEIGHT(A0),D1 ; get height
MOVE.W D1,(A1)+ ; set up bottom
ADD.W MENUWIDTH(A0),D3 ; compute right of menuRect
MOVE.W D3,(A1) ; move in right point
RTS
;-----------------------------------------------
; Utility within a utility -- MakeHMRect
;-----------------------------------------------
;
; This is for a hierarchical menu, so do the following:
; 1. Make top line up with previous item unless menu hits bottom of the screen
; 2. Go same direction as last menu up
; 3. If hit edge of screen try to go in other direction
; 4. If hit edge of screen then give up and just plop it on the screen any old place
; On Entry: A0 ptr points to menuRecord for current menu
; d1 pt vertical mouse pt
;
MakeHMRect
; d1 has vertical mouse pt when we get here. Stabilize menu so top item lines up
; with selected item on previous menu. If menu is too long then move top up until
; either the bottom is 8 pixels above the bottom of the screen or top comes within
; 7 pixels of the menu bar.
movem.l d2-d5/a0-a3, -(sp) ; save work registers
move.l d1, d5 ; move vertical mouse pt into d5
bsr GetSizes ; get font info in stackframe
bsr GetA1SaveData ; get ptr to previous menu's data in a1
move mbTopScroll(a1), d2 ; get previous menu's top
move.l mbMLHandle(a1), a3 ; get previous menu's handle
moveq #1, d4 ; start with first item
@ItemLoop
move d4, d0 ; get item
bsr GetItemRecord ; look it up, put item's string ptr in a0,
; properties ptr in a1
bsr GetItemHeight ; get item height in d0
add d0, d2 ; d2 now has bottom of item
cmp d5, d2 ; is bottom of item below mouse pt ?
bgt.s @FoundItem ; yes, so we found the item
addq #1, d4 ; go to next item
bra.s @ItemLoop ; and try next item
@FoundItem
sub d0, d2 ; d2 now has top of item to line up with
move d2, d1 ; put it in d1 for rest of this routine
movem.l (sp)+, d2-d5/a0-a3 ; restore work registers
SUBQ.W #7, D1 ; move item top up 7 pixels (tune it!) <1.8>
MOVE.W portRect+top(A2), D0 ; menu bar height is relative <1.8>
ADD.W MBarHeight, D0 ; to top of portRect <1.8>
CMP.W D0, D1 ; compare with menu bar height <1.8>
bge.s @SetBottom ; if top not in menu bar then don't reset top
MOVE.W D0, D1 ; top is in menu bar <1.8>
@SetBottom
addq.w #7, d1 ; Move top down 7 pixels.
move d1, d0 ; get top in d0 temporarily
add.w menuHeight(a0), d0 ; find menu bottom
addi #12, d0 ; add 12 pixels so don't hit screen bottom exactly
cmp.w portRect+Bottom(a2), d0 ; compare it to the bottom of the screen
BLE.S @BottomOK ; if < or = to bottom then we are ok <1.8>
; menu extends beyond the bottom of the screen so recalc top
MOVEQ.L #-12, D0 ; move it up 12 pixels from screen bottom <1.8>
ADD.W portRect+Bottom(a2), d0 ; get screen bottom <1.8>
sub.w menuHeight(a0), d0 ; d0 now has correct height
move d0, d1 ; put it in back in d1
@BottomOK
; now calculate left, right and bottom
bsr GetA1SaveData ; get ptr to previous menu's data in a1
move.w mbMenuDir(a1), MenuDir(a6) ; assume direction of last menu
cmpi.w #mbLeftDir, MenuDir(a6) ; if going left then branch
beq.s @MenuToLeft
; menu going right. Menuleft starts 4 pixels in from previous menu's right hand edge.
@MenuToRight move.w mbRectSave+Right(a1), d0; get previous menu's right edge
subi.w #4, d0 ; overlap 4 pixels
move.w d0, d3 ; save location in d3 for StoreRect
add menuWidth(a0), d0 ; get right edge by adding menu's width
addq #8, d0 ; leave a little margin
cmp PortRect+Right(a2), d0 ; compare with size of screen
ble.s @DoneMakeH ; if smaller we're cool
; oops, menu needs to go left instead of right,
; menuRight starts 4 pixels from left edge of previous menu.
move.w #mbLeftDir, MenuDir(a6) ; change direction in stackframe
move.w mbRectSave+Left(a1), d0 ; get previous menu's left edge
sub menuWidth(a0), d0 ; shift left edge to the left where it should be
add.w #8, d0 ; overlap 8 pixels going left !!!
move.w d0, d3 ; save location in d3 for StoreRect
; one last check, if left edge of menu flops over left edge of screen then bring
; it back onto the screen
subq #8, d0 ; leave a little margin
cmp PortRect+Left(a2), d0 ; compare with size of screen
bge.s @DoneMakeH ; we're cool
move PortRect+Left(a2), d0 ; damn, we need to reset rect again
addq #8, d0 ; leave a little margin
move d0, d3 ; and put loc in d3 for StoreRect
move #mbRightDir, MenuDir(a6); change direction one last time
bra.s @DoneMakeH ; done...
; menu going left. MenuRight starts 8 pixels in from previous menu's left hand edge.
@MenuToLeft
move.w mbRectSave+Left(a1), d0 ; get previous menu's left edge
addi.w #8, d0 ; overlap 8 pixels going left
sub menuWidth(a0), d0 ; shift left edge to the left where it should be
move.w d0, d3 ; save location in d3 for StoreRect
subq #8, d0 ; leave a little margin
cmp PortRect+Left(a2), d0 ; compare with size of screen
bgt.s @DoneMakeH ; if smaller we're cool
; oops, menu needs to go right instead of left,
; menuRight starts 4 pixels from right edge of previous menu.
move.w #mbRightDir, MenuDir(a6); change direction in stackframe
move.w mbRectSave+Right(a1), d0; get previous menu's right edge
sub.w #4, d0 ; overlap 4 pixels
move.w d0, d3 ; save location in d3 for StoreRect
; one last check, if right edge of menu flops over right edge of screen then bring
; it back onto the screen
add.w menuWidth(a0), d0 ; get right edge of HMenu
addq #8, d0 ; leave a little margin
cmp PortRect+Right(a2), d0 ; compare with size of screen
ble.s @DoneMakeH ; we're cool
move PortRect+Right(a2), d0 ; damn, we need to reset rect again
sub menuWidth(a0), d0 ; move it in from right edge of screen
subq #8, d0 ; and a little more for good luck
move d0, d3 ; and put loc in d3 for StoreRect
move #mbLeftDir, MenuDir(a6) ; change direction one last time
@DoneMakeH
bra StoreRect ; and continue
;---------------------------------------
; Utility -- GetItemRecord <Taken from MDEF, FJL 12-29-86>
;---------------------------------------
; GetItemRecord is the main utility used for accessing the menu item data structure.
; It has a register interface to save code. On entry, A3 handles to a menuInfo block,
; while D0 has the item number of interest. On exit, A0 points to the item string
; of interest while A1 points to that item's attribute byte list. If the item can't
; be found, A0 and A1 both return NIL.
GetItemRecord
MOVE.L (A3),A0 ; get menu ptr <2.2>
TST.w D0 ; make sure item number is valid
BLE.S NOITEM ; if it's not, don't bother
MOVEQ #0,D1 ; clear D1 for byte arithmetic
LEA MENUDATA(A0),A1 ; get menuData handle
MOVE.B (A1)+,D1 ; get title length
ADD.w D1,A1 ; skip over title string
; here is the item search loop. A1 points to the beginning of the next item.
GetILoop
SUBQ #1,D0 ; is this the one we're looking for?
BEQ.S GOTITEM ; if so, we got it
MOVE.B (A1)+,D1 ; get length of current item
BEQ.S NOITEM ; length zero marks end of list
ADDQ #4,D1 ; there are 4 bytes of item properties
ADD.w D1,A1 ; bump to next item
BRA.S GETILOOP ; loop till done
; the item couldn't be found so return NIL
NoItem
SUB.L A0,A0 ; zero A0
MOVE.L A0,A1 ; and A1 too
Exit
MOVE.L A0,D0 ; and set the z-flag
RTS ; return to caller
; we found the item so return a pointer to it in A0 and a pointer to the item properties
; in A1
GotItem
TST.B (A1) ; is this the NIL item?
BEQ.S NOITEM ; if so, we really didn't get one
bsr.s ExpandItem ; puff item up to full size <2.1>
bra.s EXIT ; and leave
; ExpandItem. Take basic menu item data and fill in more with _GetAuxMenuItem.
; New in <2.1>.
; On entry: A1 points to a menu item
; A3 is the menu handle
;
; On exit: A0 points to the item string of interest
; A1 points to that item's attribute byte list (on the stack)
; Eats D0, D1
ExpandItem
; copy menu item attributes to stack, split into distinct fields (unroll the
; variant in itemCmd).
movem.l d2/a2,-(sp) ; save regs <2.2>
move.l a1,a2 ; move pointer to safe register
moveq #0,D1 ; clear D1 for byte arithmetic
move.b (a1)+,d1 ; get length
add d1,a1 ; bump to item properties
lea itemStackBase(a6),a0 ; address of working copy
; set defaults (one at a time, to avoid odd-address problems since string be any length)
move.b (a1)+,(a0)+ ; copy attribute byte
move.b (a1)+,(a0)+ ; copy attribute byte
move.b (a1)+,(a0)+ ; copy attribute byte
move.b (a1)+,(a0)+ ; copy attribute byte
clr.l (a0)+ ; set defaults
clr.l (a0)+ ; set defaults
clr.l (a0) ; set defaults
lea itemStackBase(a6),a0 ; address of working copy, again
; check for script code
moveq #0,d1 ; clear the air
move.b itemCmd(a0),d1 ; get record variant field
cmp.w #ScriptMenuCmd,d1 ; is there a script code?
bne.s notScripted ; jump if not
move.b itemIcon(a0),itemScript+1(a6) ; if scripted, icon has script number
clr.b itemIcon(a0) ; reset field to say "no icon"
bra.s doneConvert ; rejoin
; check for hierarchical item
notScripted
cmp.w #HMenuCmd,d1 ; hierarchical menu?
bne.s notHierarchical ; jump if not
move.b itemMark(a0),itemHierarchicalID+1(a6)
clr.b itemMark(a0) ; reset to say "no mark"
bra.s doneConvert ; rejoin
; check for icon and icon type
notHierarchical
cmp.w #ShrunkenIconCmd,d1 ; shrunken icon?
beq.s sizedIcon ; jump if so
cmp.w #SmallIconCmd,d1 ; small icon?
beq.s sizedIcon ; jump if so
tst.b itemIcon(a0) ; is there an icon?
beq.s getAuxdata ; jump if not
move.w #LargeIconCmd,itemIconSize(a6) ; save default icon type
bra.s getAuxData ; and continue (don't clear itemCmd!)
sizedIcon
move.w d1,itemIconSize(a6) ; copy type to proper field
doneConvert
clr.b itemCmd(a0) ; reset field to say "no command key"
getAuxData
subq.l #2,sp ; room for return result
move.l a3,-(sp) ; push menu handle
move.l a2,-(sp) ; push pointer to menu item
pea itemIconHandle(a6) ; push buffer address
move.l #Sizeof_auxdata,-(sp) ; push buffer size
_GetAuxMenuItem ; get the extra info
addq.l #2,sp ; dump result
move.l a2,a0 ; point at name (in list item)
lea itemStackBase(a6),a1 ; point at the (extended) attributes
tst.l itemIconHandle(a6) ; icon handle known now?
beq.s doneExpand ; jump if not
clr.b itemIcon(a1) ; nuke unneeded resource #
doneExpand
movem.l (sp)+,d2/a2 ; restore regs <2.2>
rts ; return to sender
;---------------------------------------
; Utility -- GetSizes <Taken from MDEF, FJL 12-29-86>
;---------------------------------------
; GetSizes reads the size of the current font into the stack frame. It puts
; ascent+descent+leading into the leading field and tweaks width for chicago
GetSizes LEA MInfoRec(A6),A2 ; point to our info rec <1Aug85>
MOVE.L A2,-(SP) ; push a pointer <1Aug85>
_GetFontInfo ; and get the font's info <1Aug85>
MOVE.W (A2)+,D0 ; get ascent <1Aug85>
ADD.W (A2)+,D0 ; add descent <1Aug85>
CMP.W #14,(A2) ; fudge width for chicago <1Aug85>
BNE.S @notChicago ; => not chicago <1Aug85>
SUBQ #2,(A2) ; <1Aug85>
@notChicago
ADDQ #2,A2 ; skip over widmax <1Aug85>
ADD.W D0,(A2) ; store total height in MFHeight(A6) <1Aug85>
RTS
;---------------------------------------
; Utility -- GetItemHeight <Taken from MDEF, FJL 12-29-86>
;---------------------------------------
; GetItemHeight gets the height of the current menu item into D0.
; The item pointer is in A1.
GetItemHeight
MOVE.W MFHeight(A6),D0 ; get menu item height <1Aug85>
TST.W itemIconSize(A6) ; does it have an icon? <2.2>
BEQ.S @gotHeight ; jump if not <2.2>
MOVE #34,D1 ; size of large icon <2.2>
CMP.W #LargeIconCmd,itemIconSize(a6) ; large icon? <2.2>
BEQ.S @isLarge ; jump if so <2.2>
MOVEQ #18,D1 ; else set to 18 <2.2>
@isLarge
CMP.W D0,D1 ; Is icon height > text height? <2.2>
BLT.S @gotHeight ; Nope, skip around <2.2>
MOVE.W D1,D0 ; Yes, use icon height instead <2.2>
@gotHeight
RTS
;-----------------------------------------------
; Utility -- SaveDemBits
;-----------------------------------------------
;
; Utility to create a bitmap or pixmap in which to save the bits in TempRect.
; Used by SaveBitsBar and HiliteMenu.
;
; On entry: TempRect has rectangle of bits to be saved.
; D0.b 1 if bits should be purgable, 0 if not <41>
;
; On exit: SavedHandle Has handle to bitmap or pixmap.
; If == 0 then couldn't alloc space.
SaveDemBits
subq #2,sp ; make room for error result
pea TempRect
move.b d0,-(sp) ; WITH purging <40><41>
pea SavedHandle
_SaveBits
tst.w (sp)+ ; ignore error
rts
;-----------------------------------------------
; Utility -- GetA0SaveData
;-----------------------------------------------
;
; utility to get pointer to last menu's save data in a0.
GetA0SaveData
move.l mbSaveLoc, a0 ; get handle to saved area
move.l (a0), a0 ; dereference
add.w lastMBSave(a0), a0 ; a0 points to last menu's data storage
rts
;-----------------------------------------------
; Utility -- GetA1SaveData
;-----------------------------------------------
;
; Utility to get pointer to last menu's save data (from mbarproc struct) into a1.
GetA1SaveData move.l mbSaveLoc, a1 ; get handle to saved area
move.l (a1), a1 ; dereference
add.w lastMBSave(a1), a1 ; a1 points to last menu's data storage
rts
;-----------------------------------------------
; Utility -- RemoveAnyBalloon
;-----------------------------------------------
RemoveAnyBalloon
SUBQ #2,SP ; room for Boolean
_HMGetBalloons ; what is the state of What Is? mode?
TST.B (SP)+
BEQ.S @noHelper
CLR.W -(SP) ; remove any balloons that are showing
_HMRemoveBalloon
TST (SP)+
@noHelper
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #8 -- Restore -- retore bits behind a menu
;
;--------------------------------------------------------------------------------------------
;
; This call restores the bits that were saved under a menu pulldown.
; If there was insufficient memory to save the bits, then an appropriate
; update event is posted. This call takes the menuIndex of the menu to be
; restored in parameter (this is only needed if data was not saved).
;
RestoreBitsBar
bsr FullClip ; set clip wide open
BSR.s RemoveAnyBalloon ; remove any help balloons that are showing
bsr.s GetA0SaveData ; get ptr to last menu's save data
subq #2, sp ; make room the result
move.l mbBitsSave(a0), -(sp) ; get handle to saved "bits-behind"
_RestoreBits
addq #2, sp ; ignore the result
; update number of menus on screen
move.l mbSaveLoc, a0 ; get handle
move.l (a0), a0 ; dereference
subi.w #mbEntrySize, lastMBSave(a0) ; one fewer menu showing on screen
RTS
;--------------------------------------------------------------------------------------------
;
; Msg #9 -- GetRect -- return a ptr to a menuRect and reset other data needed by multiple
; menus.
;
;--------------------------------------------------------------------------------------------
;
; This call returns a ptr to a menu's rectangle. The menuIndex (6 byte offset) is in
; the lo-word of of param. If it can't find the menuIndex, it calculates the menuRect.
;
; This routine is called by MenuSelect every time it loops thru. It needs to do this because
; if a HMenu was just displayed the last loop thru, then MenuSelect's menuRect will
; be incorrect.
;
; This routine is also called just before MrMacHook is called since MrMacHook needs the
; menu's rectangle and we normally don't have the rectangle until after the menu is drawn.
;
; This routine is now called by MenuSelect before executing the Save Msg. This way we
; isolate the calculation of the menu's rectangle from the code that save the bits and
; draws the menu structure. This allows PopUpMenuSelect to use the Save Msg.
GetRectBar
move.l Param2(a6), d0 ; get the param
move.l mbSaveLoc, a0 ; get handle to mbar's save data
move.l (a0), a0 ; dereference
move.w lastMBSave(a0), d1 ; are there any menus?
beq.s @MenuNotFound ; no, so go calculate size instead
@MenuLoop
cmp.w mbMLOffset(a0,d1), d0 ; did we find the menuID?
beq.s @MenuFound ; yes, so branch
subi #mbEntrySize, d1 ; move to next index
beq.s @MenuNotFound ; if at end of list then didn't find menu
bra.s @MenuLoop ; loop if more
@MenuFound
lea mbRectSave(a0,d1), a1 ; get address of rect
move.l a1, Result(a6) ; and return it as the Result
@RectBarDone
rts
@MenuNotFound
bsr CalcMenuRect ; calculate the menu rectangle since we couldn't
; find it in the mbarproc data structure
lea TempRect, a0 ; move rect into TempRect for result
lea menuRect(a6), a1
move.l (a1), (a0) ; move Top/Left
move.l 4(a1), 4(a0) ; move Bottom/Right
move.l a0, Result(a6) ; return address of TempRect
bra.s @RectBarDone
;--------------------------------------------------------------------------------------------
;
; Msg #10 -- SaveAlt -- save other data pertinent to the menu after it is drawn
;
;--------------------------------------------------------------------------------------------
;
; This message is called directly after the MDEF has drawn a menu. At that time the two
; scrolling globals topMenuItem and atMenuBottom are known.
;
; The reason the mbar proc saves these globals instead of having MenuSelect do it is because
; the mbarproc is already set up to save info about each menu (its rect, direction and offset)
; and so it is trivial to save two more words about each menu. The alternative would have
; been to have MenuSelect reproduce a lot of the code that the mbarproc has to manipulate this
; saved data.
SaveAltBar
move.l Param2(a6), d0 ; get the param
move.l mbSaveLoc, a0 ; get handle to mbar's save data
move.l (a0), a0 ; dereference
move.w lastMBSave(a0), d1 ; are there any menus?
beq.s @SaveAltBarDone ; no, so return
@MenuLoop
cmp.w mbMLOffset(a0,d1), d0 ; did we find the menuID?
beq.s @MenuFound ; yes, so branch
subi #mbEntrySize, d1 ; move to next index
beq.s @SaveAltBarDone ; if at end of list then didn't find menu
bra.s @MenuLoop ; loop if more
@MenuFound
move topMenuItem, mbTopScroll(a0,d1.w) ; save scrolling globals
move atMenuBottom, mbBotScroll(a0,d1.w)
@SaveAltBarDone
rts
;--------------------------------------------------------------------------------------------
;
; Msg #11 -- ResetScroll -- reset the scrolling globals for the given menu
;
;--------------------------------------------------------------------------------------------
;
; Reset the global variables topMenuItem and atMenuBottom.
;
; This routine is called by MenuSelect every time it loops thru. It needs to do this because
; if a HMenu was just displayed the last loop thru, then not only will MenuSelects menuRect
; be incorrect, but the two scrolling globals are reset by the MDEF when it is asked to
; draw the menu and these must be reset.
ResetScrollBar
move.l Param2(a6), d0 ; get the param
move.l mbSaveLoc, a0 ; get handle to mbar's save data
move.l (a0), a0 ; dereference
move.w lastMBSave(a0), d1 ; are there any menus?
beq.s @ResetBarDone ; no, so return
@MenuLoop
cmp.w mbMLOffset(a0,d1.w), d0 ; did we find the menuID?
beq.s @MenuFound ; yes, so branch
subi #mbEntrySize, d1 ; move to next index
beq.s @ResetBarDone ; if at end of list then didn't find menu
bra.s @MenuLoop ; loop if more
@MenuFound
move mbTopScroll(a0,d1.w), topMenuItem ; reset scrolling globals for this menu
move mbBotScroll(a0,d1.w), atMenuBottom
@ResetBarDone
rts
;--------------------------------------------------------------------------------------------
;
; Msg #12 -- GetMenuRgn -- return the menu bar's region
;
;--------------------------------------------------------------------------------------------
;
;
ReturnMenuRgn
move.l Param2(a6), -(sp) ; push the param on the stack
; use portRect instead of assuming topLeft is (0,0) <FJL CXXX>
move portRect+Left(a2), -(sp); left
move portRect+Top(a2), -(sp) ; top
move PortRect+Right(A2),-(SP); right
move portRect+Top(a2), -(sp) ; bottom = top + mBarHeight
move MBarHeight, d0
add d0, (sp)
_SetRecRgn ; clip to the menu bar
move.l Param2(a6), Result(a6) ; return handle passed in as the result
@ReturnRgnDone
rts
;--------------------------------------------------------------------------------------------
;
; Msg #13 -- MoveSIcon -- move small icon into title of apple menu
;
;--------------------------------------------------------------------------------------------
MoveSICNToAM MOVE.B #SICNInAppleMenu, D6 ; Entry for moving SICN to Apple Menu
BRA.S MoveIcon
MoveSICNToPM MOVE.B #SICNInApplicationMenu, D6 ; Entry for moving SICN to Application Menu
BRA.S MoveIcon
MoveICSToAM MOVE.B #ICSInAppleMenu, D6 ; Entry for moving icon suite to Apple Menu
BRA.S MoveIcon
MoveICSToPM MOVE.B #ICSInApplicationMenu, D6 ; Entry for moving icon suite to Application Menu
MoveIcon
CLR.L Result(A6) ; Return 0 on (possible) failures
MOVEQ #6, D3 ; 6 B.O. = 6 (first title)
CMP.W (A3), D3 ; Is it in the legal range?
BGT NoMoveS ; Skip if not
MOVE.W lastMenu(A3), D0 ; Get last regular menu
ADDQ.W #6, D0 ; Get to HMenu header
TST.L menuTitleSave(A3, D0) ; Is a title highlighted?
BNE NoMoveS ; Skip if so
BTST #1, D6 ; if Apple Menu
BNE.S @FindApplicationMenu
MOVE.L menuOH(A3, D3), A0 ; Get handle to first menu
MOVE.L (A0), A4 ; Get ptr to first menu
CMP.W #$0114, menuData(A4) ; if (menuData != apple sign)
BNE NoMoveS ; exit
BRA.S @MenuFound
@FindApplicationMenu ; else
bsr FindFirstSystemMenu6BO ; See whether we have a system menu <43>
beq NoMoveS ; if no system menu, exit <43>
move.l d0,d3 ; put 6BO into our offset (d3) <43>
@FindAppMenuLoop ; <43>
cmp.w lastMenu(a3),d3 ; Is current menu is in menulist <43>
bgt NoMoveS ; no => exit <43>
MOVE.L menuOH(A3, D3), A0 ; Is current menu the Application menu? <43>
MOVE.L (A0), A4
CMP.W #kApplicationMenuID, menuID(A4)
BEQ.S @MenuFound
ADDQ #6, D3 ; go to the next menu
BRA.S @FindAppMenuLoop ; end while
@MenuFound ; end if
_HLock ; lock the menuhandle
BSR ClipMBar ; Set clipRgn to menu bar
CLR.W SelectFlag(A6) ; Draw normal mode
CLR.W TitleBackFlag(A6)
BSR SetTitleColor ; Set the colors (also saves current colors)
MOVE.L D3, D0
BSR GetTitleRect
BSR.S CalcRightRectSize ; grow or shrink TempRect to 16x16
MOVE.W Param1(A6), D4 ; Get the scroll distance
BEQ.S @NoScroll ; Skip if no scroll
SUBQ.L #4, SP ; Make room for the Update Rgn
_NewRgn
MOVE.L (SP)+, D5
PEA TempRect ; theRect
MOVE.W D4, -(SP) ; dh = Param1
CLR.W -(SP) ; dv = 0
MOVE.L D5, -(SP) ; updateRgn
_ScrollRect ; Scroll it
MOVE.L D5, -(SP) ; rgn
_SetClip ; Clip to the updateRgn
MOVE.L D5, -(SP) ; rgn
_DisposRgn
BRA.S @ScrollDone
@NoScroll
PEA TempRect ; theRect
_EraseRect
@ScrollDone
; The IconState variable keeps track of where the current icon/title is. Currently it
; is interpreted to be the number of pixels left to shift in.
MOVE.L mbSaveLoc, A0 ; Get handle to save data
MOVE.L (A0), A0 ; Dereference it
MOVE.W mbIconState(A0), D5 ; Get the icon state
BGT.S @SameOld ; Still working on same icon
; A new icon is coming in. Reset the icon state to the title width
MOVE.W TempRect+right, D5 ; Width of title
SUB.W TempRect+left, D5 ; is width of TempRect
@SameOld
MOVE.W TempRect+left, D1 ; Pen normally based upon left edge of TempRect
TST.L Param2(A6) ; Using an icon?
BNE.S @anIcon ; Skip if so
MOVE.W menuLeft(A3, D3), D1 ; Menu title based upon menuleft[index]
ADD.W portRect+left(A2), D1 ; + portRect.left
ADDQ.W #8, D1 ; + 8
@anIcon
MOVE.W D4, D0 ; Get the shift distance
BLT.S @ShiftLeft
BGT.S @ShiftRight
; The icon/title is to be replaced in its entirety.
MOVEQ #0, D5 ; Set icon state to 0
BRA.S @ShiftCommon
@ShiftLeft
; The icon/title is moving left.
ADD.W D0, D5 ; Decrement the icon state (D0<0)
ADD.W D5, D1 ; Add it to pen
BRA.S @ShiftCommon
@ShiftRight
; The icon/title is moving right.
SUB.W D0, D5 ; Decrement the icon state (D0>0)
SUB.W D5, D1 ; Subtract it from pen
@ShiftCommon
MOVE.L clipRgn(A2), A0 ; Get the clip region
MOVE.L (A0), A0 ; Dereference it
MOVE.W D1, -(SP) ; x coordinate for pen
BSR GetMenuAscent ; Returns value in D4
MOVE.W D4, -(SP) ; y coordinate for pen
_MoveTo ; Set the pen location
TST.L param2(A6) ; Get the icon handle
BEQ.S @NoIcon ; Skip if none
MOVE.L #$FFF40000, appleRect+topLeft(A6) ; top = -12, left = 0
MOVE.L #$00040010, appleRect+botRight(A6) ; bottom = 4, right = 16
PEA appleRect(A6) ; theRect for OffsetRect
SUBQ.L #4, -(SP) ; Make room for pen
MOVE.L SP, -(SP) ; Point to it
_GetPen
_OffsetRect ; Offset icon's rect by pen position
BTST #0, D6
BEQ.S @IsaSICN
SUBQ #2, SP ; make room for result
PEA appleRect(a6) ; push the title rect
MOVE.W #atAbsoluteCenter, -(SP) ; No need to do centering since the rect is of the right size
MOVE.W #ttNone, -(SP) ; assume no transformation needed
MOVE.L param2(A6), -(SP) ; push the icon handle
_PlotIconSuite
ADDQ #2, SP ; dump the result
BRA.S MoveSDone
@IsaSICN
PEA appleRect(A6) ; theRect for PlotSIcon
MOVE.L param2(a6), -(SP) ; theSIcon for PlotSIcon
BSR.S PlotSIcon ; Plot it
BRA.S MoveSDone
@NoIcon
BSR DrawSimple ; Draw the regular title
MoveSDone
MOVEQ #0, D0 ; Assume same icon
MOVE.L mbSaveLoc, A0 ; Get handle to save data
MOVE.L (A0), A0 ; Dereference it
MOVE.W D5, mbIconState(A0) ; Save the icon state
BGT.S @SameIcon ; Skip if still positive
MOVEQ #-1, D0 ; Flag new icon needed
@SameIcon
MOVE.L D0, Result(A6) ; Return the result
BSR ResetPreviousColors ; Restore the colors
BSR FullClip ; Set the clipRgn back to full open
MOVE.L menuOH(A3, D3), A0 ; Get the menuHandle
_HUnlock ; Unlock it
NoMoveS
RTS
;--------------------------------------------------------------------------------------------
; PROCEDURE PlotSIcon(theRect: Rect; theIcon: SIconHandle)
PlotSIcon
LEA IconBitMap, A1 ; Get address of the icon mgr bitMap
MOVE.L 4(SP), D0 ; Get the icon handle
BEQ.S DoneIPlot ; If nil, don't plot
MOVE.L D0, A0 ; Get the Icon Handle in address reg
MOVE.L (A0), (A1)+ ; baseAddr = master pointer
MOVE.W #2, (A1)+ ; rowBytes = 2
CLR.L (A1)+ ; topLeft = 0, 0
MOVE.L #$00100010, (A1) ; botRight = 16, 16
MOVE.L 8(SP), D1 ; Get theRect
LEA IconBitMap, A1 ; Point A1 at the bitMap again
MOVE.L A1, -(SP) ; srcBits = iconBitMap
MOVE.L GrafGlobals(A5), A0
MOVE.L thePort(A0), A0
PEA portBits(A0) ; dstBits = portBits
PEA bounds(A1) ; srcRect = iconBitMap.bounds
MOVE.L D1, -(SP) ; dstRect = theRect
CLR.W -(SP) ; srcCopy
CLR.L -(SP) ; maskRgn = nil
_CopyBits
DoneIPlot
MOVE.L (SP)+, A0 ; Get return address
ADDQ.L #8, SP ; Strip parameters
JMP (A0) ; And return to caller
;--------------------------------------------------------------------------------------------
;
; Msg #14 -- GetTRect -- Return the title rect of the menu given in param2
;
;--------------------------------------------------------------------------------------------
;
; Return the rectangle enclosing the area specified.
; NOTE: This call depends entirely on the GetTitleRect routine to calculate the
; bounding rectangle for each menu. DonÕt change it without changing this.
; It also assumes lastRight is the right edge of the visible app menus.
;
; Param1 Result
; ------------- ------------------------------------------------------------------
; <pos> = 6 B.O. Return the title rect for that menu
; = 0 Return the rectangle enclosing the menu bar
; -1 Return the rectangle enclosing the system menus which are visible
; -2 Return the rectangle enclosing the apps menus which are visible
;
GetTRect
MOVE.L #0, result(A6) ; We always return zero
LEA TempRect, A1 ; Get the address of tempRect
MOVE.W param1(A6), D0 ; Which part of the menubar should we return?
BMI.S @specialRect ; Wants special rect information
CMP.W lastMenu(A3), D0 ; Is this a valid offset?
BGT.S @returnEmptyRect ; Bail if someone is trying to run us off the road
BSR GetTitleRect ; Puts the title rect into tempRect
@StuffFromTemp
MOVE.L param2(A6), A0 ; Get the address of the rectangle
MOVE.L (A1)+, (A0)+ ; Copy topLeft
MOVE.L (A1)+, (A0)+ ; Copy bottomRight
RTS
@specialRect
TST.W lastMenu(A3) ; Are there any menus?
BEQ.S @returnEmptyRect ; OH, NO! there are none!
ADDQ #1, D0 ; Is it -1 (App menu case) ?
BEQ.S @AppRect
ADDQ #1, D0 ; Is it -2 (System menu case) ?
BEQ.S @SystemRect
@returnEmptyRect
MOVEQ #0,D0 ; Get a zero
MOVE.L D0, topLeft(A1) ; Set topLeft(TempRect)
MOVE.L D0, botRight(A1) ; Set botRight(TempRect)
BRA.S @StuffFromTemp ; Return that empty rect
@SystemRect
MOVEQ #0, D0 ; Clear out high word
BSR FindFirstSystemMenu6BO ; Find the first system menu
BEQ.S @returnEmptyRect ; Equal if no system menus
@nextSysLoop
MOVE.L D0, -(SP) ; Save across GetTitleRect call
BSR GetTitleRect ; Get its title rect (left >= right if obscured)
MOVE.L (SP)+, D0 ; Restore it
MOVE.W left(A1), D1 ; Get the left side
CMP.W right(A1), D1 ; IF left < right THEN {empty}
BLT.S @foundVisSys ; found 1st visible system menu
ADDQ #6, D0
CMP.W lastMenu(A3), D0 ; IF D0 <= lastMenu THEN
BLE.S @nextSysLoop ; goto nextSysLoop
BRA.S @returnEmptyRect ; We should never get here since the last system menu
; was never supposed to be obscured (BUT...)
@foundVisSys
MOVE.W left(A1), -(SP) ; Save the left side of visible system area
MOVE.W lastMenu(A3), D0 ; Get the last menu 6 B.O.
BSR GetTitleRect ; Get its title rect
MOVE.W (SP)+, D0 ; Restore first vis menu.left from stack
MOVE.W D0, left(A1) ; Force in the new left side
BRA.S @StuffFromTemp ; And return this rect
@AppRect
MOVEQ #6, D0 ; Get the 1st menu 6 B.O.
BSR GetTitleRect ; Get its title rect
MOVE.W lastRight(A3), D0 ; Get the last right
MOVE.W D0, right(A1) ; Stuff right with lastRight
BRA.S @StuffFromTemp ; And return this rect
;--------------------------------------------------------------------------------------------
;
; Msg #15 -- BannerMsg -- Draw the given string in the given script in the menubar
;
;--------------------------------------------------------------------------------------------
;
; Erase the menu bar area and TextBox in the given string in the menu bar.
;
; Param1 Param2
; -------------------------- -------------------------
; <special> ptr to pString none
; lo byte=scriptID
; hi byte=teJust for textbox
;
BannerMsg
moveq #0,a4 ; <49> Zero it out for the call to SetTitleColor
CLR.W -(SP) ; Unhilite any hilited menu
_HiliteMenu
MOVE.L param2(A6), -(SP) ; Save off the old parameter value before clearing
MOVE.L #-1, param2(A6) ; -1 is the clear indicator
BSR DrawBar ; Draw a cleared menubar
MOVE.L (SP)+, param2(A6) ; Restore the old parameter value
MOVE.W param1(A6), D0 ; Get param1
TST.B D0 ; Is it script?
BGE.S @noScript ; Nope
AND.W #$7F, D0 ; Mask out the junk
SUBQ #4, SP ; Make room for script result
MOVE.W D0, -(SP) ; Push script ID
MOVE.W #smScriptSysFondSize, -(SP)
_GetScript
_TextFont
_TextSize
@noScript
move.w #srcOr, -(sp) ; set text mode to srcOr
_TextMode
MOVEQ #0, D0 ; Zero get the entire menubar rect
BSR GetTitleRect ; Put rect into temprect
PEA TempRect ; Get the address of tempRect
MOVE.W #mbMenu1Loc, -(SP) ; This will be the horz inset
MOVE.W #1, -(SP)
_InsetRect ; TempRect has the TextBox rect
MOVEQ #0, D0 ; Clear all bytes
MOVE.W D0, SelectFlag(a6) ; clear select flag ==> draw normal mode
MOVE.W D0, TitleBackFlag(a6) ; calling SetTitleColor from DrawTitle
BSR SetTitleColor ; set color for title/background
;TextBox(p, size, r, style);
MOVE.W param1(A6), D1 ; Get param1
ASR #8, D1 ; Roll down to the teJust
MOVE.L param2(A6), A0 ; Get the stringPointer
MOVE.B (A0), D0 ; Copy the length byte
ADDQ #1, A0 ; Skip the length byte
MOVE.L A0, -(SP) ; Pointer to text
MOVE.L D0, -(SP) ; Length
PEA TempRect ; the rect address
MOVE.W D1, -(SP) ; the teJust
_TextBox
BSR ResetPreviousColors ; reset to original fore/back colors
RTS
;ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
END