TweetFollow Us on Twitter

Menu Hide, Seek
Volume Number:7
Issue Number:2
Column Tag:Pascal Procedures

Related Info: Menu Manager Script Manager Window Manager

Menu Bar Hide & Seek

By D. Grant Leeper, Buena Park, CA

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

[Grant has been programming the Mac since the original 128K model back in 1984. He is currently working on a 3D graphics library for MacApp and a set of HyperCard XFCNs that allow HyperCard users to access the Script Manager 2.0 extended date, geographic location, and number formatting facilities. He is also available for contract programming work and can be contacted on CompuServe at 70157,1670 or on AppleLink at D0428.]

The Disclaimer

The techniques described in this article should work on any current Macintosh computer with the 128K ROMs or newer (512KE, Plus, SE series, II series) using system 6.0.4 or less, with or without MultiFinder running. However several of the steps described violate Apple’s rules for future compatibility and could break in the future. Take this into account when implementing these techniques. These techniques are not supported by Apple, if they break don’t blame Apple (or me), you were warned!

Now, having said all that, on with the story.

The Introduction

So, in spite of all you’ve heard about future compatibility you have a case where you just absolutely, positively have to hide the menu bar in your application. This is the story of how you can do it.

The accompanying Pascal unit which I have called ShowHideMBar provides the basic tools required to hide and redisplay the menu bar. When the menu bar is hidden command key equivalents to items in the menu bar will still work. In addition, you can detect a mouse click in the hidden menu bar and react to it by displaying the menu bar, or just the menus, long enough to issue a single menu command.

I have also provided a sample application to demonstrate the use of this unit. It is similar to sample applications provided by Apple’s own MacDTS and so it is rather sparsely commented. For the most part the only comments in the code are those that apply to hiding the menu bar. It is probably simpler for readers to apply the techniques I describe to an existing application of their own rather than typing in the entire example.

The Warning

A warning is appropriate here. Under MultiFinder, it is an extremely bad idea to allow an application to become suspended or worse to quit while the menu bar is hidden. If an application gets suspended without redisplaying the menu bar the new foreground application will not have a menu bar visible. The user could end up trapped in an application with no menu bar and no way out but to quit or reboot. The situation is worse if an application exits without redisplaying the menu bar. The unit ShowHideMBar saves the menu bar height as it existed before hiding the menu bar. It uses this to restore the menu bar and desktop when the menu bar is to be made visible again. If the application exits this information is lost.

