|
| Volume Number: | 7 | |
| Issue Number: | 10 | |
| Column Tag: | Color Workshop |
Related Info: Menu Manager Memory Manager Color Quickdraw
Window Menu Bars Revisited 
By John A. Love, III, Springfield, VA, MacTutor Contributing Editor
Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.
[ John is a member of the Washington Apple Pi Users’ Group from the greater Washington D.C. metropolitan area and can be reached on AppleLink {D3471} and on GEnie {J.LOVE7} ... with very, very special thanks to Ben Cranston from the Programmers’ Special Interest Group of Washington Apple Pi for his brilliance and his extraordinary patience ... ]
This article builds on James Matthews’ work presented in MacTutor, Nov 1988. My significant additions include:
Color menus.
Hierarchical menus.
Multiple windows with the capability to place varying Window MenuBars (WMB) in different windows.
Zooming and growable windows that allow the user to scroll the Window MenuBars horizontally by clicking on my horizontal Menu Scroll Activators (MSA).
By the way, you’ll notice that the above is a THINK Pascal Project, using version 3.Ø.2 and the appropriate Interface files and Libraries provided on the System 7 CD-ROM. Yes...my application is not only System 7 “compatible”, but System 7 “friendly”...but more on this later.
There are two fundamental sets of PROCEDUREs and FUNCTIONs that are mandatory:
• Some of Skippy White’s Off-Screen Map routines that were originally presented by MacDTS on CD-ROM. The ones I use are modified to address off-screen BitMaps/PixMaps rather than off-screen Devices. I presented my modifications in MacTutor, Nov 1990, “Spiffy Color Demo, Part I”. I am re-running them below because:
a) They really ought to serve as a programming standard and, therefore, are worth repeating.
b) I now use the FUNCTION CreateOffScreen to return a OffScreenRecHdl since I draw the window’s WMB in the associated off-screen Port & subsequently blit the Port’s bitMap/pixMap back to the screen using CopyBits. Since each window can have a different WMB, each window can have a different OffScreenRecHdl for blitting back upon the occurrence of Update and Activate Events. I originally implemented this logic so I could have these OffScreenRec handles hang around even when said window had been de-activated or dragged partly beyond the physical edge of the screen or dragged to a secondary monitor. However, I then decided to dispose of these handles immediately following the blitting back to screen ... otherwise, I would then have to periodically test, for example, if any of this dragging had occured and, if so, re-create all these off-screen Maps anyway.
• James Matthews’ routines such as wInsertMenu and wDrawMenuBar. I will attempt to lead you readers through the logic with particular emphasis on color and hierarchical Menus.
One note of caution ... I will not be presenting alot of the conventional parts of the code, for example the GetNextEvent/WaitNextEvent loop, the cursor-changing PROC etc. The entire THINK Pascal Project, Pascal source code and SARez source( w/included resources) consumes a tad over 600K which Kirk Chase will gladly sell you for a mere pittance.
Before the drum roll ends, I will also be talking about snipits of code that are just plain spiffy. For example, how do you retrieve a window’s window type ... before you generate a wrong answer such as a simple call to GetWVariant, watch out ... the variation codes of several rDocProc types duplicate those of several standard types. So, stay tuned ...
First in line is a complete listing of all external routines USEd by each Pascal UNIT ... the big picture, so-to-speak. I will amplify only on a few of them, those that are crucial to my off-screen BitMap/PixMap gymnastics as well as to Window MenuBars.
{1}
UNIT wBMMiscSubs;
INTERFACE
USES
Types, Quickdraw, Menus, TextEdit, Traps, Sound, wBMGlobals;
PROCEDURE InitManagers;
FUNCTION TestForColor (VAR pixelDepth: INTEGER): BOOLEAN;
PROCEDURE LocalGlobal (VAR r: Rect);
PROCEDURE GlobalLocal (VAR r: Rect);
FUNCTION TrapIsAvailable (theTrap: INTEGER): BOOLEAN;
FUNCTION WNEisImplemented: BOOLEAN;
PROCEDURE PlaySound (mySound: Str255);
FUNCTION GetStripAddressMask: LONGINT;
FUNCTION QuickStrip (myPtr: Ptr): Ptr;
FUNCTION GetMouseMovement (gMouse0: Point): Size;
FUNCTION DoubleClick: BOOLEAN;
PROCEDURE DimRgn (rgn: RgnHandle);
FUNCTION Max (a, b: INTEGER): INTEGER;
FUNCTION Min (a, b: INTEGER): INTEGER;
FUNCTION GetWindowPartColor (window: WindowPtr; part: INTEGER; VAR
color: RGBColor): BOOLEAN;
UNIT OffscreenSubs;
INTERFACE
USES
Quickdraw, wBMInterface, wBMGlobals, wBMMiscSubs;
FUNCTION GetMaxAreaDevice (globalRect: Rect): GDHandle;
FUNCTION CreateOffScreen (VAR myRect: Rect): OffScreenRecHdl;
PROCEDURE ToOnScreen (COSHdl: OffScreenRecHdl);
PROCEDURE DisposOffScreen (VAR COSHdl: OffScreenRecHdl);
UNIT wBMScrollSubs;
INTERFACE
USES
Quickdraw, wBMGlobals, wBMMiscSubs;
FUNCTION ScrollHoriz (wp: WindowPtr): ControlHandle;
FUNCTION ScrollVert (wp: WindowPtr): ControlHandle;
PROCEDURE ScrollShow (wp: WindowPtr);
PROCEDURE ScrollHide (wp: WindowPtr);
PROCEDURE InvalidScroll (wp: WindowPtr);
PROCEDURE ValidScroll (wp: WindowPtr);
PROCEDURE ScrollResize (wp: WindowPtr);
FUNCTION GetWindowType (window: WindowPtr): INTEGER;
UNIT wBarMenuProc;
INTERFACE
USES
Quickdraw, wBMInterface, wBMGlobals, wBMMiscSubs, OffScreenSubs, wBMScrollSubs;
FUNCTION wInitMenus: wMenuBarListHdl;
FUNCTION wGetNewMBar (wp: WindowPtr; wMenuBarID: INTEGER): wMenuBarHandle;
FUNCTION wGetMenuBar (wp: WindowPtr): wMenuBarHandle;
PROCEDURE wSetMenuBar (theMenuBar: wMenuBarHandle; wp: WindowPtr);
PROCEDURE wAddWMB (theMenuBar: wMenuBarHandle);
PROCEDURE wDeleteWMB (wp: WindowPtr);
PROCEDURE wClearMenuBarList (theMenuBarList: wMenuBarListHdl);
PROCEDURE wInsertMenu (theMenuBar: wMenuBarHandle; theMenu: MenuHandle;
beforeID: INTEGER);
PROCEDURE wDeleteMenu (theMenuBar: wMenuBarHandle; menuID: INTEGER);
PROCEDURE GetWBMrects (wp: WindowPtr; VAR WBMrect, leftMSArect, rightMSArect:
Rect);
{ only local: }
{ PROCEDURE wSetColorMenu (menusID, itemsID: INTEGER); }
PROCEDURE wDrawMenuBar (theMenuBar: wMenuBarHandle);
PROCEDURE wScrollMenuBar (theMenuBar: wMenuBarHandle);
PROCEDURE wGetMSA (theMenuBar: wMenuBarHandle);
PROCEDURE wDrawMSA (theMenuBar: wMenuBarHandle);
PROCEDURE wClearMenuBar (theMenuBar: wMenuBarHandle);
FUNCTION wMenuSelect (theMenuBar: wMenuBarHandle; startPt: Point): LONGINT;
FUNCTION wMenuKey (theMenuBar: wMenuBarHandle; ch: char): LONGINT;
PROCEDURE wHiliteMenu (theMenuBar: wMenuBarHandle; menuID: INTEGER);
PROCEDURE wChangeMenuBarSize (wp: WindowPtr; zooming: BOOLEAN);
UNIT wBMWindSubs;
INTERFACE
USES
Quickdraw, Palettes, wBMInterface, wBMGlobals, wBMMiscSubs, wBMScrollSubs,
wBarMenuProc, wBMBalloons;
FUNCTION InitWindowStorage: allWSHdl;
PROCEDURE CalcWindowRect (window: WindowPtr; VAR r: Rect);
PROCEDURE DisplayWindow (window: WindowPtr; TLPR: Point);
FUNCTION DoNewWindow (windowID, wMBARID: INTEGER; VAR offset: Point):
BOOLEAN;
PROCEDURE CloseOurWindow (window: WindowPtr);
PROCEDURE DoCloseAll;
Next is my complete wBMGlobals.p file. I wouldn’t even bother with it except for the RECORD types that serve as the chief worker-bees for off-screen BitMaps/PixMaps, WMBs and multiple windows.
{2}
UNIT wBMGlobals;
INTERFACE
{ ------------------------------------------ }
{ Global constants: }
{ ------------------------------------------ }
CONST
{ General constant: }
Enter = 3;
ohFudge = 1; { Guess what ????? }
{ low-memory global: }
ROM85Loc = $28E;
{ Specific constants ... }
{ Stuff for main Menu ... }
kMBarDisplayed = 128;
mainMBARID = kMBarDisplayed;
AppleMenuID = 1;
AboutItem = 1;
AdisabledItem = 2;
{ ---- }
FileMenuID = 2;
NewWindowItem = 1;
CloseWindowItem = 2;
FdisabledItem = 3;
QuitItem = 4;
{ ---- }
EditMenuID = 3;
UndoItem = 1;
EdisabledItem = 2;
CutItem = 3;
CopyItem = 4;
PasteItem = 5;
ClearItem = 6;
{ Stuff for Window Menu ... }
kMBarNotDisplayed = 129;
wMBARID = kMBarNotDisplayed;
wAppleMenuID = 1001;
wAboutItem = 1;
wAdisabledItem = 2;
{ ---- }
wFileMenuID = 1002;
wNewWindowItem = 1;
wCloseWindowItem = 2;
wFdisabledItem = 3;
wQuitItem = 4;
{ ---- }
wEditMenuID = 1003;
wUndoItem = 1;
wEdisabledItem = 2;
wCutItem = 3;
wCopyItem = 4;
wPasteItem = 5;
wClearItem = 6;
{ -------------------------------------------- }
{ Hierarchical Menus ... }
{ -------------------------------------------- }
wNewHierMenuID = 104;
wNewHierItem = 1;
wCloseHierMenuID = 105;
wCloseHierItem = 1;
wHierHierMenuID = 106;
wHierHierItem = 1;
{ Window goodies ... }
maxWindows = 20; { A # subject only to memory. }
kDefaultWindowID = 1001;
mainWindowID = kDefaultWindowID;
newWindowID = mainWindowID + 1;
frame = 1; { Window parts in Pixels ... }
shadow = 1;
title = 18;
horizScrollID = 128;
vertScrollID = 129;
scrollWidth = 16;
scrollHeight = scrollWidth;
growBoxSize = scrollWidth - frame;
{ Miscellaneous stuff ... }
logoID = 131;
{ --------------------------------------------------------------------------------------------------------------
}
{ ... for Error handling in my Off-screen map routine(s): }
{ --------------------------------------------------------------------------------------------------------------
}
NewCOSHdlError = -10000;
MaxDevError = -15000;
NewBaseAddrPtrError = -20000;
CloneHdlError = -25000;
{ ------------------------------------ }
{ MultiFinder stuff: }
{ ------------------------------------ }
{ _WaitNextEvent = $A860; -- in new “Traps.p” interface }
{ _Unimplemented = $A89F; }
SysEnvironsVersion = 1;
{ OSEvent is the event number of the suspend/resume and }
{ mouse-moved Events sent by MultiFinder. Once you }
{ determine that an event is an OSEvent, look at the }
{ High byte of the message sent with the event to }
{ determine which kind it is. To differentiate between }
{ suspend & resume, look at the resumeMask bit. }
OSEvent = app4Evt;
suspendResumeMessage = 1;
mouseMovedMessage = $FA;
resumeMask = 1;
{ ------------------------------------------------------------------
}
{ ... for Window Menu Bar routines: }
{ ------------------------------------------------------------------
}
noneHilited = -1; { Stored in “wMenuBar.hilited” }
{ if nada. }
menuTitleBit = 31; { Offset for Menu title bit in }
{ “enableFlags”. }
flashDelay = 10; { For blinking Menu title }
{ and Menu item. }
normalSize = 12; { Radius FPD stuff ... }
chicago16 = 16; { Special FONT. }
dontScrollMenu = 0; { Pass to wDrawMenuBar }
{ if appropriate. }
atEnd = 0; { ... as in InsertMenu(MenuHdl, 0); }
noMBARrsrc = -1; { There ‘aint’ any ... }
mceMenuBar = 0; { mctID & mctItem for }
{ color Menus ... }
mceMenuTitle = 0;
zooming = TRUE;
regMenu = 0; { NOT a Hierarchical Menu. }
mainMenu = 0; { NO parent Menu. }
{ ------------------------------------------ }
{ Global types: }
{ ------------------------------------------ }
TYPE
{ General stuff: }
RgnHandlePtr = ^RgnHandle;
wordPtr = ^INTEGER;
longPtr = ^LONGINT;
{ BitMapPtr = ^BitMap; -- in new “QuickDraw.p” interface }
{ The following is required to avoid calling }
{ _GetNewWindow with NIL as the “wStroage” }
{ parameter. Otherwise, we risk fragmenting }
{ the Application Heap. }
{ }
{ [Adapted from Dan Weston’s Assembly Code] }
oneWStorage = RECORD
inUse: BOOLEAN;
fill: BOOLEAN;
ws: WindowRecord;
END;
allWStorage = RECORD
ones: ARRAY[1..maxWindows] OF oneWStorage;
END;
allWSPtr = ^allWStorage;
allWSHdl = ^allWSPtr;
{ Off Screen stuff: }
OffScreenRec = RECORD
CreateOffScreenError: OSErr;
oldDevice: GDHandle;
origPort: GrafPtr;
drawingRect: Rect;
myMaxDevice: GDHandle;
myBits: Handle;
offGrafPort: GrafPort;
offGrafPtr: GrafPtr;
offCGrafPort: CGrafPort;
offCGrafPtr: CGrafPtr;
ourCTHandle: CTabHandle;
offBitMapPtr, onScreenBitsPtr: BitMapPtr;
END;
OffScreenRecPtr = ^OffScreenRec;
OffScreenRecHdl = ^OffScreenRecPtr;
{ ... for Window Menus: }
wMenuRec = RECORD
mh: MenuHandle;
menuType: INTEGER; { Regular or Hierarchical. }
parentID: INTEGER; { Hierarchical stuff ... }
menuParentRgn, cumParentRgn: RgnHandle;
titleRect: Rect;
MenuDownOSHdl: OffScreenRecHdl;
END;
wMenuBar = RECORD
numMenus: INTEGER;
barLength: INTEGER;
titleHilited: INTEGER; { Menu # or “noneHilited”. }
leftScrollPoly, rightScrollPoly: PolyHandle;
{ ... to Menu Scroll Activators (MSA). }
saveCumScrollMenuX: INTEGER;
barOSHdl: OffScreenRecHdl;
wp: WindowPtr;
wMCTable: MCTableHandle;
wMenus: ARRAY[0..0] OF wMenuRec;
END;
wMenuBarPtr = ^wMenuBar;
wMenuBarHandle = ^wMenuBarPtr;
{ ---------- }
wMenuBarList = RECORD
numWindows: INTEGER;
wMBars: ARRAY[0..0] OF wMenuBarHandle;
END;
wMenuBarListPtr = ^wMenuBarList;
wMenuBarListHdl = ^wMenuBarListPtr;
aDynamicBalloon = RECORD { ... for my NEW dynamic windows. }
dynamicStrID: INTEGER;
dynamicStrIndex: INTEGER;
dynamicR: Rect;
END;
{ The BIG guys: }
RadBWStatus = PACKED RECORD
{ For Internal use, ONLY !! }
Signature, CPFlags, SSDelay, VertOffset: Char;
LargeFontEn, PluggedIn: Char; { PluggedIn = DontRepos }
MacBits: BitMapPtr;
BigTicksPtr: Ptr;
BigTicks: LONGINT;
Reserved1: LONGINT;
TopBigRAM, IdleHook: Ptr;
Reserved2: LONGINT;
CursorHook: Ptr;
END;
RadBWStatPtr = ^RadBWStatus;
RadBWStatHdl = ^RadBWStatPtr;
{ ---------- }
RadIIStatus = PACKED RECORD
AutoCenter, AutoLower, TearOffMenus, ScreenDump: Char;
LargeMenus, ScreenSaver, SaverActive, Reserved: Char;
ScreenSaverDelay, InitVers: INTEGER;
CardID: PACKED ARRAY[0..5] OF Char;
ROMVers: PACKED ARRAY[0..5] OF INTEGER;
END;
RadIIStatPtr = ^RadIIStatus;
RadIIStatHdl = ^RadIIStatPtr;
{ ---------- }
PivotDataStruct = PACKED RECORD
flipped, command, dLogFlags, xInternal, topOffset, bottomOffset:
Char;
tileFactor: INTEGER;
reserved: PACKED ARRAY[0..4] OF Char;
movementFlags: Char;
parameter, result: LONGINT;
resultRect: Rect;
END;
PivotDSPtr = ^PivotDataStruct;
PivotDSHand = ^PivotDSPtr;
{ ---------- }
radiusType = (none, radBW, radII);
RadiusData = RECORD
PivotHdl: PivotDSHand;
CASE radType : radiusType OF
none: (
);
radBW: (
BWHdl: RadBWStatHdl;
);
radII: (
IIHdl: RadIIStatHdl;
);
END;
RadiusDataPtr = ^RadiusData;
RadiusDataHdl = ^RadiusDataPtr;
{ -------------------------------------- }
{ Global variables: }
{ -------------------------------------- }
VAR
{ ... for Main PROGRAM: }
gStripAddressMask: LONGINT;
oldPort: GrafPtr;
lScreen, gScreen, visRect, updateRect: Rect;
ROM: wordPtr;
mBarHt: INTEGER;
AppleMenu, FileMenu, EditMenu: MenuHandle;
aMac2, hasGrowIcon: BOOLEAN;
colorDepth: INTEGER;
TheWindow, FW: WindowPtr;
windowCount, newCount, windType: INTEGER;
windowStorage: allWSHdl;
Event: EventRecord;
windowLoc: INTEGER;
ignore, moreNew, brandNew: BOOLEAN;
offset, deltaOffset: Point;
{ ... to avoid flickering Menu Bar: }
prevDA, prevWind, currDA, myAppl, applWind: BOOLEAN;
Done, InWindow, InWBMenu: BOOLEAN;
WNE, InForeGround: BOOLEAN;
Sleep, finalTicks: LONGINT;
ourControl: ControlHandle;
{ Window Menus ... }
pnState: PenState;
WBMrect, leftMSArect, rightMSArect, gWBMrect: Rect;
mbHState: SignedByte;
oldClip, onScreenRgn: RgnHandle;
oldForeColor, oldBackColor: RGBColor; { Color stuff ... }
oldMCTable, newMCTable: MCTableHandle;
found: BOOLEAN;
mBarList: wMenuBarListHdl;
mBar: wMenuBarHandle;
newBarListSize, newWMBSize: Size;
titleWidth, scrollPolyDXY: INTEGER;
{ Pixels between adjacent Menus & }
{ pixels to invert on each side }
{ of Menu title: }
betweenTitles, invertOverlap: INTEGER;
aboveBelowItem, menuFrame, menuShadow, frameShad: INTEGER;
whichMenu, whichItem: INTEGER;
{ Radius’ BIG screens ... }
WMgrPort: GrafPtr;
FPDRsrc: RadiusData;
BIGfont: Handle;
sizeFont: INTEGER;
{ System 7.0 ... }
startBalloons, balloonsUp, saveBalloons: BOOLEAN;
HelpMenu: MenuHandle;
origNumHelpItems: INTEGER;
dynamicBalloons: ARRAY[0..2] OF aDynamicBalloon;
lastBalloon: INTEGER;
IMPLEMENTATION
END. { UNIT = wBMGlobals }
Speaking of multiple windows and one of those snipits I promised you, the principal problem here centers on the fact that the majority of code I’ve seen repeatedly calls GetNewWindow, passing NIL as the wStorage Pointer. Bad news!!! The window record will be allocated as a non-relocatable object on the heap in which case you risk generating a fragmented heap. Dan Weston, in his positively super two-book set, The Complete Book of Macintosh Assembly Language Programming, passes a Pointer to the ws field of a oneWStorage RECORD and sets its inUse field. You see ... we’ve initialized a NewHandle to a allWStorage RECORD shortly after our call to InitManagers. This new handle contains, say, 20 oneWStorage RECORDs:
{3}
FUNCTION InitWindowStorage: allWSHdl;
{ Call this hummer after “InitManagers”. }
VAR
wsHdl: allWSHdl;
BEGIN
InitWindowStorage := NIL; { Worry-wart !! }
wsHdl := allWSHdl(NewClearHandle(SizeOf(allWStorage)));
IF MemError = noErr THEN
BEGIN
MoveHHi(Handle(wsHdl));
HLock(Handle(wsHdl));
;
windowCount := 0;
InitWindowStorage := wsHdl;
END; { IF noErr }
END; { InitWindowStorage }
Every time you call GetNewWindow, you scan these 20 and stop at the first
whose inUse = FALSE & set it to TRUE.
FUNCTION DoNewWindow (windowID, wMBARID: INTEGER; VAR offset: Point):
BOOLEAN;
{ IF NOT DoNewWindow( ) THEN }
{ OhOh; }
VAR
i: INTEGER;
FUNCTION FindWStorage (VAR index: INTEGER): BOOLEAN;
BEGIN
index := 1;
WITH windowStorage^^ DO
BEGIN
WHILE (index <= maxWindows) & ones[index].inUse DO
index := index + 1;
;
IF index <= maxWindows THEN
BEGIN
ones[index].inUse := TRUE;
FindWStorage := TRUE;
END
ELSE { no more windows allowed }
FindWStorage := FALSE;
END; { WITH }
END; { FindWStorage }
BEGIN{ DoNewWindow }
DoNewWindow := FALSE;
;
moreNew := moreNew & FindWStorage(i); { i is VARed. }
IF NOT moreNew THEN
EXIT(DoNewWindow);
IF aMac2 THEN
TheWindow := GetNewCWindow(windowID, @windowStorage^^.ones[i].ws,
WindowPtr(-1))
ELSE
TheWindow := GetNewWindow(windowID, @windowStorage^^.ones[i].ws, WindowPtr(-1));
;
IF TheWindow = NIL THEN
BEGIN
{ Reverse effect of FindWStorage: }
windowStorage^^.ones[i].inUse := FALSE;
EXIT(DoNewWindow);
END;
;
SetPort(TheWindow);
IF windowID = newWindowID THEN
BEGIN
ourControl := GetNewControl(horizScrollID, TheWindow);
ourControl := GetNewControl(vertScrollID, TheWindow);
END; { retrieve Scroll Bars }
{ oldOffset --> newOffset: }
offset := GetTLWindPortRect(TheWindow, offset);
mBar := wGetNewMBar(TheWindow, wMBARID);
IF mBar <> NIL THEN
wAddWMB(mBar);
ScrollResize(TheWindow); { Does nada if NO Scroll Bars. }
DisplayWindow(TheWindow, offset);
{ Since an Update Event draws the MSAs & the Window Menu, }
{ Bar we do NOT want these drawn by the DoActivate PROC: }
brandNew := TRUE;
DoNewWindow := TRUE;
;
windowCount := windowCount + 1;
moreNew := moreNew & (windowCount < maxWindows);
END; { DoNewWindow }
Every time you call CloseWindow, you scan the same 20 and stop when inUse = TRUE and WindowPtr = @oneWStorage.ws . At this point, of course, we reset the former to FALSE so that my DoNewWindow FUNCTION finds it available.
{4}
{ ---------------------------------------------- }
{ One at a time, folks !! }
{ ---------------------------------------------- }
PROCEDURE CloseOurWindow (window: WindowPtr);
VAR
myPic: PicHandle;
pal: PaletteHandle;
aux: BOOLEAN;
auxWind: AuxWinHndl;
The next snipit centers on my comparison of FrontWindow’s resultant WindowPtr with @oneWStorage.ws as I’ve already talked about..
PROBLEM-- oneWStorage is a field in a LOCKED allWStorage handle and, therefore, @oneWStorage.ws has its high bit set. Guess what ... FrontWindow’s WindowPtr has its high bit clear. I “borrowed” GetStripAddressMask and QuickStrip from Tech Note #213.
{5}
PROCEDURE DisposeWStorage (wp: WindowPtr);
VAR
i: INTEGER;
found: BOOLEAN;
wsHState: SignedByte;
BEGIN
found := FALSE;
{ oneWStorage dsec 0 }
{ inUse byte ; = 0 }
{ fill byte ; = 1 }
{ ws byte WindowSize ; = 2 }
{ dend }
{ ... }
{ move.l windowStorage,a0 }
{ move.l (a0),a4 ; Locked Master Ptr. }
{ lea ws(a4),a1 ; Bit #31 also set. }
{ cmpa.l wp,a1 ; wp = 8(a6) }
{ ... }
wsHState := HGetState(Handle(windowStorage));
windowStorage^ := allWSPtr(QuickStrip(Ptr(windowStorage^)));
WITH windowStorage^^ DO
BEGIN
FOR i := 1 TO maxWindows DO
IF ones[i].inUse THEN
IF wp = @ones[i].ws THEN
BEGIN
found := TRUE;
Leave;
END;
IF found THEN
ones[i].inUse := FALSE {Undo effect of FindWStorage.}
ELSE { should NOT happen !! }
;
END; { WITH }
;
{ We have NOT done anything to move memory, }
{ therefore _MoveHHi is NOT required. }
HSetState(Handle(windowStorage), wsHState);
END; { DisposeWStorage }
BEGIN { CloseOurWindow }
IF window = NIL THEN
EXIT(CloseOurWindow);
IF WindowPeek(window)^.windowKind < 0 THEN
CloseDeskAcc(WindowPeek(window)^.windowKind)
ELSE
BEGIN
IF aMac2 THEN
BEGIN
pal := GetPalette(window);
IF pal <> NIL THEN
DisposePalette(pal);
END; { IF aMac2 }
myPic := GetWindowPic(window);
IF myPic <> NIL THEN
BEGIN
HUnlock(Handle(myPic));
ReleaseResource(Handle(myPic));
END; { IF myPic <> NIL }
wDeleteWMB(window);
DisposeWStorage(window);
CloseWindow(window);
WITH offset DO
BEGIN
h := h - deltaOffset.h;
IF h < 0 THEN
h := 0;
v := v - deltaOffset.v;
IF v < 0 THEN
v := 0;
END; { WITH }
windowCount := windowCount - 1;
;
IF windowCount = 0 THEN
BEGIN
{ In case a lingering DA doesn’t properly }
{ handle its “doCursor” routine: }
InitCursor;
{ Wait till last is gone because all windows }
{ share a common Color Table. }
IF aMac2 THEN
BEGIN
aux := GetAuxWin(window, auxWind);
IF aux THEN
ReleaseResource(Handle(auxWind));
END; { IF aMac2 }
END; { IF no more windows }
moreNew := TRUE;
END; { NOT a Desk Accessory window }
END; { CloseOurWindow }
Then comes my OffScreenRec which doesn’t make sense until we see the code later on ... so cool it ...
Next comes the stuff for WMBs. The wMenuBarList consists of a window count and an array of wMenuBarHandles. Gotta have the count so we know how many handles. Each of these handles consists of:
a) menu count and associated array of individual wMenuRecs. Again, this count tells us how many.
b) barLength tells us if we’re clicking the Mouse on ANY active Menu. If so, then we call PtInRect for the titleRect of each wMenuRec to find out which Menu.
c) titleHilited enters with wHiliteMenu which is called as our MouseDown travels from Menu-to-Menu: un-Hilite the old titleRect and Hilite the new.
d) left & right PolyHandles, my MSAs for horizontal scrolling of the WMB. Click on one of these dudes to scroll. If we scroll part of a titleRect out of view, call FillPoly(polyH, black); when we scroll back into view, call FillPoly(polyH, white) followed by FramePoly(polyH).
e) gotta save the amount we’ve scrolled the WMB so when we zoom back in from just zooming out, we can re-scroll to where we were.
f) it’s the OffScreenRecHdl we scroll for instantaneous blitting on screen.
g) the MCTableHandle handles color ... natch !!
h) each wMenuRec basically is just a Menuhandle together with some added info:
1) the menuType determines the placement of the titleRect ... for a regular Menu, it’s in the main WMB and for a hierarchical Menu, it’s the rect of the parent item.
2) the parentID for a hierarchical Menu is recorded to help us determine which wMenus[i] we’re looking at.
3) the two RgnHandles play in the wMenuSelect FUNCTION as our MouseDown bounces between regular, hierarchical and even hierarchical-hierarchical Menus. We create another OffScreenREcHdl for the drawing of the pulled-down Menu. Because of hierarchical Menus, several of these off-screen beauties may exist simultaneously. So we’ve gotta keep track of these off-screen handles so we can correctly dispose of them when we veer off-course ... either to a different Menu entirely or to a different item, an item that does NOT have a sub-Menu. The above RgnHandles help us to do just that.
4) The drawing of the pulled-down Menus occurs within MenuDownOSHdl.
Finally, holding up the rear, the BIG guns from Radius ...
Another snipit enters in the UNIT wBMMiscSubs with InitManagers. Instead of calling MoreMasters 10 times or whatever number turns you on, check out Tech Note #53.
Now, my off-screen gymnastics without many comments since the routines are essentially repeated from one of my former articles:
{6}
UNIT OffscreenSubs;
INTERFACE
USES
wBMInterface, wBMGlobals, wBMMiscSubs;
FUNCTION GetMaxAreaDevice (globalRect: Rect): GDHandle;
FUNCTION CreateOffScreen (VAR myRect: Rect): OffScreenRecHdl;
PROCEDURE ToOnScreen (COSHdl: OffScreenRecHdl);
PROCEDURE DisposOffScreen (VAR COSHdl: OffScreenRecHdl);
{ ********** }
FUNCTION GetMaxAreaDevice (globalRect: Rect): GDHandle;
{ Find the greatest overlap device }
{ for the given global rectangle. }
VAR
area: LONGINT;
maxArea: LONGINT;
device: GDHandle;
intersection: Rect;
BEGIN
GetMaxAreaDevice := NIL;
;
maxArea := 0;
;
device := GetDeviceList;
WHILE device <> NIL DO
BEGIN
IF TestDeviceAttribute(device, screenDevice) THEN
IF TestDeviceAttribute(device, screenActive) THEN
IF SectRect(globalRect, device^^.gdRect, intersection) THEN
BEGIN
WITH intersection DO
area := LONGINT(right - left) * LONGINT(bottom - top);
IF area > maxArea THEN
BEGIN
GetMaxAreaDevice := device;
maxArea := area;
END; { IF area > maxArea }
END; { IF SectRect ... }
device := GetNextDevice(device);
END; { WHILE device <> NIL }
END; { GetMaxAreaDevice }
FUNCTION CreateOffScreen (VAR myRect: Rect): OffScreenRecHdl;
{ Reference: Tech Note #120 }
{ with special thanks to: }
{ Forrest Tanaka and }
{ Jon Zap of MacDTS }
{ }
{ NOTE: Local window coordinates are input, but local }
{ device coordinates are returned for drawing purposes. }
VAR
offRowBytes, sizeOfOff, tempSeed: LONGINT;
localRect, globRect: Rect;
i, maxDepth: INTEGER;
err: OSErr;
COSHdl: OffScreenRecHdl;
PROCEDURE ErrorOut (error: OSErr);
BEGIN
IF error = NewCOSHdlError THEN
CreateOffScreen := NIL
ELSE
BEGIN
COSHdl^^.CreateOffScreenError := error;
CreateOffScreen := COSHdl;
END;
EXIT(CreateOffScreen);
END; { ErrorOut }
BEGIN { CreateOffScreen }
COSHdl := OffScreenRecHdl(NewClearHandle(SizeOf(OffScreenRec)));
;
IF MemError <> noErr THEN
ErrorOut(NewCOSHdlError);
;
MoveHHi(Handle(COSHdl));
HLock(Handle(COSHdl)); { Lock this sucker down !! }
WITH COSHdl^^ DO
BEGIN
{ CreateOffScreenError := noErr; -- We hope !! }
GetPort(origPort); { Used by ToOnScreen. }
drawingRect := myRect; { Saved for use after }
{ call to ToOnScreen. }
globRect := myRect; { We’re about to switch }
{ the Port to off-screen: }
LocalGlobal(globRect);
IF NOT aMac2 THEN
BEGIN
offGrafPtr := @offGrafPort;
OpenPort(offGrafPtr);
maxDepth := 1;
END { ... a low-life machine }
ELSE
BEGIN
myMaxDevice := GetMaxDevice (globRect);
IF myMaxDevice = NIL THEN
ErrorOut(MaxDevError);
oldDevice := GetGDevice;
SetGDevice(myMaxDevice);
;
offCGrafPtr := @offCGrafPort; { Initialize this guy. }
OpenCPort(offCGrafPtr);
MoveHHi(Handle(offCGrafPtr^.portPixMap)); { Arrgh !! }
HLock(Handle(offCGrafPtr^.portPixMap));
maxDepth := offCGrafPtr^.portPixMap^^.pixelSize;
END; { ELSE: aMac2 }
{ CanNOT use my GlobalLocal PROC because we may have dragged }
{ our window to a secondary screen. “Global” here is with }
{ respect to the main screen and “Local” is with respect to }
{ the secondary screen. }
{ }
{ From Forrest Tanaka: }
{ When GetMaxDevice returns the secondary screen’s GDevice & }
{ we set that to the current GDevice, then OpenCPort creates }
{ a CGrafPort which has a portRect=GetMainDevice^^.gdPMap^^. }
{ bounds which is in the global coordinates for all the }
{ screens’ pixel images with a topLeft = (0,0). The new }
{ CGrafPort.portPixMap^^.bounds is in the local coordinates }
{ of the secondary screen with a topLeft = (0,-640), e.g. }
{ }
{ In effect, the port that OpenCPort gives you is NOT a }
{ port because the portRect pertains to the wrong screen. }
{ This means that calling GlobalLocal shifts the localRect }
{ waaaaay over somewhere ... BECAUSE the difference between }
{ the above portRect and portPixMap^^.bounds is SO large!!! }
localRect := globRect;
WITH screenBits.bounds DO
OffsetRect(localRect, left, top);
;
IF aMac2 THEN
BEGIN
RectRgn(offCGrafPort.visRgn, localRect)
offCGrafPort.portRect := localRect;
END
ELSE
BEGIN
RectRgn(offGrafPort.visRgn, localRect);
offGrafPort.portRect := localRect;
END;
WITH localRect DO
BEGIN
offRowBytes := (maxDepth * (right - left) + 15) DIV 16;
IF ODD(offRowBytes) THEN
offRowBytes := offRowBytes + 1;
offRowBytes := offRowBytes * 2;
sizeOfOff := LONGINT(bottom - top) * offRowBytes;
END; { WITH }
myBits := NewClearHandle(sizeOfOff);
IF MemError <> noErr THEN
ErrorOut(NewBaseAddrPtrError);
MoveHHi(myBits);
HLock(myBits);
IF aMac2 THEN
BEGIN
WITH offCGrafPtr^.portPixMap^^ DO
BEGIN
baseAddr := myBits^;
rowBytes := offRowBytes + $8000; bounds := localRect;
END; { WITH }
offBitMapPtr := BitMapPtr(offCGrafPtr^.portPixMap^);
END { IF aMac2 }
ELSE { definitely ... “YUCKY” black-and-white. }
BEGIN
WITH offGrafPtr^.portBits DO
BEGIN
baseAddr := myBits^;
rowBytes := offRowBytes;
bounds := localRect;
END;
offBitMapPtr := @offGrafPtr^.portBits;
END;
IF aMac2 THEN
BEGIN
ourCTHandle := myMaxDevice^^.gdPMap^^.pmTable;
err := HandToHand(Handle(ourCTHandle)); { Clone it. }
IF err <> noErr THEN
ErrorOut(CloneHdlError);
WITH ourCTHandle^^ DO
FOR i := 0 TO ctSize DO
ctTable[i].value := i;
ourCTHandle^^.ctFlags := BAND(ourCTHandle^^.ctFlags, $7FFF);
tempSeed := GetCTSeed; { Thanks, Scott Knaster !! }
ourCTHandle^^.ctSeed := tempSeed;
offCGrafPtr^.portPixMap^^.pmTable := ourCTHandle;
END; { IF aMac2 }
myRect := localRect; { Return local device coords. }
END; { WITH COSHdl^^ DO }
ErrorOut(noErr); { Whew !! }
END; { CreateOffScreen}
{ ******************* }
{ Back to “Square 1”: }
{ ******************* }
PROCEDURE ToOnScreen (COSHdl: OffScreenRecHdl);
BEGIN
WITH COSHdl^^ DO { COSHdl is locked coming in. }
BEGIN
SetPort(origPort);
IF aMac2 THEN
SetGDevice(oldDevice);
END; { WITH }
END; { ToOnScreen}
PROCEDURE DisposOffScreen (VAR COSHdl: OffScreenRecHdl);
LABEL
100;
BEGIN
IF COSHdl = NIL THEN
EXIT(DisposOffScreen);
WITH COSHdl^^ DO
BEGIN
IF CreateOffScreenError = MaxDevError THEN
GOTO 100;
{ NewBaseAddrPtrError or CloneHdlError or noErr ... }
IF aMac2 THEN
BEGIN
IF CreateOffScreenError = noErr THEN
DisposHandle(Handle(ourCTHandle));
HUnlock(Handle(offCGrafPtr^.portPixMap));
CloseCPort(offCGrafPtr);
END
ELSE
ClosePort(offGrafPtr);
IF CreateOffScreenError <> NewBaseAddrPtrError THEN
BEGIN
HUnlock(myBits);
DisposHandle(myBits);
END;
END; { WITH }
100:
HUnlock(Handle(COSHdl));
DisposHandle(Handle(COSHdl));
COSHdl := NIL; { Mark as gone ... }
END; { DisposOffScreen }
END. { UNIT = OffscreenSubs }
Another snipit centers on the fact that my HandleCursor PROC demands knowledge of what kind of window FrontWindow is:
{7}
FUNCTION GetWindowType (window: WindowPtr): INTEGER;
{ Here, window type = Window Definition ID. }
CONST
RomMapInsertLoc = $B9E;
mapTrue = $FFFF;
VAR
varCode, WDEFRsrcID, wType: INTEGER;
WDEFHandle: Handle;
WDEFType: ResType;
WDEFName: Str255;
BEGIN
varCode := GetWVariant(window);
{ Now, what about rDocProc types since their Variation }
{ Codes duplicate those of some standard types such as }
{ documentProc & dBoxProc. I could call: }
{ }
{ regionSize := WindowPeek(window)^.strucRgn^^.rgnSize; }
{ }
{ If regionSize = 10, then rgnBBox is rectangular; so }
{ if <> 10, we’ve got an rDocProc. HOWEVER, if the }
{ window is invisible because I’ve not yet called }
{ _ShowWindow, rgnBBox is empty and regionSize STILL }
{ equals 10. The solution is simple ... call }
{ GetWindowType when the window is being activated. }
{ Better yet ... the solution presented below, thanks }
{ to MacDTS, avoids this workaround. In addition, }
{ MacDTS’ solution avoids the pitfalls of “Murphy” }
{ inventing a totally new window type with a regionSize }
{ that dupes that of rDocProc. }
WDEFHandle := Handle(QuickStrip(Ptr(WindowPeek(window)^.windowDefProc)));
;
LoadResource(WDEFHandle); { May have been purged ... }
{ !! Thanks !!, Ben Cranston: }
wordPtr(RomMapInsertLoc)^ := mapTrue;
GetResInfo(WDEFHandle, WDEFRsrcID, WDEFType, WDEFName);
wType := 16 * WDEFRsrcID + varCode;
IF (wType = documentProc) | (wType = zoomDocProc) THEN
hasGrowIcon := TRUE
ELSE
hasGrowIcon := FALSE;
;
hasGrowIcon := hasGrowIcon | (ScrollHoriz(window) <> NIL) | (ScrollVert(window)
<> NIL);
GetWindowType := wType;
END; { GetWindowType }
Another snipit goodie pertains to determining if we’re staring at a regular or a Desk Accessory Menu. I need this hummer because my “HandleCursor” routine is a part of my “doPeriodic” loop
{8}
FUNCTION daMenu: BOOLEAN;
{ I know ... NEVER assume knowledge of Menu }
{ Record structures ... BUT ... }
CONST
MenuListLoc = $A1C;
TYPE
rMenuRec = RECORD
menuOH: MenuHandle;
menuLeft: INTEGER; { Left edge of Menu. }
END; { rMenuRec }
hMenuRec = RECORD
menuHOH: MenuHandle;
reserved: INTEGER;
END; { hMenuRec }
MenuList = RECORD
lastMenu: INTEGER; { Offset to last regular }
{ MenuHandle. }
lastRight: INTEGER; { Right edge of last }
{ Menu’s title. }
mbResID: INTEGER;
rMenu: ARRAY[0..0] OF rMenuRec;
{ The following fields are also present: }
{ }
{ lastHMenu: INTEGER; -- Offset from here to last }
{ hierarchical Menu. }
{ menuTitleSave: PixMapHandle; }
{ When my daMenu routine is called, there are NO }
{ hierarchical Menus: }
{ hMenu: ARRAY[0..0] OF hMenuRec; }
END; { MenuList }
MenuListPtr = ^MenuList;
MenuListHdl = ^MenuListPtr;
VAR
MLHdl: MenuListHdl;
nbrMenusX6, menuCounter, theMenuID: INTEGER;
BEGIN
MLHdl := MenuListHdl(longPtr(MenuListLoc)^);
nbrMenusX6 := ORD(MLHdl^^.lastMenu);
menuCounter := (nbrMenusX6 DIV 6) - 1;
WHILE menuCounter >= 0 DO
BEGIN
theMenuID := MLHdl^^.rMenu[menuCounter].menuOH^^.menuID;
{ Watch out !!! with System 7 ... }
{ ... the Help Menu (kHMHelpMenuID = -16490) & }
{ ... the Application Menu (ID = ???) }
IF (theMenuID < 0) & (theMenuID >= -16384) THEN
Leave;
menuCounter := menuCounter - 1;
END; { scanning the MenuBar }
{ I could have used: }
{ daMenu := theMenuID < 0; }
{ because I KNOW my app has menus. However, to make }
{ this routine applicable to ANY app, what if ANY app }
{ had zip menus and there were no DA menus, then I }
{ would have to initialize with: }
{ theMenuID := 0; }
{ putting an extra statement in my time-critical }
{ “doPeriodic” loop. }
daMenu := menuCounter >= 0;
END; { daMenu }
Here comes the firehose full of code pertaining to Window MenuBars ... some of the stuff, such as MenuDefProc you folks will recognize as unchanged from James Matthews’ article while others I did change slightly (e.g., Jim’s MenuDefGlue). Anywho, folks, they are waiting for you on disk ...
This next routine is called by wInitMenus in order to sprinkle the Radius “magic” here and there:
{9}
PROCEDURE InitBigScreen (VAR RadStatus: RadiusData; VAR fontSize: INTEGER);
CONST
largeMenuBar = 5; { Bit # in CPFlags field }
{ for non-MacII. }
RadiusID = 0;
VAR
statusHdl, pivotHand: Handle;
BEGIN
SetResLoad(TRUE);
pivotHand := PivotDSHand(GetNamedResource(‘INFO’, ‘Radius Pivot Display’));
IF pivotHand = NIL THEN
LoadResource(pivotHand);
RadStatus.PivotHdl := PivotDSHand(pivotHand);
IF NOT aMac2 THEN
statusHdl := GetNamedResource(‘INFO’, ‘Radius Display’)
ELSE
statusHdl := GetNamedResource(‘INFO’, ‘Radius II Display’);
IF statusHdl = NIL THEN
BEGIN
LoadResource(statusHdl);
IF statusHdl = NIL THEN {Still !!! }
BEGIN
RadStatus.radType := none;
fontSize := normalSize;
EXIT(InitBigScreen);
END; { STILL! }
END; { Zip }
IF NOT aMac2 THEN
BEGIN
IF BTST(RadBWStatHdl(statusHdl)^^.CPFlags, largeMenuBar)
THEN
BEGIN
RadBWStatHdl(statusHdl)^^.LargeFontEn := chr(1);
AddResource(statusHdl, ‘INFO’, RadInfoID, ‘Radius Display’);
fontSize := chicago16;
{ ID = 128*font number + size: }
BIGfont := GetResource(‘FONT’, 128 * systemFont + chicago16);
IF BIGfont = NIL THEN
LoadResource(BIGfont);
RadBWStatHdl(statusHdl)^^.LargeFontEn := chr(0);
RadBWStatHdl(statusHdl)^^.PluggedIn:= chr(0);
AddResource(statusHdl, ‘INFO’, RadInfoID, ‘Radius Display’);
END
ELSE
fontSize := normalSize;
;
RadStatus.radType := radBW;
RadStatus.BWHdl := RadBWStatHdl(statusHdl);
END
ELSE { aMac2 }
BEGIN
IF ord(RadIIStatHdl(statusHdl)^^.LargeMenus) <> 0 THEN
BEGIN
fontSize := chicago16;
BIGfont := GetResource(‘FONT’, chicago16);
IF BIGfont = NIL THEN
LoadResource(BIGfont);
END
ELSE
fontSize := normalSize;
;
RadStatus.radType := radII;
RadStatus.IIHdl := RadIIStatHdl(statusHdl);
END;
END; { InitBigScreen }
Speaking of wInitMenus, note that we set the values of four parms with/without the Radius big screen monitors:
1) between titles -- see James Matthews’ article.
2) aboveBelowItem -- prevents half a menu item string showing for a vertically scrolling Menu.
3) menuFrame, menuShadow -- box around a pulled-down Menu.
scrollPolyDXY plays in wGetMSA. Jim discusses invertOverlap.
{10}
FUNCTION wInitMenus: wMenuBarListHdl;
{ Call immediately after “InitManagers”: }
{ }
{ Creates a wMenuBarList and quantifies }
{ assorted & sordid global parms. }
VAR
wMBL: wMenuBarListHdl;
BEGIN
wMBL := wMenuBarListHdl(NewClearHandle(SizeOf(wMenuBarList)));
;
IF MemError <> noErr THEN
BEGIN
wInitMenus := NIL;
EXIT(wInitMenus);
END; { Whoops !! }
{ wClearMenuBarList(wMBL); -- NOT needed here !! }
wInitMenus := wMBL;
{ ++ stuff for BIGees: }
InitBigScreen(FPDRsrc, sizeFont);
IF sizeFont > normalSize THEN
BEGIN
betweenTitles := 18;
aboveBelowItem := 3;
menuFrame := 2 * frame;
menuShadow := 2 * shadow;
END
ELSE { small potatoes }
BEGIN
betweenTitles := 14;
aboveBelowItem := 2;
menuFrame := frame;
menuShadow := shadow;
END; { ELSE }
frameShad := menuFrame + menuShadow;
scrollPolyDXY := mBarHt DIV 2;
{ Neighboring MENUs share inverted space: }
invertOverlap := (betweenTitles DIV 2) + 1;
END; { wInitMenus }
wGetNewMBar is called every time I create a new window. Please pay close attention to the code that addresses color. This is where I store the attached Menu resource’s Menu Color Table (MCTableHandle) into wMenuBarHandle^^.wMCTable. I need this info in order to draw the Menu’s colors.
{11}
FUNCTION wGetNewMBar (wp: WindowPtr; wMenuBarID: INTEGER): wMenuBarHandle;
{ Pass wMenuBarID = noMBARrsrc if you wish to start fresh }
{ and call wInsertMenu yourself. }
CONST
none = 0;
TYPE
rMenuBar = RECORD
numMenus: INTEGER;
menuIDs: ARRAY[0..0] OF INTEGER;
END;
rMenuBarPtr = ^rMenuBar;
rMenuBarHdl = ^rMenuBarPtr;
VAR
rMBar: rMenuBarHdl;
mh: MenuHandle;
i: INTEGER;
theWorld: SysEnvRec;
itDoesntMatter: OSErr;
BEGIN
wGetNewMBar := NIL; { Assume the pits !! }
;
IF wp = NIL THEN
EXIT(wGetNewMBar);
rMBar := rMenuBarHdl(GetResource(‘MBAR’, wMenuBarID));
{ Out with the old Window Menu Bar if there’s one }
{ and in with the new: }
wDeleteWMB(wp);
;
mBar := wMenuBarHandle(NewClearHandle(SizeOf(wMenuBar)));
IF MemError <> noErr THEN
BEGIN
IF rMBar <> NIL THEN
ReleaseResource(Handle(rMBar));
EXIT(wGetNewMBar);
END; { Whoops !! }
mBar^^.titleHilited := noneHilited;
wSetMenuBar(mBar, wp);
{ & so sue me -- I’m paranoid !! }
IF (rMBar <> NIL) & (rMBar^^.numMenus > 0) THEN
BEGIN
{ Save & restore main Menu Color Table }
{ so that GetMenu does NOT change it. }
IF aMac2 THEN
oldMCTable := GetMCInfo;
FOR i := 0 TO (rMBar^^.numMenus - 1) DO
BEGIN
mh := GetMenu(rMBar^^.menuIDs[i]);
IF mh <> NIL THEN { Paranoid-ville again !! }
BEGIN
IF i = 0 THEN { = Apple Menu }
BEGIN
itDoesntMatter := SysEnvirons(1, theWorld);
IF theWorld.systemVersion < $0700 THEN
BEGIN
SetItemIcon(mh, AboutItem, none);
SetItemCmd(mh, AboutItem, char(none));
END;
AddResMenu(mh, ‘DRVR’); { + DAs }
END; { Apple Menu }
wInsertMenu(mBar, mh, atEnd);
{ For calling GetMenu & AddResMenu lots. }
DetachResource(Handle(mh));
END; { IF mh <> NIL }
END; { FOR }
;
ReleaseResource(Handle(rMBar));
IF aMac2 THEN
BEGIN
newMCTable := GetMCInfo; { Safe on the Stack !! }
SetMCInfo(oldMCTable);
{ Save for drawing & selecting. }
mbar^^.wMCTable := newMCTable;
END; { IF aMac2}
END; { IF a rMBar }
wGetNewMBar := mBar;
END; { wGetNewMBar }
wGetMenuBar is used to retrieve the given window’s wMenuBarHandle for subsequent feeding to wDrawMenuBar and wDrawMSA for Update and Activate Events.
{12}
FUNCTION wGetMenuBar (wp: WindowPtr): wMenuBarHandle;
VAR
i: INTEGER;
BEGIN
found := false;
i := 0;
;
wGetMenuBar := NIL;
IF mBarList = NIL THEN
EXIT(wGetMenuBar);
WITH mBarList^^ DO
BEGIN
IF numWindows > 0 THEN
WHILE (NOT found) & (i < numWindows) DO
IF WMBars[i]^^.wp = wp THEN
found := true
ELSE
i := i + 1 { End of WHILE }
ELSE { zip windows }
;
IF found THEN
wGetMenuBar := WMBars[i];
END; { WITH }
END; { wGetMenuBar }
Just as James Matthews’ did it:
PROCEDURE wSetMenuBar (theMenuBar: wMenuBarHandle; wp: WindowPtr);
BEGIN
theMenuBar^^.wp := wp; { Simple, aint it ?!!? }
END; { wSetMenuBar }
For example:
windPtr := GetNewWindow(...);
menuBar := wGetNewMBar(windPtr, barID);
IF menuBar <> NIL THEN
wAddWMB(menuBar);
PROCEDURE wAddWMB (theMenuBar: wMenuBarHandle);
VAR
i: INTEGER;
BEGIN
newBarListSize := SizeOf(wMenuBarList) + (mBarList^^.numWindows + 1)
* 4;
IF newBarListSize > GetHandleSize(Handle(mBarList)) THEN
IF MemError = noErr THEN
SetHandleSize(Handle(mBarList), newBarListSize);
IF MemError = noErr THEN
WITH mBarList^^ DO
BEGIN
WMBars[numWindows] := theMenuBar;
numWindows := numWindows + 1
END; { WITH }
END; { wAddWMB }
Used when closing a window:
{13}
PROCEDURE wDeleteWMB (wp: WindowPtr);
VAR
i, j: INTEGER;
BEGIN
found := false;
i := 0;
IF mBarList^^.numWindows > 0 THEN
BEGIN
WHILE (NOT found) & (i < mBarList^^.numWindows) DO
IF mBarList^^.WMBars[i]^^.wp = wp THEN
found := true
ELSE
i := i + 1; { End of WHILE }
IF found THEN
BEGIN
wClearMenuBar(mBarList^^.WMBars[i]);
DisposHandle(Handle(mBarList^^.WMBars[i]));
{ Not the last one in the List. }
IF i <> (mBarList^^.numWindows - 1) THEN
FOR j := (i + 1) TO (mBarList^^.numWindows - 1) DO
mBarList^^.WMBars[j - 1] := mBarList^^.WMBars[j]
ELSE
{ Delete the last one. Already done, }
{ so nada required here. }
;
mBarList^^.numWindows := mBarList^^.numWindows - 1;
newBarListSize := GetHandleSize(Handle(mBarList)) - 4;
IF MemError = noErr THEN
SetHandleSize(Handle(mBarList), newBarListSize);
END; { IF found }
END { IF numWindows >0 }
ELSE { zip windows }
;
END; { wDeleteWMB }
To tell you the truth, I do NOT even use wClearMenuBarList, but it’s here for the sake of symmetry with wDrawMenuBar.
{14}
PROCEDURE wClearMenuBarList (theMenuBarList: wMenuBarListHdl);
{ For now, I do NOT use the passed parm because it’s a }
{ global. This may change in the future, however. }
CONST
WindowListLoc = $9D6; { 1st window in linked list. }
VAR
window: WindowPeek;
BEGIN
window := WindowPeek(longPtr(WindowListLoc));
WHILE window <> NIL DO
BEGIN
wDeleteWMB(WindowPtr(window));
window := window^.nextWindow;
END; { WHILE }
{ The following has already happened after execution }
{ of above WHILE loop: }
{ }
{ theMenuBarList^^.numWindows := 0; }
{ SetHandleSize(Handle(theMenuBarList), }
{ SizeOf(wMenuBarList)); }
END; { wClearMenuBarList }
These two routines are called by wInsertMenu & wDeleteMenu, respectively.
{15}
FUNCTION IncreaseSize (theMenuBar: wMenuBarHandle): OSErr;
VAR
hState: SignedByte;
BEGIN
newWMBSize := SizeOf(wMenuBar) + (theMenuBar^^.numMenus + 1) * SizeOf(wMenuRec);
IF newWMBSize > GetHandleSize(Handle(theMenuBar)) THEN
IF MemError = noErr THEN
BEGIN
hState := HGetState(Handle(theMenuBar));
HUnlock(Handle(theMenuBar));
SetHandleSize(Handle(theMenuBar), newWMBSize);
{ Just in case entry state is locked: }
MoveHHi(Handle(theMenuBar));
HSetState(Handle(theMenuBar), hState);
END;
;
IncreaseSize := MemError;
END; { IncreaseSize }
FUNCTION DecreaseSize (theMenuBar: wMenuBarHandle): OSErr;
VAR
hState: SignedByte;
BEGIN
newWMBSize := SizeOf(wMenuBar) + (theMenuBar^^.numMenus - 1) * SizeOf(wMenuRec);
IF newWMBSize < GetHandleSize(Handle(theMenuBar)) THEN
IF MemError = noErr THEN
BEGIN
hState := HGetState(Handle(theMenuBar));
HUnlock(Handle(theMenuBar));
SetHandleSize(Handle(theMenuBar), newWMBSize);
MoveHHi(Handle(theMenuBar));
HSetState(Handle(theMenuBar), hState);
END;
;
DecreaseSize := MemError;
END; { DecreaseSize }
Called when inserting & deleting a Menu so the Menu’s titleRect can be quantified.
{16}
FUNCTION GetTitleWidth (theMenu: MenuHandle): INTEGER;
VAR
oldTxSize, oldTxFont, oldTxMode: INTEGER;
oldTxStyle: Style;
BEGIN
oldTxSize := thePort^.txSize;
oldTxFont := thePort^.txFont;
oldTxStyle := thePort^.txFace;
TextSize(sizeFont);
TextFont(systemFont);
TextFace([]);
;
GetTitleWidth := StringWidth(theMenu^^.menuData);
;
TextSize(oldTxSize);
TextFont(oldTxFont);
TextFace(oldTxStyle);
END; { GetTitleWidth }
This routine is present for the same reason as aboveBelowItem as discussed above.
See wMenuSelect.
FUNCTION GetItemIconSize (theMenu: MenuHandle; item: INTEGER): INTEGER;
CONST
reducedIconCmd = $1D;
smallIconCmd = $1E;
VAR
iconNbr: Byte;
sizeIcon: INTEGER;
theCICN: CIconHandle;
cmdChar: char;
BEGIN
GetItemIcon(theMenu, item, iconNbr);
IF iconNbr = 0 THEN
sizeIcon := 0
ELSE
BEGIN
IF aMac2 THEN
BEGIN
theCICN := GetCIcon(iconNbr + 256);
IF theCICN <> NIL THEN
BEGIN
WITH theCICN^^.iconPMap.bounds DO
sizeIcon := bottom - top;
DisposCIcon(theCICN);
END
ELSE { no cicn }
sizeIcon := 32;
END { aMac2 }
ELSE
sizeIcon := 32;
GetItemCmd(theMenu, item, cmdChar);
IF (cmdChar = chr(reducedIconCmd)) | (cmdChar = chr(smallIconCmd))
THEN
sizeIcon := sizeIcon DIV 2;
END; { Has either an ICON, a CICN, a reduced icon or a SICN }
GetItemIconSize := sizeIcon;
END; { GetItemIconSize }
| Continued in next frame | ||
| Volume Number: | 7 | |
| Issue Number: | 10 | |
| Column Tag: | Color Workshop | |
Related Info: Menu Manager Memory Manager Color Quickdraw
Window Menu Bars Revisited (code) 
When I insert a hierarchical Menu, I do so after all regular Menus. Also note that I account for the fact that all Menu items #32 and beyond are considered enabled as stipulated by the Menu Manager.
The arithmetic for determining the titleRect for a regular Menu dittos James Matthews’ algorithm. The titleRect for a hierarchical Menu is simply the rect for the parent item. We’ve just seen a picture worth at least two pages of prose ...
Note below that I store menuType and parentID in the wMenuRec RECORD. For a regular Menu, parentID = 0. I need these two pieces of info so I can subsequently determine what Menu type I’m looking at and, if a hierarchical Menu, so I can back-calculate to the Menu’s enclosing frame (see RedrawParentItem within wMenuSelect).
{17}
PROCEDURE wInsertMenu (theMenuBar: wMenuBarHandle; theMenu: MenuHandle;
beforeID: INTEGER);
{ Insert a Menu into a defined wMenuBar: }
VAR
hierID, index, i, j: INTEGER;
found, enabled: BOOLEAN;
parentMenuHdl: MenuHandle;
oldPort: GrafPtr;
cmdChar, parentMark: char;
parentItemRect, parentFrameRect: Rect;
currentHeight, prevHeight, sizeIcon: INTEGER;
BEGIN
IF beforeID = atEnd THEN
BEGIN
i := 0;
WHILE (i < theMenuBar^^.numMenus) & (theMenuBar^^.wMenus[i].menuType
= regMenu) DO
i := i + 1;
IF i < theMenuBar^^.numMenus THEN
{ Insert after end of regular portion of Window Menu Bar, }
{ which occurs just prior to the Hierarchical portion. }
BEGIN
wInsertMenu(theMenuBar, theMenu, theMenuBar^^.wMenus[i].mh^^.menuID);
EXIT(wInsertMenu);
END
ELSE
BEGIN
IF IncreaseSize(theMenuBar) <> noErr THEN
EXIT(wInsertMenu);
titleWidth := GetTitleWidth(theMenu);
END; { ELSE: i = numMenus }
END { beforeID = atEnd }
ELSE IF beforeID = hierMenu THEN
BEGIN
hierID := theMenu^^.menuID;
i := 0;
found := false;
;
{ Scan entire wMenuBar. }
WHILE (i < theMenuBar^^.numMenus) & NOT found DO
BEGIN
parentMenuHdl := theMenuBar^^.wMenus[i].mh;
{ Scan each menu. }
FOR j := 1 TO CountMItems(parentMenuHdl) DO
BEGIN
GetItemCmd(parentMenuHdl, j, cmdChar);
IF cmdChar = char(hMenuCmd) THEN
BEGIN
GetItemMark(parentMenuHdl, j, parentMark);
IF ord(parentMark) = hierID THEN
BEGIN
found := true;
Leave; { FOR loop }
END; { IF ord() }
END; { Hierarchical Menu }
END; { FOR }
i := i + 1; { IF found, i = correct # plus 1. }
END; { WHILE }
IF found THEN { ... is it enabled ??? }
IF j < 32 THEN
enabled := BitTst(@theMenuBar^^.wMenus[i - 1].mh^^.enableFlags,
menuTitleBit - j)
ELSE
enabled := true; { Items 32 & beyond. }
IF found & enabled & (IncreaseSize(theMenuBar) = noErr) THEN
BEGIN
{ ’tis re-locked by IncreaseSize PROC. }
WITH theMenuBar^^, wMenus[numMenus] DO
BEGIN
mh := theMenu; { Place at end = Hierarchical portion. }
menuType := hierMenu;
parentID := parentMenuHdl^^.menuID;
{ These fields are filled-in later by wMenuSelect }
{ for both Hierarchical and Regular menus: }
{ }
{ menuParentRgn, cumParentRgn and MenuDownOSHdl }
{ }
{ You’ll notice that I ignore these fields when }
{ inserting and deleting a Regular menu because }
{ Hierarchical menus are inserted AFTER all Regular }
{ menus and are deleted immediately after use. }
END; { WITH theMenuBar^^, wMenus[numMenus] }
{ titleRect = parent item’s rect. }
{ }
{ For starters, setup left & right coordinates: }
WITH parentItemRect DO
BEGIN
{ [i-1] belongs to parentMenuHdl. }
WITH theMenuBar^^.wMenus[i - 1] DO
IF menuType = regMenu THEN
left := titleRect.left + menuFrame
ELSE
left := titleRect.right - 4 * menuFrame + menuFrame;
CalcMenuSize(parentMenuHdl);
right := left + parentMenuHdl^^.menuWidth;
END; { WITH parentItemRect }
WITH theMenuBar^^.wMenus[i - 1] DO
IF menuType = regMenu THEN
currentHeight := titleRect.bottom + menuFrame
ELSE
currentHeight := titleRect.top + menuFrame;
FOR index := 1 TO j DO
BEGIN
prevHeight := currentHeight;
sizeIcon := GetItemIconSize(parentMenuHdl, index);
currentHeight := currentHeight + aboveBelowItem + Max(sizeFont,
sizeIcon) + aboveBelowItem;
END; { FOR }
{ Complete the other two dimensions. }
WITH parentItemRect DO
BEGIN
top := prevHeight;
bottom := currentHeight;
END; { WITH parentItemRect }
WITH theMenuBar^^, wMenus[i - 1] DO
BEGIN
{ Change ONLY right & left coords ... }
parentFrameRect := parentItemRect;
WITH parentFrameRect DO
BEGIN
left := left - menuFrame;
right := right + menuFrame + menuShadow;
END; { WITH parentFrameRect }
GetPort(oldPort);
{ ---- }
SetPort(wp);
LocalGlobal(parentFrameRect);
{ WMgrPort’s portBits.bounds in global coordinates: }
WITH gScreen DO
BEGIN
IF parentFrameRect.right > right - 2 * menuFrame THEN { Shift
left. }
IF menuType = regMenu THEN
OffsetRect(parentFrameRect, right - 2 * menuFrame - parentFrameRect.right,
0)
ELSE
OffsetRect(parentFrameRect, -(titleRect.right - titleRect.left
- 8 * menuFrame + (parentFrameRect.right - parentFrameRect.left)), 0);
;
IF parentFrameRect.left < left + 2 * menuFrame THEN { Shift
right. }
OffsetRect(parentFrameRect, left + 2 * menuFrame - parentFrameRect.left,
0);
END; { WITH gScreen }
{ Back to local window coordinates. }
GlobalLocal(parentFrameRect);
{ ---- }
SetPort(oldPort);
parentItemRect := parentFrameRect;
WITH parentItemRect DO
BEGIN
left := left + menuFrame;
right := right - menuFrame - menuShadow;
END;
;
{ [numMenus] belongs to inserted sub-Menu: }
wMenus[numMenus].titleRect := parentItemRect;
numMenus := numMenus + 1;
END; { WITH theMenuBar^^, wMenus[i - 1] }
END; { IF found & enabled & IncreaseSize }
EXIT(wInsertMenu);
END { beforeID = hierMenu }
ELSE { Smack in the middle somewhere !! }
BEGIN
IF IncreaseSize(theMenuBar) <> noErr THEN
EXIT(wInsertMenu);
titleWidth := GetTitleWidth(theMenu);
WITH theMenuBar^^ DO
BEGIN
i := 0;
WHILE (i < numMenus) & (wMenus[i].mh^^.menuID <> beforeID) DO
i := i + 1;
;
IF i <> numMenus THEN
BEGIN
FOR j := numMenus DOWNTO (i + 1) DO
BEGIN
wMenus[j].mh := wMenus[j - 1].mh;
wMenus[j].menuType := wMenus[j - 1].menuType;
wMenus[j].parentID := wMenus[j - 1].parentID;
{ Overkill just to copy top & bottom ... }
wMenus[j].titleRect := wMenus[j - 1].titleRect;
{ ... now, adjust right & left if a regular Menu. }
IF wMenus[j].menuType = regMenu THEN
OffsetRect(wMenus[j].titleRect, titleWidth + betweenTitles, 0);
END; { FOR j := numMenus DOWNTO (i + 1) }
END; { IF i <> numMenus }
END; { WITH }
END; { in middle }
{ Some wierd arithmetic ... }
WITH theMenuBar^^, wMenus[i].titleRect DO
BEGIN
top := wp^.portRect.top;
;
bottom := top + mBarHt - menuFrame;
;
left := wp^.portRect.left;
{ Make room for Menu Scroll Activator -- see “wDrawMSA”: }
IF i = 0 THEN
left := left + 2 * scrollPolyDXY + menuFrame + betweenTitles - invertOverlap
ELSE
left := left + wMenus[i - 1].titleRect.right - invertOverlap + betweenTitles
- invertOverlap;
;
right := left + invertOverlap + titleWidth + invertOverlap;
IF numMenus = 0 THEN { 1st call to wInsertMenu. }
barLength := betweenTitles + titleWidth + betweenTitles
ELSE
barLength := barLength + titleWidth + betweenTitles;
wMenus[i].mh := theMenu;
wMenus[i].menuType := regMenu;
wMenus[i].parentID := mainMenu;
numMenus := numMenus + 1;
END; { WITH }
END; { wInsertMenu }
wDeleteMenu simply reverses the effect of wInsertMenu.
{18}
PROCEDURE wDeleteMenu (theMenuBar: wMenuBarHandle; menuID: INTEGER);
VAR
i, j: INTEGER;
BEGIN
i := 0;
WITH theMenuBar^^ DO
WHILE (i < numMenus) & (wMenus[i].mh^^.menuID <> menuID) DO
i := i + 1; { End of 1st WITH }
;
IF i <> theMenuBar^^.numMenus THEN
BEGIN
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
titleWidth := GetTitleWidth(theMenuBar^^.wMenus[i].mh);
WITH theMenuBar^^ DO
BEGIN
IF wMenus[i].menuType = regMenu THEN
IF numMenus = 1 THEN { Soon to be zero. }
barLength := 0
ELSE
barLength := barLength - titleWidth - betweenTitles;
FOR j := (i + 1) TO (numMenus - 1) DO
BEGIN
wMenus[j - 1].mh := wMenus[j].mh;
wMenus[j - 1].menuType := wMenus[j].menuType;
wMenus[j - 1].parentID := wMenus[j].parentID;
wMenus[j - 1].titleRect := wMenus[j].titleRect;
IF wMenus[j - 1].menuType = regMenu THEN
OffsetRect(wMenus[j - 1].titleRect, -(titleWidth + betweenTitles),
0);
END; { FOR j := (i + 1) TO (numMenus - 1) }
END; { 2nd WITH }
IF DecreaseSize(theMenuBar) = noErr THEN
;
theMenuBar^^.numMenus := theMenuBar^^.numMenus - 1;
END; { IF i <> theMenuBar^^.numMenus }
END; { wDeleteMenu }
I use GetWBMrects primarily to quantify the rects containing my MSAs which, in turn, play in my DoMouseDown PROC.
{19}
PROCEDURE GetWBMrects (wp: WindowPtr; VAR WBMrect, leftMSArect, rightMSArect:
Rect);
PROCEDURE ZeroRect (VAR r: Rect);
BEGIN
WITH r DO
BEGIN
top := 0;
left := 0;
bottom := 0;
right := 0;
END; { WITH }
END; { ZeroRect }
BEGIN { GetWBMrects }
IF wGetMenuBar(wp) <> NIL THEN
BEGIN
{ + quantifies “hasGrowIcon” for update Event: }
windType := GetWindowType(wp);
WBMrect := wp^.portRect;
WITH WBMrect DO
BEGIN
IF hasGrowIcon THEN
right := right - (scrollWidth - frame);
bottom := top + mBarHt;
END;
leftMSArect := WBMrect;
WITH leftMSArect DO
right := left + 2 * scrollPolyDXY + menuFrame;
rightMSArect := WBMrect;
WITH rightMSArect DO
left := right - 2 * scrollPolyDXY - menuFrame;
END { window has a Window Bar Menu }
ELSE
BEGIN
ZeroRect(WBMrect);
ZeroRect(leftMSArect);
ZeroRect(rightMSArect);
END; { ELSE }
dynamicBalloons[0].dynamicStrID := 128;
IF windType = rDocProc THEN
dynamicBalloons[0].dynamicStrIndex := 3
ELSE
dynamicBalloons[0].dynamicStrIndex := 6;
dynamicBalloons[0].dynamicR := leftMSArect;
;
dynamicBalloons[1].dynamicStrID := 128;
IF windType = rDocProc THEN
dynamicBalloons[1].dynamicStrIndex := 2
ELSE
dynamicBalloons[1].dynamicStrIndex := 5;
dynamicBalloons[1].dynamicR := WBMrect;
{ Between MSAs:. }
InsetRect(dynamicBalloons[1].dynamicR, leftMSArect.right, 0);
;
dynamicBalloons[2].dynamicStrID := 128;
IF windType = rDocProc THEN
dynamicBalloons[2].dynamicStrIndex := 4
ELSE
dynamicBalloons[2].dynamicStrIndex := 7;
dynamicBalloons[2].dynamicR := rightMSArect;
END; { GetWBMrects }
GetColors, RestoreColors and wSetColorMenu play with color Menus and all three are called by both wDrawMenuBar and wMenuSelect:
{20}
PROCEDURE GetColors;
BEGIN
IF aMac2 THEN
BEGIN
GetBackColor(oldBackColor);
GetForeColor(oldForeColor);
END; { IF }
END; { GetColors }
PROCEDURE RestoreColors;
BEGIN
IF aMac2 THEN
BEGIN
RGBBackColor(oldBackColor);
RGBForeColor(oldForeColor);
END; { IF }
END; { RestoreColors }
PROCEDURE wSetColorMenu (menusID, itemsID: INTEGER);
{ Without redefining Apple’s built-in MenuDefProc, }
{ we’re restricting ourselves to ALL Item text }
{ (including the mark & CMD-key) being he same }
{ color and ditto for the background color of ALL }
{ Items. }
VAR
MCTBEntry: MCEntryPtr;
{ What we actually got back from GetMCTBEntry }
{ compared with what we asked for, the latter }
{ being the original parms passed to wSetColorMenu: }
returnedMenuID, returnedMenuItem: INTEGER;
FUNCTION GetMCTBEntry (VAR menuID, itemID: INTEGER): MCEntryPtr;
VAR
mctbEntryPtr: MCEntryPtr;
BEGIN
GetMCTBEntry := NIL; { NOT very optimistic, are we ?!!? }
mctbEntryPtr := GetMCEntry(menuID, itemID);
IF mctbEntryPtr = NIL THEN
{ Could NOT find what we asked for, so recurse }
{ UP the chain: }
{ }
{ if no specified Item entry, then look for }
{ Title entry }
{ if no asked-for Title entry, then look for }
{ MenuBar entry }
{ if no specified MenuBar entry, then our }
{ ‘mctb’ resource is NOT correct }
BEGIN
IF (menuID <> mceMenuBar) & (itemID <> mceMenuTitle) THEN
BEGIN { Asked for item }
itemID := mceMenuTitle;
GetMCTBEntry := GetMCTBEntry(menuID, itemID);
END
ELSE IF (menuID <> mceMenuBar) & (itemID = mceMenuTitle) THEN
BEGIN { Asked for title }
menuID := mceMenuBar;
itemID := mceMenuBar;
GetMCTBEntry := GetMCTBEntry(menuID, itemID);
END
ELSE IF (menuID = mceMenuBar) & (itemID = mceMenuBar) THEN
; { Ran out of steam !!! }
END
ELSE
GetMCTBEntry := mctbEntryPtr;
END; { GetMCTBEntry }
BEGIN { wSetColorMenu }
IF NOT aMac2 THEN
EXIT(wSetColorMenu);
{ VARed ... what we actually get back from GetMCTBEntry. }
returnedMenuID := menusID;
returnedMenuItem := itemsID;
;
MCTBEntry := GetMCTBEntry(returnedMenuID, returnedMenuItem);
IF MCTBEntry = NIL THEN
EXIT(wSetColorMenu);
WITH MCTBEntry^ DO
IF (returnedMenuID <> mceMenuBar) & (returnedMenuItem <> mceMenuTitle)
THEN
BEGIN { Asked for AND got a Menu Item. }
RGBBackColor(mctRGB4);
RGBForeColor(mctRGB2);
END { an Item element}
ELSE IF (returnedMenuID <> mceMenuBar) & (returnedMenuItem = mceMenuTitle)
THEN
BEGIN
RGBBackColor(mctRGB4);
IF itemsID = mceMenuTitle THEN
{ Asked for AND got a Menu Title. }
RGBForeColor(mctRGB1)
ELSE { Asked for an Item, recursed to a Title. }
RGBForeColor(mctRGB3);
END { a Title element }
ELSE IF (returnedMenuID = mceMenuBar) & (returnedMenuItem = mceMenuBar)
THEN
BEGIN
{ Here, if you ask for the MenuBar entry, I assume }
{ you’re just interested in the background color }
{ because you’re coloring the overall MenuBar via }
{ _EraseRect. If you’re really interested in the }
{ background color of the pulled-down Menu, then }
{ ask for a Menu Title or a Menu Item entry. }
IF menusID = mceMenuBar THEN
{ Got what we asked for !! }
RGBBackColor(mctRGB4)
ELSE IF itemsID = mceMenuTitle THEN
{ Asked for a Title, recursed to MenuBar. }
BEGIN
RGBBackColor(mctRGB2);
RGBForeColor(mctRGB1);
END
ELSE { Asked for an Item, recursed TWICE to MenuBar. }
BEGIN
RGBBackColor(mctRGB2);
RGBForeColor(mctRGB3);
END
END; { got back a MenuBar element}
{ End of WITH }
END; { wSetColorMenu }
Note that I lock theMenuBar passed to wDrawMenuBar, but do NOT have that luxury with wMenuSelect. The reason for the latter is because I recurse however many times it takes to get to the appropriate hierarchical Menu no matter how deep it’s buried. More on this recursing & cursing later ...
{21}
PROCEDURE wDrawMenuBar (theMenuBar: wMenuBarHandle);
{ Draw a wMenuBar with appropriate highlighting: }
LABEL
100, 200;
VAR
active: BOOLEAN;
y0, i: INTEGER;
lsWBMrect, offBarRect, titleR, visDrawingRect: Rect;
titleRgn: RgnHandle;
{ Keep safe on Stack to avoid Memory Manager blues ... }
safeTitle: Str255;
BEGIN
IF theMenuBar^^.numMenus = 0 THEN { Nada !! }
EXIT(wDrawMenuBar);
mbHState := HGetState(Handle(theMenuBar));
MoveHHi(Handle(theMenuBar));
{ ... because some TRAPs called inside the }
{ WITH block move memory. }
HLock(Handle(theMenuBar));
GetPort(oldPort);
SetPort(theMenuBar^^.wp);
oldClip := NewRgn;
GetClip(oldClip);
;
GetColors;
IF aMac2 THEN
BEGIN
oldMCTable := GetMCInfo;
SetMCInfo(theMenuBar^^.wMCTable);
END; { IF aMac2 }
{ GetWBMrects already called by wDrawMSA. }
lsWBMrect := WBMrect;
LocalGlobal(lsWBMrect);
{ Local window coordinates are input to & local screen }
{ coordinates are returned from CreateOffScreen: }
WITH theMenuBar^^ DO
BEGIN
active := (ORD(WindowPeek(wp)^.hilited) <> 0);
{ offBarRect may end up being wider than window’s portRect. }
WITH offBarRect DO
BEGIN
top := WBMrect.top;
bottom := WBMrect.bottom - menuFrame;
left := leftMSArect.right;
right := left + barLength;
IF right < rightMSArect.left THEN
right := rightMSArect.left;
END; { WITH offBarRect }
IF barOSHdl <> NIL THEN
BEGIN
LocalGlobal(offBarRect);
WITH lScreen.bounds DO { _GlobalToLocal }
OffsetRect(offBarRect, left, top);
GOTO 100;
END; { Still there }
barOSHdl := CreateOffScreen(offBarRect);
IF (QuickStrip(Ptr(barOSHdl)) = NIL) | (barOSHdl^^.CreateOffScreenError
<> noErr) THEN
GOTO 200;
{ ELSE draw into off-screen Port as follows: }
TextSize(sizeFont);
TextFont(systemFont);
TextFace([]);
TextMode(srcOr);
{ We canNOT call _GlobalToLocal here because we’ve }
{ changed the portBits.bounds rectangle of our }
{ off-screen port within “CreateOffScreen”. }
WITH lScreen.bounds DO { Bounds BEFORE change. }
OffsetRect(lsWBMrect, left, top);
;
ClipRect(offBarRect);
wSetColorMenu(mceMenuBar, mceMenuBar);
EraseRect(offBarRect); { Eliminate all stray matter. }
y0 := (mBarHt - menuFrame - sizeFont) DIV 2;
;
FOR i := 0 TO (numMenus - 1) DO
BEGIN
IF wMenus[i].menuType = hierMenu THEN
Cycle;
titleR := wMenus[i].titleRect;
{ Convert to local screen coordinates: }
OffsetRect(titleR, lsWBMrect.left, lsWBMrect.top);
{Eliminate the overshoot placed there to invert title,}
{because all we wish to do is draw the title string: }
InsetRect(titleR, invertOverlap, 0);
;
MoveTo(titleR.left, titleR.bottom - y0);
wSetColorMenu(wMenus[i].mh^^.menuID, mceMenuTitle);
safeTitle := wMenus[i].mh^^.menuData;
DrawString(safeTitle);
{Gray-out disabled Menu titles ONLY if window is active.}
{We dim the whole Window Bar Menu below if window isn’t.}
{The latter allows for CMD-dragging the window. }
IF active & NOT BitTst(@wMenus[i].mh^^.enableFlags, menuTitleBit)
THEN
BEGIN
titleRgn := NewRgn;
RectRgn(titleRgn, titleR);
DimRgn(titleRgn);
DisposeRgn(titleRgn);
END; { Gray-out disabled title }
END; { FOR ... drawing off-screen }
100:
ToOnScreen(barOSHdl); { Back to “Square 1”. }
WITH barOSHdl^^ DO
BEGIN
visDrawingRect := drawingRect;
ClipRect(drawingRect);
BackColor(whiteColor); { So funny colorization }
ForeColor(blackColor); { does NOT happen !! }
;
{ Adjust if overlapping right MSA. }
WITH visDrawingRect DO
IF right > rightMSArect.left THEN
right := rightMSArect.left;
onScreenRgn := NewRgn;
RectRgn(onScreenRgn, visDrawingRect);
CalcVis(WindowPeek(wp)); { Radius’ TOM INIT. }
SectRgn(onScreenRgn, wp^.visRgn, onScreenRgn);
CopyBits(offBitMapPtr^, thePort^.portBits, offBarRect, drawingRect,
srcCopy, onScreenRgn);
{ Consider you’re CMD-dragging ... }
IF NOT active THEN
DimRgn(onScreenRgn);
ValidRgn(onScreenRgn);
DisposeRgn(onScreenRgn);
END; { WITH barOSHdl^^ }
200:
DisposOffScreen(barOSHdl);
END; { WITH theMenuBar^^ }
{ Deliberately last ... we’re safe now !! }
HSetState(Handle(theMenuBar), mbHState);
RestoreColors;
IF aMac2 THEN
SetMCInfo(oldMCTable);
;
SetClip(oldClip);
DisposeRgn(oldClip);
SetPort(oldPort);
{ Appropriate highlighting = none. }
wHiliteMenu(theMenuBar, 0);
END; { wDrawMenuBar }
Here’s another PROC wherein I need access to my MSA rects. When I scroll, I merely offset the titleRects of the regular Menu’s titleRects (the hierarchical Menus and their titleRects are NOT present except when I’m choosing a Menu item within wMenuSelect). After offseting the titleRects, I redraw the MSAs and then the window’s MenuBar ... simple ain’t it ?!*!?
{22}
PROCEDURE wScrollMenuBar (theMenuBar: wMenuBarHandle);
CONST
toRight = 1;
toLeft = -1;
VAR
mouseLoc: Point;
nbrMenus, direction, temp, deltaScroll, i: INTEGER;
BEGIN
nbrMenus := theMenuBar^^.numMenus;
GetMouse(mouseLoc);
IF PtInRect(mouseLoc, leftMSArect) THEN
direction := toRight
ELSE IF PtInRect(mouseLoc, rightMSArect) THEN
direction := toLeft
ELSE
EXIT(wScrollMenuBar); { Should NOT happen !! }
WHILE WaitMouseUp DO
BEGIN
IF direction = toRight THEN
BEGIN
temp := leftMSArect.right + betweenTitles - invertOverlap - mBar^^.wMenus[0].titleRect.left;
IF temp <= 0 THEN
Leave
ELSE
deltaScroll := Min(StringWidth(‘A’), temp);
END
ELSE { direction = toLeft }
BEGIN
temp := rightMSArect.left - (mBar^^.wMenus[nbrMenus - 1].titleRect.right
- invertOverlap + betweenTitles);
IF temp >= 0 THEN
Leave
ELSE
{ Absolute value. }
deltaScroll := Min(StringWidth(‘A’), -temp);
END;
deltaScroll := direction * deltaScroll;
FOR i := 0 TO (nbrMenus - 1) DO
OffsetRect(theMenuBar^^.wMenus[i].titleRect, deltaScroll, 0);
wDrawMSA(theMenuBar);
wDrawMenuBar(theMenuBar);
END; { WHILE }
END; { wScrollMenuBar }
Get ’em and weep, I mean ‘draw’ :
PROCEDURE wGetMSA (theMenuBar: wMenuBarHandle);
VAR
dx, dy, over, back, up, down: INTEGER;
tempPoly: PolyHandle;
BEGIN
WITH WBMrect DO
BEGIN
GetPort(oldPort);
SetPort(theMenuBar^^.wp);
GetWBMrects(theMenuBar^^.wp, WBMrect, leftMSArect, rightMSArect);
{ ----------------------------------------------------------------------
}
{ Get MSA at left of Window Bar Menu: }
dx := 3 * (scrollPolyDXY DIV 2);
dy := (bottom - menuFrame - top - scrollPolyDXY) DIV 2;
over := scrollPolyDXY;
back := -over;
up := -scrollPolyDXY;
down := scrollPolyDXY DIV 2;
IF theMenuBar^^.leftScrollPoly = NIL THEN
BEGIN
{ I can’t believe I did this ?!*!? }
{ theMenuBar^^.leftScrollPoly := OpenPoly; }
tempPoly := OpenPoly;
theMenuBar^^.leftScrollPoly := tempPoly;
MoveTo(left + dx, bottom - menuFrame - dy);
Line(0, up); { Vertical part ... }
Line(back, down); { ... horizontal parts: }
Line(over, down);
ClosePoly;
END; { Doesn’t exist, so make a new one }
{ ------------------------------------------------------------------------
}
{ Get MSA at right of Window Bar Menu: }
IF theMenuBar^^.rightScrollPoly = NIL THEN
BEGIN
tempPoly := OpenPoly;
theMenuBar^^.rightScrollPoly := tempPoly;
MoveTo(right - dx, bottom - menuFrame - dy);
Line(0, up); { Vertical part ... }
Line(over, down); { ... horizontal parts: }
Line(back, down);
ClosePoly;
END; { IF }
SetPort(oldPort);
END; { WITH WBMrect }
END; { wGetMSA }
PROCEDURE wDrawMSA (theMenuBar: wMenuBarHandle);
{ ... AND the bottom line bordering the Window Bar Menu. }
LABEL
100;
VAR
dx, dy: INTEGER;
aux: BOOLEAN;
frameColor: RGBColor;
BEGIN
WITH WBMrect DO
BEGIN
GetPort(oldPort);
SetPort(theMenuBar^^.wp);
GetPenState(pnState);
{ ------------------------------------------------------------------------------------------------------------
}
{ Get the Window Bar Menu rect & draw a line beneath it: }
wGetMSA(theMenuBar); { Calls GetWBMrects. }
gWBMrect := WBMrect;
LocalGlobal(gWBMrect);
IF NOT SectRect(gWBMrect, gScreen, visRect) THEN
GOTO 100;
GlobalLocal(visRect);
onScreenRgn := NewRgn;
RectRgn(onScreenRgn, visRect);
SectRgn(onScreenRgn, theMenuBar^^.wp^.visRgn, onScreenRgn);
oldClip := NewRgn;
GetClip(oldClip);
SetClip(onScreenRgn);
;
aux := GetWindowPartColor(theMenuBar^^.wp, wFrameColor, frameColor);
IF (colorDepth > 1) & aux THEN
BEGIN
GetForeColor(oldForeColor);
RGBForeColor(frameColor);
END; { Draw in color }
;
PenNormal;
PenSize(menuFrame, menuFrame);
MoveTo(left, bottom - menuFrame);
Line(right - left, 0);
{ ---------------------------------------------------------------- }
{ Draw MSA at left of Window Menu: }
IF theMenuBar^^.wMenus[0].titleRect.left < leftMSArect.right + betweenTitles
- invertOverlap THEN
FillPoly(theMenuBar^^.leftScrollPoly, black)
ELSE
BEGIN
FillPoly(theMenuBar^^.leftScrollPoly, white);
FramePoly(theMenuBar^^.leftScrollPoly);
END;
{ ------------------------------------------------------------------------------------------------------
}
{ Draw vertical line separating MSA from Menu titles: }
MoveTo(left + 2 * scrollPolyDXY, bottom - menuFrame);
Line(0, -(bottom - top - menuFrame));
{ --------------------------------------------------------------------------
}
{ Draw MSA at right of Window Bar Menu: }
IF theMenuBar^^.wMenus[theMenuBar^^.numMenus - 1].titleRect.right
- invertOverlap + betweenTitles > rightMSArect.left THEN
FillPoly(theMenuBar^^.rightScrollPoly, black)
ELSE
BEGIN
FillPoly(theMenuBar^^.rightScrollPoly, white);
FramePoly(theMenuBar^^.rightScrollPoly);
END;
;
MoveTo(right - 2 * scrollPolyDXY - menuFrame, bottom - menuFrame);
{ + vertical }
Line(0, -(bottom - top - menuFrame)); { line. }
IF ORD(WindowPeek(theMenuBar^^.wp)^.hilited) = 0 THEN
DimRgn(onScreenRgn);
ValidRgn(onScreenRgn);
DisposeRgn(onScreenRgn);
SetClip(oldClip);
DisposeRgn(oldClip);
IF (colorDepth > 1) & aux THEN
RGBForeColor(oldForeColor);
100:
SetPenState(pnState);
SetPort(oldPort);
ValidRect(visRect);
END; { WITH }
END; { wDrawMSA }
Kill the polyHandles. Note that barOSHdl is always = NIL because immediately after I create this OffScreenRecHdl within wDrawMenuBar and subsequently bit it back on-screen, I then call DisposOffscreen.
{23}
PROCEDURE wClearMenuBar (theMenuBar: wMenuBarHandle);
{ Called internally by wDeleteWMB to }
{ kiss some Handles goodbye. }
BEGIN
mbHState := HGetState(Handle(theMenuBar));
MoveHHi(Handle(theMenuBar));
HLock(Handle(theMenuBar));
WITH theMenuBar^^ DO
BEGIN
wHiliteMenu(theMenuBar, 0);
{ So sue me ... I’m paranoid !! }
IF leftScrollPoly <> NIL THEN
BEGIN
KillPoly(leftScrollPoly);
leftScrollPoly := NIL; { Mark as gone ... }
END;
;
IF rightScrollPoly <> NIL THEN
BEGIN
KillPoly(rightScrollPoly);
rightScrollPoly := NIL;
END;
IF barOSHdl <> NIL THEN
DisposOffScreen(barOSHdl); { Sets barOSHdl := NIL }
END; { WITH }
HSetState(Handle(theMenuBar), mbHState);
END; { wClearMenuBar }
Now, the recursing & cursing ...
The local routine ItDoesFit is used when you’ve dragged the window close to the screen’s phycical bottom edge, not leaving enough room to draw at least three items if there’s more than three to begin with.
GetParentMenuInfo is used to quantify the index for both RgnHandles, cumParentRgn & menuParentRgn, when dealing with hierarchical Menus.
See the intro comments for RedrawParentItem for its purpose in life.
wMenuSelect is no longer the nightmare it initially was, thanks to Ben Cranston. Initially I had locked the passed wMenuBarHandle & surrounded darn near the entire PROC with a WITH theMenuBar^^. But then, with recursion for a hierarchical Menu, I called wInsertMenu which immediately unlocked wMenuBarHandle & called MoveHHi. Oh where, o’ where did the handle go ... thanks Ben !!!!!
{24}
FUNCTION wMenuSelect (theMenuBar: wMenuBarHandle; startPt: Point): LONGINT;
{ Pull down the Menus and let the user select an Item: }
{ NOTE -- “startPt” is in Global coordinates, but }
{ ONLY to be compatible with _MenuSelect. }
LABEL
100, 200;
CONST
TopMenuItemLoc = $A0A;
AtMenuBottomLoc = $A0C;
MenuFlashAddr = $A24;
HiliteMode = $938;
VAR
oldPort: GrafPtr; { Many Locals because of recursion }
oldClip: RgnHandle;
oldForeColor, oldBackColor: RGBColor;
screenBounds, betweenMSAs, visAllTitles, visThisTitle, visString:
Rect;
menuRect, menuFrameRect, lsMenuRect, lsWBMrect, lsTitleRect: Rect;
lStartPt, hierPt, NILPt: Point;
itemsHeight, i, j, blink: INTEGER;
saveScrollInfo: LONGINT;
menuFlashP: wordPtr;
strayed: BOOLEAN;
cmdChar, itemMark: char;
hierMenuHdl: MenuHandle;
origMCTable, parentMCTable, hierMCTable: MCTableHandle;
hierSelect: LONGINT;
onCScreen: CGrafPort;
onCScreenPtr: CGrafPtr;
onBWScreen: GrafPort;
onBWScreenPtr: GrafPtr;
MenuDownOSHdl: OffScreenRecHdl;
{ Murphy’s Memory Manager ... }
tempRgn1, tempRgn2, tempRgn3: RgnHandle;
FUNCTION ItDoesFit (theMenu: MenuHandle; maxMenuHeight: INTEGER; VAR
cumMenuHeight: INTEGER): BOOLEAN;
{ Get maximum cum height that can fit }
{ within the specified max height. }
VAR
prevMenuHeight, index, sizeItemIcon: INTEGER;
BEGIN
ItDoesFit := true; { Be upbeat !! }
IF theMenu^^.menuHeight <= maxMenuHeight THEN
BEGIN
cumMenuHeight := theMenu^^.menuHeight;
EXIT(ItDoesFit);
END;
cumMenuHeight := 0; { For starters ... }
FOR index := 1 TO CountMItems(theMenu) DO
BEGIN
prevMenuHeight := cumMenuHeight;
sizeItemIcon := GetItemIconSize(theMenu, index);
cumMenuHeight := cumMenuHeight + aboveBelowItem + Max(sizeFont, sizeItemIcon)
+ aboveBelowItem;
IF cumMenuHeight > maxMenuHeight THEN
Leave; { FOR loop }
END; { FOR }
IF index - 1 < 3 THEN
ItDoesFit := false
ELSE IF sizeItemIcon = 0 THEN
{ ... of first item NOT shown. }
cumMenuHeight := prevMenuHeight
ELSE
{ Prevents drawing of the top pixels of }
{ any icon in first item NOT shown: }
cumMenuHeight := prevMenuHeight - aboveBelowItem;
END; { ItDoesFit }
FUNCTION GetParentMenuInfo (theMenuBar: wMenuBarHandle; hierMenuNbr:
INTEGER): LONGINT;
{ Returns parent menu # in Hi word and }
{ parent item # in the low word: }
{ NEVER say it can NEVER fail !!! }
VAR
hierID, parentMenuNum, j: INTEGER;
parentMenuHdl: MenuHandle;
cmdChar, parentMark: char;
temp: LONGINT;
BEGIN
WITH theMenuBar^^ DO
BEGIN
parentMenuNum := 0;
WHILE (parentMenuNum < numMenus) & (wMenus[hierMenuNbr].parentID
<> wMenus[parentMenuNum].mh^^.menuID) DO
parentMenuNum := parentMenuNum + 1;
IF parentMenuNum = numMenus THEN
{ It better NOT be !!! }
;
hierID := wMenus[hierMenuNbr].mh^^.menuID;
parentMenuHdl := wMenus[parentMenuNum].mh;
END; { WITH }
FOR j := 1 TO CountMItems(parentMenuHdl) DO
BEGIN
GetItemCmd(parentMenuHdl, j, cmdChar);
IF cmdChar = char(hMenuCmd) THEN
BEGIN
GetItemMark(parentMenuHdl, j, parentMark);
IF ord(parentMark) = hierID THEN
Leave; { FOR loop }
END;
END; { FOR }
temp := parentMenuNum;
temp := BitShift(temp, 16) + j;
GetParentMenuInfo := temp;
END; { GetParentMenuInfo }
PROCEDURE RedrawParentItem (theMenuBar: wMenuBarHandle; hierMenuNbr:
INTEGER);
{ Apple’s MenuDefProc does NOT call _InverRect for a }
{ color Mac, but rather _EraseRect followed by a }
{ redraw of the Menu item with reversed background }
{ and hilite colors. As you can see below, however, }
{ I am prone to cheating: }
{ CONST }
{ TopMenuItemLoc = $A0A; }
{ AtMenuBottomLoc = $A0C; }
VAR
saveScrollInfo: LONGINT; { MUST be local !!! }
parentMenuInfo: LONGINT;
parentMenuNum, redrawitem: INTEGER;
redrawPt: Point;
parentMenuHdl: MenuHandle;
parentMenuRect: Rect;
BEGIN
IF NOT aMac2 THEN
EXIT(RedrawParentItem);
parentMenuInfo := GetParentMenuInfo(theMenuBar, hierMenuNbr);
parentMenuNum := HiWord(parentMenuInfo);
redrawItem := LoWord(parentMenuInfo);
WITH theMenuBar^^.wMenus[parentMenuNum] DO
BEGIN
parentMenuHdl := mh;
parentMenuRect := menuParentRgn^^.rgnBBox;
END;
ClipRect(parentMenuRect);
WITH lScreen.bounds DO { LocalToGlobal }
OffsetRect(parentMenuRect, -left, -top);
SetPt(redrawPt, 0, 0);
saveScrollInfo := longPtr(TopMenuItemLoc)^;
wordPtr(TopMenuItemLoc)^ := parentMenuRect.top;
wordPtr(AtMenuBottomLoc)^ := parentMenuRect.bottom;
MenuDefGlue(mChooseMsg, parentMenuHdl, parentMenuRect, redrawPt, redrawItem);
longPtr(TopMenuItemLoc)^ := saveScrollInfo;
END; { RedrawParentItem }
BEGIN { wMenuSelect }
{ Note that starting here, we sure could use }
{ WITH theMenuBar^^ & WITH wMenus[i] statements }
{ for shorthand. However, we’d then need to call }
{ HLock. This would be okay except when we later }
{ implement Hierarchical menus via a recursive to }
{ ourself (wMenuSelect). This unnecessarily }
{ keeps a locked Handle around for a long time. }
{ [ See “The Secret Life of the Memory Manager” }
{ by Richard Clark n “develop”, Volume 1, }
{ Issue 2, April 1990 ] }
{ In addition, for Hierarchical menus, we call }
{ wInsertMenu and wDeleteMenu which in turn call }
{ the IncreaseSize and DecreaseSize PROCs. These }
{ latter PROCs move “theMenuBar” because we need }
{ to temporarily unlock this handle therefore }
GetPort(oldPort);
SetPort(theMenuBar^^.wp);
oldClip := NewRgn;
GetClip(oldClip);
;
IF aMac2 THEN
BEGIN
{ “GetColors” is local due to recursion. }
GetBackColor(oldBackColor);
GetForeColor(oldForeColor);
origMCTable := GetMCInfo;
SetMCInfo(theMenuBar^^.wMCTable);
END; { IF aMac2 }
;
menuFlashP := wordPtr(MenuFlashAddr);
WHILE WaitMouseUp DO
BEGIN
whichItem := 0; { May NOT be in a titleRect. }
{ Find the Menu title that user is selecting. }
i := theMenuBar^^.numMenus - 1;
GlobalToLocal(startPt); { Local window coordinates. }
WHILE (i >= 0) & NOT PtInRect(startPt, theMenuBar^^.wMenus[i].titleRect)
DO
i := i - 1;
IF i >= 0 THEN { Have Menu drop ... }
BEGIN
lsTitleRect := theMenuBar^^.wMenus[i].titleRect;
;
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
BEGIN
{ Otherwise strayed = TRUE momentarily as you hit the }
{ line bordering titleRect & menuRect in the process }
{ of pulling down a MENU (see below): }
lsTitleRect.bottom := lsTitleRect.bottom + menuFrame;
{ ... AND if the Window Menu Bar is scrolled ... }
{ don’t forget about the invertOverlap arithmetic }
{ which would enable the Mouse to be over the expanded }
{ titleRect WITHOUT the first/last title }
{ character being visible. The equations below avoid }
{ this happenstance. In addition, “menuFrame” is used }
{ to account for a character width > an image width as }
{ well as a character origin > 0. }
screenBounds := gScreen; { = GrayRgn’s rgnBBox. }
GlobalLocal(screenBounds);
betweenMSAs := WBMrect;
InsetRect(betweenMSAs, leftMSArect.right, 0);
IF NOT SectRect(screenBounds, betweenMSAs, visAllTitles) THEN
GOTO 100; { Will NOT happen !! }
IF NOT SectRect(visAllTitles, lsTitleRect, visThisTitle) THEN
GOTO 100; { Ditto !! }
visString := visThisTitle;
WITH visString DO
BEGIN
IF (leftMSArect.right > right - invertOverlap - 2 * menuFrame)
| (screenBounds.left > right - invertOverlap - 2 * menuFrame) THEN
right := right - invertOverlap - 2 * menuFrame;
;
IF (rightMSArect.left < left + invertOverlap + 2 * menuFrame) |
(screenBounds.right < left + invertOverlap + 2 * menuFrame) THEN
left := left + invertOverlap + 2 * menuFrame;
END; { WITH visString }
IF EmptyRect(visString) THEN
GOTO 100;
END; { a regular Menu }
LocalGlobal(lsTitleRect);
{ Needed for vertical scrolling: }
lsWBMrect := WBMrect;
{ ... or rightMSArect.left: }
InsetRect(lsWBMrect, leftMSArect.right, 0);
LocalGlobal(lsWBMrect);
LocalToGlobal(startPt);
CalcMenuSize(theMenuBar^^.wMenus[i].mh);
WITH theMenuBar^^.wMenus[i], titleRect DO
IF menuType = regMenu THEN
SetRect(menuFrameRect, left, bottom, left + menuFrame + mh^^.menuWidth
+ frameShad, bottom + menuFrame + mh^^.menuHeight + frameShad)
ELSE
SetRect(menuFrameRect, right - 4 * menuFrame, top, right - 4 *
menuFrame + menuFrame + mh^^.menuWidth + frameShad, top + menuFrame +
mh^^.menuHeight + frameShad);
{ If Menu overlaps the screen’s edges, }
{ trim and/or shift it: }
LocalGlobal(menuFrameRect);
WITH gScreen DO
BEGIN
IF menuFrameRect.bottom > bottom - 2 * menuFrame THEN
menuFrameRect.bottom := bottom - 2 * menuFrame;
;
IF menuFrameRect.right > right - 2 * menuFrame THEN
{ Shift left. }
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
OffsetRect(menuFrameRect, right - 2 * menuFrame - menuFrameRect.right,
0)
ELSE
OffsetRect(menuFrameRect, -(theMenuBar^^.wMenus[i].titleRect.right
- theMenuBar^^.wMenus[i].titleRect.left - 8 * menuFrame + (menuFrameRect.right
- menuFrameRect.left)), 0);
;
IF menuFrameRect.left < left + 2 * menuFrame THEN
{ Shift right. }
OffsetRect(menuFrameRect, left + 2 * menuFrame - menuFrameRect.left,
0);
END; { WITH gScreen }
GlobalLocal(menuFrameRect); { --> local window coords. }
WITH menuFrameRect DO
IF ItDoesFit(theMenuBar^^.wMenus[i].mh, bottom - top - menuFrame
- frameShad, itemsHeight) THEN
bottom := top + menuFrame + itemsHeight + frameShad
ELSE IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
BEGIN { Damn SysBeep drove me nuts/nuttier !!! }
wHiliteMenu(theMenuBar, theMenuBar^^.wMenus[i].mh^^.menuID);
Delay(flashDelay * 2, finalTicks);
wHiliteMenu(theMenuBar, 0);
Delay(flashDelay * 2, finalTicks);
GOTO 100;
END
ELSE
BEGIN
{ From Open(C)Port on the previous go-around. }
SetPort(oldPort);
WITH lScreen.bounds DO
OffsetRect(lsTitleRect, left, top); { GlobalToLocal }
Delay(flashDelay * 2, finalTicks);
IF aMac2 THEN
{ i = Hierarchical Menu # }
RedrawParentItem(theMenuBar, i)
ELSE
BEGIN
ClipRect(lsTitleRect);
InvertRect(lsTitleRect);
END;
Delay(flashDelay * 2, finalTicks);
{ So we can reset its clipRgn on exit: }
SetPort(theMenuBar^^.wp);
Leave;
END; { does NOT fit & WITH menuFrameRect }
{ MenuDefProc’s “mChooseMsg” handles hiliting }
{ for a Hierarchical menu item: }
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
wHiliteMenu(theMenuBar, theMenuBar^^.wMenus[i].mh^^.menuID);
MenuDownOSHdl := CreateOffScreen(menuFrameRect);
IF (QuickStrip(Ptr(MenuDownOSHdl)) = NIL) | (MenuDownOSHdl^^.CreateOffScreenError
<> noErr) THEN
BEGIN
DisposOffScreen(MenuDownOSHdl);
GOTO 200;
END; { Whoops !! }
ClipRect(menuFrameRect); { Draw off-screen ... }
EraseRect(menuFrameRect); { Eliminate all stray matter. }
{ An alternate “ToOnScreen” so our Menu can overlap }
{ the window’s boundaries rather than be confined }
{ to just its portRect: }
IF aMac2 THEN
BEGIN
SetGDevice(MenuDownOSHdl^^.oldDevice);
onCScreenPtr := @onCScreen;
OpenCPort(onCScreenPtr);
{ For multiple screens ... }
RectRgn(onCScreenPtr^.visRgn, gScreen);
onCScreenPtr^.portRect := gScreen;
END { IF aMac2 }
ELSE
BEGIN
onBWScreenPtr := @onBWScreen;
OpenPort(onBWScreenPtr);
RectRgn(onBWScreenPtr^.visRgn, gScreen);
onBWScreenPtr^.portRect := gScreen;
END; { ELSE = “Yucky” black-and-white }
ClipRect(menuFrameRect);
{ Save current screen image: }
BackColor(whiteColor);
ForeColor(blackColor);
CopyBits(thePort^.portBits, MenuDownOSHdl^^.offBitMapPtr^, menuFrameRect,
menuFrameRect, srcCopy, NIL);
TextSize(sizeFont);
TextFont(systemFont);
TextFace([]);
TextMode(srcOr);
{ NOW, the magic ~~ Mike Shuster, MacTutor <Dec, 85> }
menuRect := menuFrameRect;
WITH menuRect DO
BEGIN { Draw frame, then shadow. }
GetPenState(pnState);
PenNormal;
right := right - menuShadow;
bottom := bottom - menuShadow;
wSetColorMenu(theMenuBar^^.wMenus[i].mh^^.menuID, mceMenuTitle);
EraseRect(menuRect); { Inside shadow. }
PenSize(menuFrame, menuFrame);
FrameRect(menuRect);
{ Inside frame AND shadow: }
InsetRect(menuRect, menuFrame, menuFrame);
;
MoveTo(left + menuShadow, bottom + menuFrame);
PenSize(menuShadow, menuShadow);
Line((right - left + menuFrame), 0);
MoveTo(right + menuFrame, bottom + frameShad);
Line(0, -(bottom - top + menuFrame));
SetPenState(pnState);
END; { WITH menuRect }
lsMenuRect := menuRect; { Save for later ... }
WITH lScreen DO
BEGIN
OffsetRect(menuRect, -left, -top); { LocalToGlobal }
OffsetRect(lsTitleRect, left, top); { GlobalToLocal }
OffsetRect(lsWBMrect, left, top);
END; { WITH lScreen }
{ ... or parentID = mainMenu. }
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
BEGIN
tempRgn1 := NewRgn;
RectRgn(tempRgn1, lsWBMrect);
theMenuBar^^.wMenus[i].cumParentRgn := tempRgn1;
tempRgn2 := NewRgn;
RectRgn(tempRgn2, lsMenuRect);
theMenuBar^^.wMenus[i].menuParentRgn := tempRgn2;
END
ELSE
BEGIN
{ i = Hierarchical Menu # }
j := HiWord(GetParentMenuInfo(theMenuBar, i));
tempRgn1 := NewRgn;
tempRgn2 := theMenuBar^^.wMenus[j].cumParentRgn;
tempRgn3 := theMenuBar^^.wMenus[j].menuParentRgn;
UnionRgn(tempRgn2, tempRgn3, tempRgn1);
theMenuBar^^.wMenus[i].cumParentRgn := tempRgn1;
tempRgn2 := NewRgn;
RectRgn(tempRgn2, lsMenuRect);
theMenuBar^^.wMenus[i].menuParentRgn := tempRgn2;
END;
{ Start fresh with each scrollable Menu: }
saveScrollInfo := longPtr(TopMenuItemLoc)^;
wordPtr(TopMenuItemLoc)^ := menuRect.top;
wordPtr(AtMenuBottomLoc)^ := menuRect.bottom;
{ I encountered a few “cosmetic” problems with Apple’s }
{ MenuDefProc. }
{ 1) the disabled dotted line will overwrite the right }
{ border of the frame. }
{ 2) if there is an icon immediately below the last }
{ item that shows in a scrolling menu, the bottom }
{ border of the frame is overwritten by a portion }
{ of said icon. }
{ The call to ClipRect solves both: }
ClipRect(lsMenuRect);
{ whichItem := 0; -- at beginning of WHILE WaitMouseUp DO }
MenuDefGlue(mDrawMsg, theMenuBar^^.wMenus[i].mh, menuRect, startPt,
whichItem);
strayed := false; { = Mouse on Menu Item OR on Menu }
{ title OR NOT on another Menu. }
WHILE WaitMouseup & NOT strayed DO
{ While still selecting in this Menu ... }
BEGIN
GetMouse(startPt);
lStartPt := startPt;
{ LocalToGlobal }
SubPt(lScreen.topLeft, startPt);
MenuDefGlue(mChooseMsg, theMenuBar^^.wMenus[i].mh, menuRect, startPt,
whichItem);
IF whichItem <> 0 THEN { Item is enabled. }
BEGIN
GetItemCmd(theMenuBar^^.wMenus[i].mh, whichItem, cmdChar);
IF cmdChar = char(hMenuCmd) THEN { a sub Menu ... }
BEGIN
IF aMac2 THEN
parentMCTable := theMenuBar^^.wMCTable;
hierPt := startPt;
GetItemMark(theMenuBar^^.wMenus[i].mh, whichItem, itemMark);
hierMenuHdl := GetMenu(ord(itemMark));
wInsertMenu(theMenuBar, hierMenuHdl, hierMenu);
DetachResource(Handle(hierMenuHdl));
IF aMac2 THEN
BEGIN
hierMCTable := GetMCInfo;
SetMCInfo(parentMCTable);
theMenuBar^^.wMCTable := hierMCTable;
END; { IF aMac2 }
hierSelect := wMenuSelect(theMenuBar, hierPt);
wDeleteMenu(theMenuBar, ord(itemMark));
;
whichMenu := HiWord(hierSelect);
whichItem := LoWord(hierSelect);
IF whichItem <> 0 THEN
{ So a parent Menu Item does NOT blink: }
BEGIN
strayed := true;
Leave;
END;
END
ELSE { a regular Menu }
whichMenu := theMenuBar^^.wMenus[i].mh^^.menuID;
END; { enabled Item }
strayed := NOT PtInRgn(lStartPt, theMenuBar^^.wMenus[i].menuParentRgn)
& NOT PtInRect(lStartPt, lsTitleRect) & PtInRgn(lStartPt, theMenuBar^^.wMenus[i].cumParentRgn);
END; { WHILE WaitMouseup & NOT strayed }
IF (whichItem <> 0) & NOT strayed THEN
FOR blink := 1 TO menuFlashP^ DO
BEGIN
SetPt(NILPt, 0, 0);
MenuDefGlue(mChooseMsg, theMenuBar^^.wMenus[i].mh, menuRect, NILPt,
whichItem);
Delay(flashDelay DIV 4, finalTicks);
MenuDefGlue(mChooseMsg, theMenuBar^^.wMenus[i].mh, menuRect, startPt,
whichItem);
Delay(flashDelay DIV 4, finalTicks);
END; { blinking the selected item }
ClipRect(menuFrameRect);
BackColor(whiteColor);
ForeColor(blackColor);
{ Blit back original screen image. For a Hierarchical menu }
{ item, the off-screen bitMap/pixMap will include a part of }
{ the inverted parent item. Therefore, we must first blit }
{ back and THEN re-invert !!! }
CopyBits(MenuDownOSHdl^^.offBitMapPtr^, thePort^.portBits, menuFrameRect,
menuFrameRect, srcCopy, NIL);
{ Un-hilite the title: }
IF theMenuBar^^.wMenus[i].menuType = regMenu THEN
wHiliteMenu(theMenuBar, 0)
ELSE IF aMac2 THEN
{ i = Hierarchical Menu # }
RedrawParentItem(theMenuBar, i)
ELSE
BEGIN
ClipRect(lsTitleRect);
InvertRect(lsTitleRect);
END;
IF aMac2 THEN
CloseCPort(onCScreenPtr)
ELSE
ClosePort(onBWScreenPtr);
SetPort(theMenuBar^^.wp);
{ Original menuFrameRect in window coordinates: }
ValidRect(MenuDownOSHdl^^.drawingRect);
DisposOffScreen(MenuDownOSHdl);
DisposeRgn(theMenuBar^^.wMenus[i].menuParentRgn);
DisposeRgn(theMenuBar^^.wMenus[i].cumParentRgn);
longPtr(TopMenuItemLoc)^ := saveScrollInfo;
IF theMenuBar^^.wMenus[i].menuType = hierMenu THEN
Leave;
END { IF i >= 0 }
ELSE { User is not over a Menu. }
;
100:
GetMouse(startPt);
LocalToGlobal(startPt);
END; { WHILE WaitMouseUp }
IF whichItem = 0 THEN
wMenuSelect := 0
ELSE
wMenuSelect := BitShift(whichMenu, 16) + whichItem;
200:
IF aMac2 THEN
BEGIN
RGBBackColor(oldBackColor); { “SetColors” is local }
RGBForeColor(oldForeColor); { due to recursion. }
SetMCInfo(origMCTable);
END; { aMac2 }
;
SetClip(oldClip);
DisposeRgn(oldClip);
SetPort(oldPort);
END; { wMenuSelect }
There’s nothing super different in wMenuKey from Jim Matthews’ code except I utilized GetItemCmd to shorten it a tad.
{25}
FUNCTION wMenuKey (theMenuBar: wMenuBarHandle; ch: char): LONGINT;
VAR
i, j, whichMenu, whichItem: INTEGER;
found, enabled: BOOLEAN;
cmdChar: char;
FUNCTION equalChars (c1, c2: char): BOOLEAN;
{ Filter out difference between UPPER and lower case: }
BEGIN
IF c1 IN [‘a’..’z’] THEN
c1 := char(ord(c1) + ord(‘A’) - ord(‘a’));
IF c2 IN [‘a’..’z’] THEN
c2 := char(ord(c2) + ord(‘A’) - ord(‘a’));
equalChars := (c1 = c2);
END; { equalChars }
BEGIN { wMenuKey }
mbHState := HGetState(Handle(theMenuBar));
MoveHHi(Handle(theMenuBar));
HLock(Handle(theMenuBar));
found := false;
i := 0;
WITH theMenuBar^^ DO
BEGIN
WHILE (NOT found) & (i < numMenus) DO
BEGIN
WITH wMenus[i] DO
FOR j := 1 TO CountMItems(mh) DO
BEGIN
GetItemCmd(mh, j, cmdChar);
IF equalChars(cmdChar, ch) THEN
BEGIN
found := true;
whichMenu := mh^^.menuID;
whichItem := j;
Leave; { FOR loop }
END; { IF equalChars }
END; { FOR scanning each individual Menu & }
{ WITH wMenus[i] }
i := i + 1; { IF found, i = correct # plus 1. }
END; { WHILE scanning each whole Menu }
IF found THEN
BEGIN
{ The Item is enabled if both it AND }
{ its Menu title are enabled: }
IF j < 32 THEN
enabled := BitTst(@wMenus[i - 1].mh^^.enableFlags, menuTitleBit
- j)
ELSE
enabled := true; { Items 32 & beyond. }
enabled := enabled & BitTst(@wMenus[i - 1].mh^^.enableFlags, menuTitleBit);
END; { IF found }
END; { WITH theMenuBar^^ }
HSetState(Handle(theMenuBar), mbHState);
IF found & enabled THEN
BEGIN
wHiliteMenu(theMenuBar, whichMenu);
Delay(flashDelay, finalTicks);
wHiliteMenu(theMenuBar, 0);
wMenuKey := BitShift(whichMenu, 16) + whichItem;
END { IF found & enabled }
ELSE
wMenuKey := 0;
END; { wMenuKey }
The prolific comments tell the whole gory story ...
{26}
PROCEDURE wHiliteMenu (theMenuBar: wMenuBarHandle; menuID: INTEGER);
{ NOTE that this PROC is used only for a regular Menu item. }
{ Apple’s MenuDefProc handles a hierarchical Menu item. }
{ For a regular Menu item, we invert the portion of the }
{ titleRect that is both totally visible on the screen and }
{ between the two MSAs. }
CONST
{ What happened to a simple InvertRect ?!!? }
HiliteMode = $938;
VAR
origPort: GrafPtr;
origClip: RgnHandle;
i: INTEGER;
screenBounds, betweenMSAs, visAllTitles, visThisTitle, visString:
Rect;
{ Gotta be local to avoid interference }
{ with the global = mbHState: }
lmbHState: SignedByte;
oldMCTable: MCTableHandle; { Color stuff ... }
oldForeColor, oldBackColor, hiliteForeColor, hiliteBackColor: RGBColor;
oldTxSize, oldTxFont, oldTxMode: INTEGER;
oldTxStyle: Style;
BEGIN
{ Needed because wHiliteMenu is called with pressing }
{ a CMD-key whereupon a window may not be around. }
IF FrontWindow = NIL THEN
EXIT(wHiliteMenu);
lmbHState := HGetState(Handle(theMenuBar));
IF NOT BitTst(@lmbHState, 0) THEN
BEGIN
MoveHHi(Handle(theMenuBar));
HLock(Handle(theMenuBar));
END; { NOT already locked !! }
WITH theMenuBar^^ DO
BEGIN
GetPort(origPort);
SetPort(wp);
origClip := NewRgn;
GetClip(origClip);
;
{ Just as with wMenuSelect PROC because wMenuKey calls us. }
oldTxSize := thePort^.txSize;
oldTxFont := thePort^.txFont;
oldTxStyle := thePort^.txFace;
oldTxMode := thePort^.txMode;
TextSize(sizeFont);
TextFont(systemFont);
TextFace([]);
TextMode(srcOr);
;
IF aMac2 THEN
BEGIN
GetForeColor(oldForeColor);
GetBackColor(oldBackColor);
oldMCTable := GetMCInfo;
SetMCInfo(theMenuBar^^.wMCTable);
END;
screenBounds := gScreen;
GlobalLocal(screenBounds);
betweenMSAs := WBMrect;
{ ... or rightMSArect.left: }
InsetRect(betweenMSAs, leftMSArect.right, 0);
IF SectRect(screenBounds, betweenMSAs, visAllTitles) THEN
BEGIN
{ Un-highlight previously highlighted Menu title by }
{ re-inverting it or re-drawing it if on a machine }
{ with Color QuickDraw. This is similiar to the }
{ gyrations within Apple’s MenuDefProc. The latter }
{ does NOT call _InverRect for a color Mac, but }
{ rather _EraseRect followed by a redraw of the }
{ Menu item. }
IF titleHilited <> noneHilited THEN
BEGIN
WITH wMenus[titleHilited], titleRect DO
BEGIN
IF SectRect(visAllTitles, titleRect, visThisTitle) THEN
BEGIN { ALWAYS true if hilited. }
ClipRect(visThisTitle);
IF aMac2 THEN { See wDrawMenuBar PROC. }
BEGIN
wSetColorMenu(mceMenuBar, mceMenuBar);
EraseRect(visThisTitle);
MoveTo(left + invertOverlap, bottom - (mBarHt - menuFrame - sizeFont)
DIV 2);
wSetColorMenu(mh^^.menuID, mceMenuTitle);
DrawString(mh^^.menuData);
END
ELSE
InvertRect(visThisTitle);
ValidRect(visThisTitle);
END; { IF SectRect: visThisTitle NOT empty }
END; { WITH }
;
titleHilited := noneHilited; { So we don’t re-invert. }
END; { IF hilited }
IF menuID <> 0 THEN
BEGIN
i := 0;
WHILE (i < numMenus) & (wMenus[i].mh^^.menuID <> menuID) DO
i := i + 1;
IF i <> numMenus THEN
WITH wMenus[i] DO
BEGIN
IF SectRect(visAllTitles, titleRect, visThisTitle) THEN
BEGIN
visString := visThisTitle;
WITH visString DO
BEGIN
IF (leftMSArect.right > right - invertOverlap - 2 * menuFrame)
| (screenBounds.left > right - invertOverlap - 2 * menuFrame) THEN
right := right - invertOverlap - 2 * menuFrame;
;
IF (rightMSArect.left < left + invertOverlap + 2 * menuFrame)
| (screenBounds.right < left + invertOverlap + 2 * menuFrame) THEN
left := left + invertOverlap + 2 * menuFrame;
END; { WITH visString }
IF NOT EmptyRect(visString) THEN
BEGIN
ClipRect(visThisTitle);
IF aMac2 THEN
BEGIN
{ Text’s color becomes the background color and the }
{ MenuBar’s background color becomes the foreground. }
wSetColorMenu(menuID, mceMenuTitle);
GetForeColor(hiliteBackColor);
HiliteColor(hiliteBackColor);
wSetColorMenu(mceMenuBar, mceMenuBar);
{ GetBackColor(hiliteForeColor); }
{ RGBBackColor(hiliteForeColor); }
BitClr(Ptr(HiliteMode), pHiliteBit);
END; { on a color machine }
InvertRect(visThisTitle);
ValidRect(visThisTitle);
;
titleHilited := i;
END; { visString NOT empty }
END; { IF SectRect: visThisTitle NOT empty }
END; { IF i <> numMenus & WITH }
END { IF menuID <> 0 }
ELSE { as in HiliteMenu(0). }
; { Taken care of by IF titleHilited <> noneHilited }
END; { IF SectRect: visAllTitles NOT empty }
IF aMac2 THEN
BEGIN
SetMCInfo(oldMCTable);
RGBForeColor(oldForeColor);
RGBBackColor(oldBackColor);
END;
;
TextSize(oldTxSize);
TextFont(oldTxFont);
TextFace(oldTxStyle);
TextMode(oldTxMode);
;
SetClip(origClip);
DisposeRgn(origClip);
SetPort(origPort);
END; { WITH theMenuBar^^ }
HSetState(Handle(theMenuBar), lmbHState);
END; { wHiliteMenu }
Called in response to zooming & growing the window.
Note: NOT zooming = growing.
{27}
PROCEDURE wChangeMenuBarSize (wp: WindowPtr; zooming: BOOLEAN);
BEGIN
mBar := wGetMenuBar(wp);
;
IF mBar <> NIL THEN
BEGIN { Only a part of wClearMenuBar ... }
GetWBMrects(wp, WBMrect, leftMSArect, rightMSArect);
wHiliteMenu(mBar, 0);
IF NOT zooming THEN
{ doZoom calls InvalRect(wp^.portRect) }
InvalRect(rightMSArect);
IF mBar^^.rightScrollPoly <> NIL THEN
BEGIN
KillPoly(mBar^^.rightScrollPoly);
mBar^^.rightScrollPoly := NIL; { Mark as gone !! }
END;
IF zooming & (mBar^^.leftScrollPoly <> NIL) THEN
BEGIN
KillPoly(mBar^^.leftScrollPoly);
mBar^^.leftScrollPoly := NIL;
END;
END; { window has a WBM }
END; { wChangeMenuBarSize }
END. { UNIT = wBarMenuProc }
Thank goodness it’s over ...
I lie ... even though I have NOT presented the source in “wBMBalloons.p” here, the application incorporates Balloon Help as in big System 7.0 ...and here’s a sneak preview ...
{28}
UNIT wBMBalloons;
INTERFACE
USES
Types, Quickdraw, Menus, TextEdit, Traps, GestaltEqu, Balloons, wBMGlobals,
wBMMiscSubs, wBMScrollSubs;
FUNCTION HelpManagerActive: BOOLEAN;
FUNCTION BalloonsOn: BOOLEAN;
FUNCTION BalloonShowing: BOOLEAN;
PROCEDURE FindAndShowDynamicBalloons (balloonsUp: BOOLEAN; window: WindowPtr);
PROCEDURE HideBalloons (balloonsUp: BOOLEAN);
PROCEDURE ShowBalloons (balloonsUp: BOOLEAN);
PROCEDURE ResetBalloons (balloonsUp: BOOLEAN);
NOW it’s over, really and truly ..
Well ... almost!!! What about AppleEvents? ... it’s on disk!!
{29}
UNIT myAppleEvents;
INTERFACE
USES
Types, Memory, OSUtils, Quickdraw, Events, Files, AppleTalk, PPCToolbox,
Processes, EPPC, Notification, AppleEvents, Script, Packages, Dialogs,
CTBUtilities, Connections, GestaltEqu, wBMGlobals, wBMMiscSubs;
FUNCTION AppleEventsActive: BOOLEAN;
FUNCTION PPCToolboxActive: BOOLEAN;
FUNCTION DoAEOpenApplication (message: AppleEvent; reply: AppleEvent;
refcon: LONGINT): OSErr;
FUNCTION DoAEOpenDocuments (message: AppleEvent; reply: AppleEvent;
refcon: LONGINT): OSerr;
FUNCTION DoAEPrintDocuments (message: AppleEvent; reply: AppleEvent;
refcon: LONGINT): OSErr;
FUNCTION DoAEQuitApplication (message: AppleEvent; reply: AppleEvent;
refcon: LONGINT): OSErr;
FUNCTION InitAppleEvents: OSErr;
FUNCTION MissedAnyParameters (VAR event: EventRecord; message: AppleEvent):
BOOLEAN;
PROCEDURE DoHighLevelEvent (event: EventRecord);
P.P.S The SARez resource code is on dis k too
SEE!!!
the little guy here this must prove I’m done -->
- SPREAD THE WORD:
- Slashdot
- Digg
- Del.icio.us
- Newsvine