Note that this warning does not apply to what Apple calls “minor switching” and “update switching” (Tech Note #180, revised June 1989). Minor switching is when a foreground application goes to sleep and background tasks receive null events to perform background processing. Null events do not affect the menu bar so this is not a problem. Update switching is when background applications get a chance to update their windows. Since the disappearance of the menu bar can make previously hidden portions of background windows visible as well as our own, we actually want this to happen.

Without MultiFinder the desktop is currently rebuilt when an application exits. But since there’s no approved way for an application to tell if MultiFinder is running it’s best to just assume it will be and code for it.

The sample application shows how to deal with this properly for a finished application. It is important to be careful though when debugging an application because the menu bar may not be visible when entering a debugger. For low level debuggers like MacsBug this means you don’t want to issue an exit to shell or restart the application command from the debugger if the menu bar is hidden. For high level debuggers like SADE which use menu bars of their own you will not be able to access the menu bar with the mouse if you enter it with the menu bar hidden.

The Tools

There are five public routines defined in this unit, they are declared as follows:

PROCEDURE HideMenuBar;

You call HideMenuBar when you want to make the menu bar invisible. You can call it as soon as you have done the standard toolbox initializations if you want the menu bar to be initially (or always) hidden. Or you can call it in response to a request from the user. Calling it with the menu bar already hidden will have no effect.

PROCEDURE ShowMenuBar;

Call ShowMenuBar to display the menu bar if it is hidden, usually in response to a request from the user, but also when suspending or quitting. Calling it with the menu bar already showing will have no effect.

FUNCTION  MenuBarVisible: BOOLEAN;

This function allows the application to determine if the menu bar is currently visible.

FUNCTION  PtInMenuBar(pt: Point): BOOLEAN;

Call this to find out if a point would be in the menu bar if it were visible. If FindWindow returns inDesk and this function returns TRUE you could display the menu bar long enough for the user to issue a single menu command.

FUNCTION  HiddenMenuSelect(startPt: Point): LONGINT;

This routine is equivalent to the toolbox trap MenuSelect except that it can be called when the menu bar is hidden. If in response to a mouse down event FindWindow returns inDesk and PtInMenuBar returns TRUE, you can call this function to allow the user to issue a menu command. It does not make the menu bar visible but only draws individual menus as they are selected. If you want to display the entire menu bar at this time call ShowMenuBar first then HiddenMenuSelect followed by HideMenuBar.

The Way It All Works

The Mac keeps track of the desktop and the menu bar by using low-memory global variables. In order to hide the menu bar we have to modify some of these variables (which are usually considered read only at best, this is why these techniques are subject to breaking. Remember these techniques break some of the rules! Use them cautiously.

The variables we are concerned with are MBarHeight and GrayRgn. MBarHeight is the height, in pixels, of the menu bar at the top of the main screen. GrayRgn is a handle to a region that defines the desktop. If there are multiple monitors in use on a Mac the desktop will include them all. GrayRgn includes all of the normally gray area on an empty desktop. It does not include the menu bar or the area outside the rounded corners at the four corners of the desktop’s bounding box .

In order to hide the menu bar we first set the low-memory variable MBarHeight to 0 while saving its existing value for when we want to make it visible again. Next we add the area occupied by the menu to GrayRgn. Then we repaint the menu bar as part of the desktop, generating update events for any windows that intersect the menu bar. And finally, again for any windows that intersect the menu bar, we add the overlap with the menu bar to their visRgn fields. The first two steps are easy, the last two are done for us by calling the two low-level window manager routines PaintBehind and CalcVisBehind which I’ll describe shortly.

In order to redisplay a hidden menu bar we follow a similar procedure. First we restore the variable MBarHeight to its previous value. Then we remove the area occupied by the menu bar from GrayRgn. Next we remove the area that overlaps the menu bar from the visRgn fields of any windows that intersect the menu bar, again using CalcVisBehind. And, finally we redraw the menu bar.

Accessing MBarHeight and GrayRgn is simple. On machines with the 128K or larger ROMs the menu bar height is stored as a word at low-memory location $0BAA. The variable MBarHeight is not present on machines with the original 64K ROM. On these machines the menu bar height is always 20 pixels and cannot be changed. We can’t hide the menu bar on old ROM machines. GrayRgn is stored in the long word at location $09EE on all Macintoshes.

The Script Manager provides the following Pascal inline function to read the menu bar height:

FUNCTION  GetMBarHeight: INTEGER;
 INLINE $3EB8, $0BAA;
 { MOVE MBarHeight,(SP) }

The Window Manager provides a similar function for getting the contents of GrayRgn:

FUNCTION  GetGrayRgn: RgnHandle;
 INLINE $2EB8, $09EE;
 { MOVE.L GrayRgn,(SP) }

We will use the following inline function to change the menu bar height (writing to low memory global variables is bad programming practice, we do it here only because there is no other way):

PROCEDURE SetMBarHeight(height: INTEGER);
 INLINE $31DF, $0BAA;
 { MOVE (SP)+, MBarHeight }

We don’t need a SetGrayRgn routine, since it’s a handle we can manipulate it in place where necessary. Modifying GrayRgn is also bad programming, again we do it only because there’s no other way.

I provide the routine GetMBarRgn to determine the area to add to and subtract from GrayRgn when we hide and show the menu bar respectively. The menu bar is always drawn with both of its top corners rounded. When we expand GrayRgn, however, we want the added area to be contiguous with the existing GrayRgn. For this reason we will only round a corner of the menu bar region if that corner coincides with a corner of GrayRgn’s bounding box. This will look better on systems with multiple monitors. It’s possible for example to have two monitors with one stacked on top of the another. The menu bar can be at the top of the bottom monitor, dividing the total screen area in two. When we remove the menu bar we don’t want to leave the menu bar’s round corners poking into the middle of the screen.

GetMBarRgn starts by unioning the menu bar rectangle (the top MBarHeight lines of screenBits.bounds) with the bounding box of GrayRgn. This is always the total screen area no matter how many monitors are in use. It then creates a round cornered region out of this and intersects it with the menu bar rectangle. This intersection is the region we will add to or subtract from GrayRgn.

After setting the menu bar height to zero and expanding the desktop region it is necessary to redraw the menu bar as part of the desktop, and to add any window overlap with the menu bar to the visRgn fields of the affected windows. For this we use the low-level Window Manager traps PaintBehind and CalcVisBehind. These traps are declared as follows:

PaintBehind(startWindow: WindowPeek; clobberedRgn: RgnHandle);

CalcVisBehind(startWindow: WindowPeek; clobberedRgn: RgnHandle);

PaintBehind redraws the intersection of clobberedRgn and the desktop, including the window frames of startWindow and all the windows behind it, and for any of these windows whose content regions intersect clobberedRgn it generates the needed update events.

CalcVisBehind recalculates the visRgn fields of all windows on the desktop, behind and including startWindow, that intersect clobberedRgn.

When we call either of these traps we pass them the result of FrontWindow for startWindow and the result of GetMBarRgn for clobberedRgn. We call these two traps in sequence to reconstruct the desktop after it has been expanded. We call CalcVisBehind followed by DrawMenuBar to reconstruct the desktop after it has been reduced.

The Way You Use It

You only need to make a few parts of your application “menu bar aware.”

If your application is to be compatible with old ROM machines (64K ROM or Macintosh XL) make all calls to ShowHideMBar routines conditional on the presence of the 128K ROM. Otherwise just check for it once in your initialization routine and exit gracefully if it is not available.

Call HideMenuBar in your initialize routine to have the menu bar initially hidden. Call it after initializing the toolbox and checking that the 128K ROM or newer is available.

Anywhere you call ExitToShell first call ShowMenuBar. If this is in a failure handler that could be called because the 128K ROM is unavailable check for the ROM first.

Call HideMenuBar and ShowMenuBar in response to whatever user commands you define for hiding and showing the menu bar. A good suggestion is to use command-space as a toggle command. This is what HyperCard uses and your users will probably be familiar with it.

To determine if the menu bar is currently visible call MenuBarVisible.

Support MultiFinder suspend/resume events. In response to a suspend message save the result of MenuBarVisible in a global variable and call ShowMenuBar. In response to a resume event check this global variable and call HideMenuBar if it is FALSE. If for some reason you are not supporting suspend/resume events then you should respond to deactivate/activate events in this manner instead. But, this will cause the (usually undesirable) side effect of briefly displaying the hidden menu bar whenever a different one of your application’s windows is activated.

You can allow the user to make menu selections even when the menu bar is hidden. To do this call PtInMenuBar with the global coordinates of the mouse in response to a mouse down event when FindWindow returns inDesk. Checking for inDesk avoids confusing mouse downs intended for windows with those intended for the menu bar. If it returns TRUE then call HiddenMenuSelect, optionally bracket by calls to ShowMenuBar and HideMenuBar. Calling the show and hide routines here causes the entire menu bar to be made temporarily visible while the user makes a menu selection. If you do not call these then the menu bar will not be drawn, instead the individual menus will appear magically from nowhere as they are selected.

The Wrap-Up

Well that’s about it. It’s really much simpler to use than to write about. Just have a look at the source code and have fun.

Listing:  HideMenuBarExample.make

#HideMenuBarExample.make
#MPW 3.0 make file for menu bar hiding example
#Copyright © 1989 D. Grant Leeper.
#All rights reserved.
#Publication rights granted to MacTutor.

POptions =-r

srcs =  :Sources:
objs =  :Objects:

objects = {objs}HideMenuBarExample.p.o 
 {objs}ShowHideMBar.p.o

{objs} ƒ{srcs}

HideMenuBarExample.p.o ƒ  ShowHideMBar.p.o

HideMenuBarExample ƒƒ{objects}
 Link {objects} -o {Targ} 
 “{Libraries}”Runtime.o 
 “{Libraries}”Interface.o 
 “{PLibraries}”PasLib.o

HideMenuBarExample ƒƒ 
 {srcs}HideMenuBarExample.r
 Rez {srcs}HideMenuBarExample.r -a -o {Targ}
 DeRez {targ} -only vers > DeRez.out
 Rez DeRez.out -a -m 
 -o HideMenuBarExample.make
 Rez DeRez.out -a -m 
 -o {srcs}ShowHideMBar.p
 Rez DeRez.out -a -m 
 -o {srcs}HideMenuBarExample.p
 Rez DeRez.out -a -m 
 -o {srcs}HideMenuBarExample.r
 Rez DeRez.out -a -m 
 -o {objs}ShowHideMBar.p.o
 Rez DeRez.out -a -m 
 -o {objs}HideMenuBarExample.p.o
 Delete DeRez.out
Listing:  ShowHideMBar.p

{
ShowHideMBar.p
MPW 3.0 Pascal unit to hide the menu bar
Copyright © 1989 D. Grant Leeper.
All rights reserved.
Publication rights granted to MacTutor.

NOTE: The calling application is responsible for
insuring that the menu bar is left visible after
suspending and quitting!

CAUTION: This code violates the guidelines for
future compatibility, use it at your own risk.
Specifically it modifies the GrayRgn and
MBarHeight global variables, and paints and
manipulates the window manager port.
Also, since it modifies MBarHeight it requires
the 128K (or newer) ROMs.
}

UNIT ShowHideMBar;

INTERFACE

USES
 Types, QuickDraw, Events,
 Controls, Windows, Menus;

PROCEDURE HideMenuBar;

PROCEDURE ShowMenuBar;

FUNCTION  MenuBarVisible: BOOLEAN;

FUNCTION  PtInMenuBar(pt: Point): BOOLEAN;

FUNCTION  HiddenMenuSelect(startPt: Point): LONGINT;

IMPLEMENTATION

VAR
 gSavedMBarHeight: INTEGER;
(*
CONST
 GrayRgn =$09EE;
 MBarHeight =  $0BAA;

{ Defined in Windows.p }
FUNCTION  GetGrayRgn: RgnHandle;
 INLINE $2EB8, $09EE; { MOVE.L GrayRgn,(SP) }
*)
{ Defined in Script.p }
FUNCTION  GetMBarHeight: INTEGER;
 INLINE $3EB8, $0BAA; { MOVE MBarHeight,(SP) }

PROCEDURE SetMBarHeight(height: INTEGER);
 INLINE $31DF, $0BAA; { MOVE (SP)+,MBarHeight }

FUNCTION  GetWindowList: WindowPtr;
 INLINE $2EB8, $9D6; { MOVE.L WindowList,(SP) }

{$S ShowHideMBar}
FUNCTION  GetMBarRgn: RgnHandle;
 VAR
 r:Rect;
 worldRgn:RgnHandle;
 mBarRgn: RgnHandle;
 BEGIN
 { Compute worldRgn, the round cornered
   rectangle that bounds all screens }
 r := GetGrayRgn^^.rgnBBox;
 UnionRect(r, screenBits.bounds, r);
 worldRgn := NewRgn;
 OpenRgn;
 FrameRoundRect(r, 16, 16);
 CloseRgn(worldRgn);
 
 { Compute mBarRgn, the intersection
   of the menu bar’s rectangle with
   worldRgn. }
 r := screenBits.bounds;
 r.bottom := r.top + gSavedMBarHeight;
 mBarRgn := NewRgn;
 RectRgn(mBarRgn, r);
 SectRgn(worldRgn, mBarRgn, mBarRgn);
 
 DisposeRgn(worldRgn);
 GetMBarRgn := mBarRgn
 END; { GetMBarRgn }

{$S ShowHideMBar}
PROCEDURE HideMenuBar;
 VAR
 mBarHeight:INTEGER;
 grayRgn: RgnHandle;
 menuBarRgn:RgnHandle;
 startWindow:  WindowPeek;
 BEGIN
 mBarHeight := GetMBarHeight;
 IF mBarHeight <> 0 THEN
 BEGIN
 grayRgn := GetGrayRgn;
 { GSavedMBarHeight must be valid when calling GetMBarRgn }
 gSavedMBarHeight := mBarHeight;
 menuBarRgn := GetMBarRgn;
 SetMBarHeight(0);
 { Add menuBarRgn to GrayRgn. }
 UnionRgn(grayRgn, menuBarRgn, grayRgn);
 { Now tell the Window Manager that the
   desktop has expanded, so the area
   under the menu bar will get
   updated correctly.  We do this by
   calling two of the low-level
   Window Manager routines PaintBehind
   and CalcVisBehind. }
 startWindow := WindowPeek(GetWindowList);
 { PaintBehind redraws the desktop,
   including window frames, as made
   necessary by the removal of the menu
   bar.  It also generates the needed
   window update events. }
 PaintBehind(startWindow, menuBarRgn);
 { CalcVisBehind recalculates any window
   visRgns that need to be changed to
   allow for the removal of the menu bar. }
 CalcVisBehind(startWindow, menuBarRgn);
 DisposeRgn(menuBarRgn)
 END { IF }
 END; { HideMenuBar }

{$S ShowHideMBar}
PROCEDURE ShowMenuBar;
 VAR
 grayRgn: RgnHandle;
 menuBarRgn:RgnHandle;
 BEGIN
 IF GetMBarHeight = 0 THEN
 BEGIN
 grayRgn := GetGrayRgn;
 menuBarRgn := GetMBarRgn;
 SetMBarHeight(gSavedMBarHeight);
 { Remove menuBarRgn from GrayRgn }
 DiffRgn(grayRgn, menuBarRgn, grayRgn);
 { Now tell the Window Manager that the
   menu bar is no longer part of the
   desktop.  We do this by calling
   CalcVisBehind again.  We do not need
   to call PaintBehind first because we
   are not expanding the desktop. }
 CalcVisBehind(WindowPeek(GetWindowList), menuBarRgn);
 DisposeRgn(menuBarRgn);
 { Now redraw the menu bar on the desktop. }
 DrawMenuBar
 END { IF }
 END; { ShowMenuBar }

{$S ShowHideMBar}
FUNCTION  MenuBarVisible: BOOLEAN;
 BEGIN
 MenuBarVisible := GetMBarHeight <> 0
 END; { MenuBarVisible }

{$S ShowHideMBar}
FUNCTION  PtInMenuBar(pt: Point): BOOLEAN;
 VAR
 height:INTEGER;
 r:Rect;
 BEGIN
 height := GetMBarHeight;
 IF height = 0 THEN
 { Menu bar is hidden. }
 height := gSavedMBarHeight;
 r := screenBits.bounds;
 r.bottom := r.top + height;
 PtInMenuBar := PtInRect(pt, r)
 END; { PtInMenuBar }

{$S ShowHideMBar}
FUNCTION  HiddenMenuSelect
 (startPt: Point): LONGINT;
 VAR
 wasHidden: BOOLEAN;
 BEGIN
 wasHidden := GetMBarHeight = 0;
 IF wasHidden THEN
 { Change it temporarily. }
 SetMBarHeight(gSavedMBarHeight);
 { Now do normal MenuSelect }
 HiddenMenuSelect := MenuSelect(startPt);
 IF wasHidden THEN
 BEGIN
 { We must unhilite the menu ourselves
   before setting MBarHeight back to 0. }
 HiliteMenu(0);
 { Now change it back. }
 SetMBarHeight(0)
 END { IF }
 END; { HiddenMenuSelect }

END. { ShowHideMBar }
Listing:  HideMenuBarExample.p

{
HideMenuBarExample.p
MPW 3.0 Pascal source for menu bar hiding example.
Copyright © 1989 D. Grant Leeper.
All rights reserved.
Publication rights granted to MacTutor.
}

PROGRAM HideMenuBarExample;

USES
 Types, Resources, QuickDraw, Fonts, Events,
 Controls, Windows, Menus, TextEdit, Dialogs,
 ToolUtils, OSUtils, SegLoad, Files, Packages,
 Desk, DiskInit, Memory, OSEvents,
 Traps, ShowHideMBar;

CONST
 kSysEnvironsVersion =  1;
 
 kMinHeap = 7 * 1024;
 kMinSpace =2 * 1024;
 
 kMinDocH = 424;
 kMinDocV = 70;
 
 kScrollBarAdjust =15;
 
 kExtremeNeg =   -32768;
 kExtremePos =   32767 - 1;

 rWindow =128;
 rMenuBar = 128;
 rAboutAlert =   128;
 rFatalAlert =   129;
 
 rMessages =128;
 iSelectApp =    1;
 iSelectWind =   2;
 iAltSelectWind =3;
 iCommandSpace = 4;
 iAltCommandSpace =5;
 iClick = 6;
 iCommandClick = 7;
 
 mApple = 128;
 iAbout = 1;
 
 mFile =129;
 iClose = 1;
 iQuit =2;
 
 mEdit =130;
 iUndo =1;
 iCut = 3;
 iCopy =4;
 iPaste = 5;
 iClear = 6;
 
VAR
 gMac:  SysEnvRec;
 gHasWaitNextEvent:BOOLEAN;
 gInBackground:  BOOLEAN;
 { This keeps track of when we need to
   adjust the menus }
 gDirtyMenus:    BOOLEAN;
 { gHasMenuBar saves the visibility of the
   menu bar while we’re in the background. }
 gHasMenuBar:    BOOLEAN;
 { Create these once rather than each time
   through the event loop. }
 gOutsideRgn:    RgnHandle;
 gInsideRgn:RgnHandle;

{$S Main}
FUNCTION  IsDAWindow(window: WindowPtr): BOOLEAN;
 BEGIN
 IsDAWindow :=
 (window <> NIL) &
 (WindowPeek(window)^.windowKind < 0)
 END; { IsDAWindow }

{$S Main}
FUNCTION  IsAppWindow(window: WindowPtr): BOOLEAN;
 BEGIN
 IsAppWindow :=
 (window <> NIL) &
 (WindowPeek(window)^.windowKind =
  userKind)
 END; { IsAppWindow }

{$S Main}
PROCEDURE DoToAllAppWindows(
 PROCEDURE DoThis(window: WindowPtr));
 VAR
 window:WindowPeek;
 BEGIN
 window := WindowPeek(FrontWindow);
 WHILE window <> NIL DO
 BEGIN
 IF window^.windowKind = userKind THEN
 DoThis(WindowPtr(window));
 window := window^.nextWindow
 END { WHILE }
 END; { DoToAllAppWindows }

{$S Main}
PROCEDURE FatalError;
 VAR
 itemHit: INTEGER;
 BEGIN
 SetCursor(arrow);
 itemHit := CautionAlert(rFatalAlert, NIL);
 { Be sure the menu bar is visible at exit
   time, but check first for the 128K ROM
   since we may have been called because
   it’s not available. }
 IF gMac.machineType >= 0 THEN
 ShowMenuBar;
 ExitToShell
 END; { FatalError }

{$S Main}
FUNCTION  DoCloseWindow(window: WindowPtr): BOOLEAN;
 BEGIN
 DoCloseWindow := TRUE;
 IF IsAppWindow(window) THEN
 BEGIN
 CloseWindow(window);
 DisposPtr(Ptr(window))
 END { IF }
 ELSE IF IsDAWindow(window) THEN
 CloseDeskAcc(WindowPeek(window)^.windowKind)
 END; { DoCloseWindow }

{$S Initialize}
PROCEDURE BringAppToFront;
 VAR
 count: INTEGER;
 event: EventRecord;
 BEGIN
 FOR count := 1 TO 3 DO
 IF EventAvail(everyEvent, event) THEN
 ; { Ignore it }
 END; { BringAppToFront }

{$S Initialize}
PROCEDURE Initialize;
 VAR
 bIgnore: BOOLEAN;
 event: EventRecord;
 ignore:OSErr;
 total: LONGINT;
 contig:LONGINT;
 storage: Ptr;
 window:WindowPtr;
 menuBar: Handle;
 
 BEGIN
 InitGraf(@thePort);
 InitFonts;
 InitWindows;
 InitMenus;
 TEInit;
 InitDialogs(NIL);
 InitCursor;
 
 BringAppToFront;
 
 { SysEnvirons must be called before calling
   FatalError. }
 ignore := SysEnvirons(kSysEnvironsVersion, gMac);
 
 { Need 128K ROMS to change menu bar height. }
 IF gMac.machineType < 0 THEN
 FatalError;
 
 { The menu bar can be hidden now if desired. }
 HideMenuBar;
 
 IF ORD(GetApplLimit) - ORD(ApplicZone) <
    kMinHeap THEN
 FatalError;
 
 PurgeSpace(total, contig);
 IF total < kMinSpace THEN
 FatalError;
 
 gHasWaitNextEvent :=
 GetTrapAddress(_Unimplemented) <>
 NGetTrapAddress(_WaitNextEvent, ToolTrap);
 
 gInBackground := FALSE;
 
 storage := NewPtr(SizeOf(WindowRecord));
 IF storage = NIL THEN
 FatalError;
 IF gMac.hasColorQD THEN
 window := GetNewCWindow(rWindow, storage, Pointer(-1))
 ELSE
 window := GetNewWindow(rWindow, storage, Pointer(-1));
 IF window = NIL THEN
 FatalError;
 
 menuBar := GetNewMBar(rMenuBar);
 IF menuBar = NIL THEN
 FatalError;
 SetMenuBar(menuBar);
 DisposHandle(menuBar);
 AddResMenu(GetMHandle(mApple), ‘DRVR’);
 DrawMenuBar;
 gDirtyMenus := TRUE;
 
 gOutsideRgn := NewRgn;
 gInsideRgn := NewRgn
 END; { Initialize }

{$S Main}
PROCEDURE Terminate;
 VAR
 window:WindowPtr;
 BEGIN
 window := FrontWindow;
 WHILE window <> NIL DO
 IF DoCloseWindow(window) THEN
 window := FrontWindow
 ELSE
 Exit(Terminate);
 { Must restore menu bar
   before quitting }
 ShowMenuBar;
 ExitToShell
 END; { Terminate }

{$S Main}
PROCEDURE AdjustMenus;
 VAR
 window:WindowPtr;
 appWind: BOOLEAN;
 daWind:BOOLEAN;
 redraw:BOOLEAN;
 menu:  MenuHandle;
 wasEnabled:BOOLEAN;
 BEGIN
 window := FrontWindow;
 appWind := IsAppWindow(window);
 daWind := IsDAWindow(window);
 redraw := FALSE;
 
 menu := GetMHandle(mFile);
 IF daWind THEN
 EnableItem(menu, iClose)
 ELSE
 DisableItem(menu, iClose);
 
 menu := GetMHandle(mEdit);
 wasEnabled := Odd(menu^^.enableFlags);
 IF daWind THEN
 BEGIN
 EnableItem(menu, 0);
 EnableItem(menu, iUndo);
 EnableItem(menu, iCut);
 EnableItem(menu, iCopy);
 EnableItem(menu, iPaste);
 EnableItem(menu, iClear)
 END { IF }
 ELSE
 BEGIN
 DisableItem(menu, 0);
 DisableItem(menu, iUndo);
 DisableItem(menu, iCut);
 DisableItem(menu, iCopy);
 DisableItem(menu, iClear);
 DisableItem(menu, iPaste)
 END; { ELSE }
 IF Odd(menu^^.enableFlags) <> wasEnabled THEN
 redraw := TRUE;
 
 IF redraw THEN
 DrawMenuBar
 END; { AdjustMenus }

{$S Main}
PROCEDURE DoMenuCommand(menuResult: LONGINT);
 VAR
 menu:  INTEGER;
 item:  INTEGER;
 ignore:INTEGER;
 name:  Str255;
 window:WindowPtr;
 bIgnore: BOOLEAN;
 
 BEGIN
 menu := HiWrd(menuResult);
 item := LoWrd(menuResult);
 CASE menu OF
 mApple:
 CASE item OF
 iAbout:
 ignore := Alert(rAboutAlert, NIL);
 
 OTHERWISE
 BEGIN
 GetItem(GetMHandle(mApple),
 item, name);
 ignore := OpenDeskAcc(name);
 gDirtyMenus := TRUE
 END { OTHERWISE }
 END; { CASE }
 
 mFile:
 CASE item OF
 iClose:
 BEGIN
 window := FrontWindow;
 IF IsDAWindow(window) THEN
 CloseDeskAcc(WindowPeek(window)^.windowKind);
 gDirtyMenus := TRUE
 END; { iClose }
 iQuit:
 Terminate
 END; { CASE }
 mEdit:
 bIgnore := SystemEdit(item - 1)
 END; { CASE }
 HiliteMenu(0)
 END; { DoMenuCommand }

{$S Main}
PROCEDURE DrawWindow(window: WindowPtr);
 VAR
 str: Str255;
 BEGIN
 SetPort(window);
 EraseRect(window^.portRect);
 DrawGrowIcon(window);
 
 { We display different messages here
   depending on our foreground/background
   and activate/inactivate states. }
 
 IF gInBackground THEN
 BEGIN
 GetIndString(str, rMessages, iSelectApp);
 MoveTo(10, 32);
 DrawString(str)
 END { IF }
 
 ELSE IF window <> FrontWindow THEN
 BEGIN
 IF MenuBarVisible THEN
 GetIndString(str, rMessages, iSelectWind)
 ELSE
 GetIndString(str, rMessages, iAltSelectWind);
 MoveTo(10, 32);
 DrawString(str)
 END { ELSE IF }
 
 ELSE
 IF MenuBarVisible THEN
 BEGIN
 MoveTo(10, 32);
 GetIndString(str, rMessages, iCommandSpace);
 DrawString(str)
 END { IF }
 ELSE
 BEGIN
 MoveTo(10, 16);
 GetIndString(str, rMessages, iAltCommandSpace);
 DrawString(str);
 MoveTo(10, 32);
 GetIndString(str, rMessages, iClick);
 DrawString(str);
 MoveTo(10, 48);
 GetIndString(str, rMessages, iCommandClick);
 DrawString(str)
 END { ELSE }
 END; { DrawWindow }

{$S Main}
PROCEDURE InvalContentRgn(window: WindowPtr);
 VAR
 r:Rect;
 BEGIN
 SetPort(window);
 r := window^.portRect;
 r.bottom := r.bottom - kScrollBarAdjust;
 r.right := r.right - kScrollBarAdjust;
 InvalRect(r)
 END; { InvalContentRgn }

{$S Main}
PROCEDURE InvalAppWindContents;
{ Since our window may be behind some DA windows
  we must check all the windows in our layer. }
 BEGIN
 DoToAllAppWindows(InvalContentRgn)
 END; { InvalAppWindContents }

{$S Main}
PROCEDURE InvalGrowRgn(window: WindowPtr);
 VAR
 r:Rect;
 BEGIN
 SetPort(window);
 r := window^.portRect;
 r.top := r.bottom - kScrollBarAdjust;
 InvalRect(r);
 r := window^.portRect;
 r.left := r.right - kScrollBarAdjust;
 InvalRect(r)
 END; { InvalGrowRgn }

{$S Main}
PROCEDURE DoGrowWindow(window: WindowPtr;
    event: EventRecord);
 VAR
 tempRect:Rect;
 growResult:LONGINT;
 BEGIN
 WITH screenBits.bounds DO
 SetRect(tempRect, kMinDocH, kMinDocV, right, bottom);
 growResult := GrowWindow(window, event.where, tempRect);
 IF growResult <> 0 THEN
 BEGIN
 InvalGrowRgn(window);
 SizeWindow(window, LoWrd(growResult),
    HiWrd(growResult), TRUE);
 InvalGrowRgn(window)
 END { IF }
 END; { DoGrowWindow }

{$S Main}
PROCEDURE DoZoomWindow(window: WindowPtr; part: INTEGER);
 BEGIN
 SetPort(window);
 EraseRect(window^.portRect);
 ZoomWindow(window, part, FALSE)
 END; { DoZoomWindow }

{$S Main}
PROCEDURE DoUpdate(window: WindowPtr);
 BEGIN
 IF IsAppWindow(window) THEN
 BEGIN
 BeginUpdate(window);
 IF NOT EmptyRgn(window^.visRgn) THEN
 DrawWindow(window);
 EndUpdate(window)
 END { IF }
 END; { DoUpdate }

{$S Main}
PROCEDURE DoActivate(window: WindowPtr;
  becomingActive: BOOLEAN);
 BEGIN
 IF IsAppWindow(window) THEN
 BEGIN
 { Message to user changes when
   activated or deactivated. }
 InvalContentRgn(window);
 DrawGrowIcon(window);
 gDirtyMenus := TRUE
 END { IF }
 END; { DoActivate }

{$S Main}
PROCEDURE DoDisk(message: LONGINT);
 CONST
 kDILeft =70;
 kDITop = 50;
 VAR
 where: Point;
 BEGIN
 IF HiWrd(message) <> noErr THEN
 BEGIN
 SetPt(where, kDILeft, kDITop);
 IF DIBadMount(where, message) = 0 THEN
 { Ignore it }
 END { IF }
 END; { DoDisk }

{$S Main}
PROCEDURE DoSuspendResume(suspend: BOOLEAN);
 BEGIN
 gInBackground := suspend;
 
 IF suspend THEN
 { Save menu bars visibility for when we resume
   then force the menu bar to be displayed. }
 BEGIN
 gHasMenuBar := MenuBarVisible;
 ShowMenuBar
 END { IF }
 
 ELSE IF NOT gHasMenuBar THEN
 { Resuming, hide the menu bar if it was
   hidden prior to our suspension. }
 HideMenuBar;
 
 DoActivate(FrontWindow, NOT suspend);
 
 { Change message to user when
   suspended or resumed. }
 InvalAppWindContents
 END; { DoSuspendResume }

{$S Main}
PROCEDURE AdjustCursor(mouse: Point;
    cursorRgn: RgnHandle);
 VAR
 window:WindowPtr;
 insideRect:Rect;
 BEGIN
 window := FrontWindow;
 IF NOT gInBackground &
    NOT IsDAWindow(window) THEN
 BEGIN
 SetRectRgn(gOutsideRgn,
 kExtremeNeg, kExtremeNeg, kExtremePos, kExtremePos);
 
 IF IsAppWindow(window) THEN
 BEGIN
 insideRect := window^.portRect;
 insideRect.bottom :=
 insideRect.bottom - kScrollBarAdjust;
 insideRect.right :=
 insideRect.right - kScrollBarAdjust;
 SetPort(window);
 LocalToGlobal(insideRect.topLeft);
 LocalToGlobal(insideRect.botRight);
 RectRgn(gInsideRgn, insideRect)
 END; { IF }
 
 DiffRgn(gOutsideRgn, gInsideRgn, gOutsideRgn);
 
 IF PtInRgn(mouse, gInsideRgn) THEN
 BEGIN
 SetCursor(GetCursor(plusCursor)^^);
 CopyRgn(gInsideRgn, cursorRgn)
 END { IF }
 ELSE
 BEGIN
 SetCursor(arrow);
 CopyRgn(gOutsideRgn, cursorRgn)
 END; { ELSE }
 
 SetEmptyRgn(gOutsideRgn);
 SetEmptyRgn(gInsideRgn)
 END { IF }
 END; { AdjustCursor }

{$S Main}
PROCEDURE DoEvent(event: EventRecord);
 CONST
 kOSEvent = app4Evt;
 kSuspendResumeMessage =  1;
 kResumeMask =   1;
 VAR
 part:  INTEGER;
 window:WindowPtr;
 key: CHAR;
 BEGIN
 CASE event.what OF
 mouseDown:
 BEGIN
 part := FindWindow(event.where, window);
 
 CASE part OF
 inDesk:
 IF PtInMenuBar(event.where) THEN
 { User clicked in hidden menu bar.  Lets show
   off some tricks. }
 BEGIN
 { Show menu bar first if
   command key pressed,
   else just show menus
   without the bar. }
 IF BAnd(event.modifiers, cmdKey) <> 0 THEN
 ShowMenuBar;
 DoMenuCommand(HiddenMenuSelect(event.where));
 { If we showed the menu bar here we must be
   sure HiliteMenu(0) is called before we hide
   it again. In our case DoMenuCommand calls it
   for us. }
 IF BAnd(event.modifiers, cmdKey) <> 0 THEN
 HideMenuBar
 END; { IF }
 inMenuBar:
 DoMenuCommand(MenuSelect(event.where));
 inSysWindow:
 SystemClick(event, window);
 
 inContent:
 IF window <> FrontWindow THEN
 SelectWindow(window);
 inDrag:
 DragWindow(window, event.where, screenBits.bounds);
 inGrow:
 DoGrowWindow(window, event);
 inZoomIn, inZoomOut:
 IF TrackBox(window,event.where, part) THEN
 DoZoomWindow(window, part)
 END { CASE }
 END; { mouseDown }
 keyDown, autoKey:
 BEGIN
 key := Chr(BAnd(event.message, charCodeMask));
 IF BAnd(event.modifiers, cmdKey) <> 0 THEN
 IF event.what = keyDown THEN
 IF key = ‘ ‘ THEN
 { User typed command-space so
   toggle the menu bar. }
 BEGIN
 IF MenuBarVisible THEN
 HideMenuBar
 ELSE
 ShowMenuBar;
 { Change message to user when menu is hidden
   or made visible. }
 InvalAppWindContents
 END { IF }
 ELSE
 DoMenuCommand(
 MenuKey(key))
 END; { keyDown, autoKey }
 activateEvt:
 DoActivate(WindowPtr(event.message),
    BAnd(event.modifiers, activeFlag) <> 0);
 updateEvt:
 DoUpdate(WindowPtr(event.message));
 diskEvt:
 DoDisk(event.message);
 kOSEvent:
 CASE BAnd(BRotL(event.message, 8), $FF) OF
 kSuspendResumeMessage:
 DoSuspendResume(BAnd(event.message,
 kResumeMask) = 0)
 END { CASE }
 END { CASE }
 END; { DoEvent }

{$S Main}
FUNCTION  GlobalMouse: Point;
 CONST
 kNoEvents =0;
 VAR
 ignore:BOOLEAN;
 event: EventRecord;
 BEGIN
 ignore := OSEventAvail(kNoEvents, event);
 GlobalMouse := event.where
 END; { GlobalMouse }

{$S Main}
PROCEDURE EventLoop;
 VAR
 cursorRgn: RgnHandle;
 gotEvent:BOOLEAN;
 event: EventRecord;
 BEGIN
 cursorRgn := NewRgn;
 WHILE TRUE DO
 BEGIN
 IF gDirtyMenus THEN
 BEGIN
 AdjustMenus;
 gDirtyMenus := FALSE
 END; { IF }
 
 AdjustCursor(GlobalMouse, cursorRgn);
 
 IF gHasWaitNextEvent THEN
 gotEvent :=
 WaitNextEvent(everyEvent, event, 30, cursorRgn)
 ELSE
 BEGIN
 SystemTask;
 gotEvent := GetNextEvent(everyEvent,
  event)
 END; { ELSE }
 
 IF gotEvent THEN
 AdjustCursor(event.where, cursorRgn);
 
 DoEvent(event)
 END { WHILE }
 END; { EventLoop }

PROCEDURE _DataInit; EXTERNAL;

BEGIN
UnloadSeg(@_DataInit);
MaxApplZone;
Initialize;
UnloadSeg(@Initialize);
EventLoop
END. { HideMenuBarExample }
Listing:  HideMenuBarExample.r
/*
HideMenuBarExample.r
MPW 3.0 Rez source for menu bar hiding example.
Copyright © 1989 D. Grant Leeper.
All rights reserved.
Publication rights granted to MacTutor.
*/

#include “Types.r”
#include “SysTypes.r”

#define kMinSize 24
#define kPrefSize32

#define rWindow  128
#define rMenuBar 128
#define rAboutAlert128
#define rFatalAlert129
#define rMessages128

#define mApple   128
#define mFile    129
#define mEdit    130

resource ‘WIND’ (rWindow, preload, purgeable) {
 {30, 80, 100, 504},
 zoomDocProc, visible, noGoAway, 0x0,
 “Menu Bar Hiding Example”
};

resource ‘MBAR’ (rMenuBar, preload) {
 { mApple, mFile, mEdit };
};

resource ‘MENU’ (mApple, preload) {
 mApple, textMenuProc,
 0x7FFFFFFF & ~0b10,
 enabled, apple,
 {
 “About HideMenuBarExample ”,
 noicon, nokey, nomark, plain;
 “-”,
 noicon, nokey, nomark, plain
 }
};

resource ‘MENU’ (mFile, preload) {
 mFile, textMenuProc,
 0b10,
 enabled, “File”,
 {
 “Close”,
 noicon, “W”, nomark, plain;
 “Quit”,
 noicon, “Q”, nomark, plain
 }
};

resource ‘MENU’ (mEdit, preload) {
 mEdit, textMenuProc,
 0,
 enabled, “Edit”,
  {
 “Undo”,
 noicon, “Z”, nomark, plain;
 “-”,
 noicon, nokey, nomark, plain;
 “Cut”,
 noicon, “X”, nomark, plain;
 “Copy”,
 noicon, “C”, nomark, plain;
 “Paste”,
 noicon, “V”, nomark, plain;
 “Clear”,
 noicon, nokey, nomark, plain
 }
};

resource ‘ALRT’ (rAboutAlert, purgeable) {
 {60, 40, 184, 340},
 rAboutAlert,
 { /* array: 4 elements */
 /* [1] */
 OK, visible, silent,
 /* [2] */
 OK, visible, silent,
 /* [3] */
 OK, visible, silent,
 /* [4] */
 OK, visible, silent
 }
};

resource ‘DITL’ (rAboutAlert, purgeable) {
 { /* array DITLarray: 5 elements */
 /* [1] */
 {92, 110, 112, 190},
 Button {
 enabled,
 “OK”
 },
 /* [2] */
 {4, 78, 20, 222},
 StaticText {
 disabled,
 “HideMenuBarExample”
 },
 /* [3] */
 {24, 37, 40, 262},
 StaticText {
 disabled,
 “Copyright © 1989 D. Grant Leeper.”
 },
 /* [4] */
 {44, 86, 60, 214},
 StaticText {
 disabled,
 “All rights reserved.”
 },
 /* [5] */
 {64, 19, 80, 281},
 StaticText {
 disabled,
 “Publication rights granted”
 “ to MacTutor.”
 }
 }
};

resource ‘ALRT’ (rFatalAlert, purgeable) {
 {40, 20, 144, 312},
 rFatalAlert,
 { /* array: 4 elements */
 /* [1] */
 OK, visible, silent,
 /* [2] */
 OK, visible, silent,
 /* [3] */
 OK, visible, silent,
 /* [4] */
 OK, visible, silent
 }
};

resource ‘DITL’ (rFatalAlert, purgeable) {
 { /* array DITLarray: 2 elements */
 /* [1] */
 {72, 180, 92, 260},
 Button {
 enabled,
 “OK”
 },
 /* [2] */
 {10, 60, 58, 276},
 StaticText {
 disabled,
 “HideMenuBarExample - An “
 “unexpected error has occurred. “
 “(Probably out of memory.)”
 }
 }
};

resource ‘STR#’ (rMessages, purgeable) {
 { /* array stringArray: 7 elements */
 /* [1] */
 “Bring application to front to hide “
 “menu bar.”,
 /* [2] */
 “Bring window to front to hide menu bar.”,
 /* [3] */
 “Bring window to front to show menu bar.”,
 /* [4] */
 “Press Command-Space to hide menu bar.”,
 /* [5] */
 “Press Command-Space to show menu bar, “
 “or try clicking on the “,
 /* [6] */
 “desktop where a menu title should be, “
 “or try command-clicking “,
 /* [7] */
 “on the desktop where the menu bar “
 “should be.”
 }
};

/*
We are MultiFinder aware and friendly.
We are probably 32 bit compatible as well but
have not been tested in a 32 bit environment.
*/

resource ‘SIZE’ (-1) {
 dontSaveScreen,
 acceptSuspendResumeEvents,
 enableOptionSwitch,
 canBackground,
 multiFinderAware,
 backgroundAndForeground,
 dontGetFrontClicks,
 ignoreChildDiedEvents,
 not32BitCompatible, /* Not tested */
 reserved,
 reserved,
 reserved,
 reserved,
 reserved,
 reserved,
 reserved,
 kPrefSize * 1024,
 kMinSize * 1024 
};

resource ‘vers’ (1) {
 0x1,
 0x0,
 release,
 0x0,
 verUs,
 “1.0”,
 “1.0 © 1989 D. Grant Leeper\n”
 “All rights reserved.”
};

resource ‘vers’ (2) {
 0x1,
 0x0,
 release,
 0x0,
 verUs,
 “1.0”,
 “Hiding The Menu Bar”
};

 
AAPL
$98.63
Apple Inc.
-0.39
MSFT
$43.92
Microsoft Corpora
-0.05
GOOG
$585.19
Google Inc.
-5.41

MacTech Search:
Community Search:

Software Updates via MacUpdate

OS X Yosemite Wallpaper 1.0 - Desktop im...
OS X Yosemite Wallpaper is the gorgeous new background image for Apple's upcoming OS X 10.10 Yosemite. This wallpaper is available for all screen resolutions with a source file that measures 5,418... Read more
Acorn 4.4 - Bitmap image editor. (Demo)
Acorn is a new image editor built with one goal in mind - simplicity. Fast, easy, and fluid, Acorn provides the options you'll need without any overhead. Acorn feels right, and won't drain your bank... Read more
Bartender 1.2.20 - Organize your menu ba...
Bartender lets you organize your menu bar apps. Features: Lets you tidy your menu bar apps how you want. See your menu bar apps when you want. Hide the apps you need to run, but do not need to... Read more
TotalFinder 1.6.2 - Adds tabs, hotkeys,...
TotalFinder is a universally acclaimed navigational companion for your Mac. Enhance your Mac's Finder with features so smart and convenient, you won't believe you ever lived without them. Tab-based... Read more
Vienna 3.0.0 RC 2 :be5265e: - RSS and At...
Vienna is a freeware and Open-Source RSS/Atom newsreader with article storage and management via a SQLite database, written in Objective-C and Cocoa, for the OS X operating system. It provides... Read more
VLC Media Player 2.1.5 - Popular multime...
VLC Media Player is a highly portable multimedia player for various audio and video formats (MPEG-1, MPEG-2, MPEG-4, DivX, MP3, OGG, ...) as well as DVDs, VCDs, and various streaming protocols. It... Read more
Default Folder X 4.6.7 - Enhances Open a...
Default Folder X attaches a toolbar to the right side of the Open and Save dialogs in any OS X-native application. The toolbar gives you fast access to various folders and commands. You just click... Read more
TinkerTool 5.3 - Expanded preference set...
TinkerTool is an application that gives you access to additional preference settings Apple has built into Mac OS X. This allows to activate hidden features in the operating system and in some of the... Read more
Audio Hijack Pro 2.11.0 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Intermission 1.1.1 - Pause and rewind li...
Intermission allows you to pause and rewind live audio from any application on your Mac. Intermission will buffer up to 3 hours of audio, allowing users to skip through any assortment of audio... Read more

Latest Forum Discussions

See All

Note Review
Note Review By Jennifer Allen on July 29th, 2014 Our Rating: :: TOO SIMPLEiPhone App - Designed for the iPhone, compatible with the iPad Note is a note taking app that’s a little too short on features to be worth its asking price... | Read more »
Chainsaw Warrior Goes on Sale & Ther...
Chainsaw Warrior Goes on Sale & There’s a Chance to Win a Copy of the Original Board Game Posted by Jennifer Allen on July 29th, 2014 [ permalink | Read more »
It Came From Canada: Tiny Tower Vegas
If you go to a casino, you might make a lot of money. If you run a casino, you’re guaranteed to make a lot of money. The choice seems pretty obvious. So while waiting for your shady real estate deals to move forward, get prepared with Tiny Tower... | Read more »
Z Hunter Review
Z Hunter Review By Lee Hamlet on July 29th, 2014 Our Rating: :: RIGHT ON TARGETUniversal App - Designed for iPhone and iPad While it might not necessarily break new ground, Z Hunter has enough tricks up its sleeve to ensure that... | Read more »
Huge Update Comes To Duet, Adding 48 New...
Huge Update Comes To Duet, Adding 48 New Stages Posted by Jennifer Allen on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Sharknado: The Video Game Available Now....
Sharknado: The Video Game Available Now. Seriously. Posted by Rob Rich on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Frog Orbs 2 Review
Frog Orbs 2 Review By Nadia Oxford on July 29th, 2014 Our Rating: :: THIS MAGIC IS A TAD MONOTONOUS Universal App - Designed for iPhone and iPad Frog Orbs 2 is repetitive, but younger players should enjoy it nonetheless.   | Read more »
Puzzix Review
Puzzix Review By Jennifer Allen on July 29th, 2014 Our Rating: :: NICE IDEAUniversal App - Designed for iPhone and iPad A little like Tetris, Puzzix is all about piecing together blocks and watching them vanish. It could do with... | Read more »
Cannonball eMail is Now Live – Works Wit...
Cannonball eMail is Now Live – Works With Gmail, Yahoo, Outlook, Hotmail, and AOL Posted by Jessica Fisher on July 29th, 2014 [ permalink ] | Read more »
To The End Review
To The End Review By Lee Hamlet on July 29th, 2014 Our Rating: :: A VICIOUS CYCLEUniversal App - Designed for iPhone and iPad To The End will test players’ patience, timing, and dedication as they try to navigate all 13 levels in... | Read more »

Price Scanner via MacPrices.net

Updated MacBook Pro Price Trackers
We’ve updated our MacBook Pro Price Trackers with the latest information on prices, bundles, and availability on the new 2014 models from Apple’s authorized internet/catalog resellers as well as... Read more
Apple updates MacBook Pros with slightly fast...
Apple updated 13″ and 15″ Retina MacBook Pros today with slightly faster Haswell processors. 13″ models now ship with 8GB of RAM standard, while 15″ MacBook Pros ship with 16GB across the board. Most... Read more
Apple drops price on 13″ 2.5GHz MacBook Pro b...
The Apple Store has dropped their price for the 13″ 2.5GHz MacBook Pro by $100 to $1099 including free shipping. Read more
Apple drops prices on refurbished 2013 MacBoo...
The Apple Store has dropped prices on Apple Certified Refurbished 13″ and 15″ 2013 MacBook Pros, with model now available starting at $929. Apple’s one-year warranty is standard, and shipping is free... Read more
iOS 8 and OS X 10.10 To Support DuckDuckGo As...
Writing for Quartz, Dan Frommer reports that Apple’s forthcoming iOS 8 and OS X 10.10 operating systems version updates will allow users to select DuckDuckGo as their default search engine. He notes... Read more
U.K. Hospital Using iPods and iPads To Record...
British news journal GazetteLive’s. Ian McNeal notes that the old “an apple a day keeps the doctor away” proverb is being turned on its head at http://southtees.nhs.uk/hospitals/james-cook/ James... Read more
13-inch 2.5GHz MacBook Pro on sale for $1099,...
Best Buy has the 13″ 2.5GHz MacBook Pro available for $1099.99 on their online store. Choose free shipping or free instant local store pickup (if available). Their price is $100 off MSRP. Price is... Read more
Roundup of Apple refurbished MacBook Pros, th...
The Apple Store has Apple Certified Refurbished 13″ and 15″ MacBook Pros available for up to $400 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free. Their prices... Read more
Record Mac Shipments In Q2/14 Confound Analys...
A Seeking Alpha Trefis commentary notes that Apple’s fiscal Q3 2014 results released July 22, beat market predictions on earnings, although revenues were slightly lower than anticipated. Apple’s Mac’... Read more
Intel To Launch Core M Silicon For Use In Not...
Digitimes’ Monica Chen and Joseph Tsai, report that Intel will launch 14nm-based Core M series processors specifically for use in fanless notebook/tablet 2-in-1 models in Q4 2014, with many models to... Read more

Jobs Board

Sr Software Lead Engineer, *Apple* Online S...
Sr Software Lead Engineer, Apple Online Store Publishing Systems Keywords: Company: Apple Job Code: E3PCAK8MgYYkw Location (City or ZIP): Santa Clara Status: Full Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Sr. Product Leader, *Apple* Store Apps - Ap...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.