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”
};

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

calibre 3.1.1 - Complete e-book library...
Calibre is a complete e-book library manager. Organize your collection, convert your books to multiple formats, and sync with all of your devices. Let Calibre be your multi-tasking digital librarian... Read more
Sparkle Pro 2.2 - $79.99
Sparkle Pro will change your mind if you thought building websites wasn't for you. Sparkle is the intuitive site builder that lets you create sites for your online portfolio, team or band pages, or... Read more
Spotify 1.0.57.474. - Stream music, crea...
Spotify is a streaming music service that gives you on-demand access to millions of songs. Whether you like driving rock, silky R&B, or grandiose classical music, Spotify's massive catalogue puts... Read more
beaTunes 5.0.1 - Organize your music col...
beaTunes is a full-featured music player and organizational tool for music collections. How well organized is your music library? Are your artists always spelled the same way? Any R.E.M. vs REM?... Read more
LibreOffice 5.3.4.2 - Free, open-source...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
VOX 2.8.26 - Music player that supports...
VOX just sounds better! The beauty is in its simplicity, yet behind the minimal exterior lies a powerful music player with a ton of features and support for all audio formats you should ever need.... Read more
iFFmpeg 6.4.0 - Convert multimedia files...
iFFmpeg is a comprehensive media tool to convert movie, audio and media files between formats. The FFmpeg command line instructions can be very hard to master/understand, so iFFmpeg does all the hard... Read more
Beamer 3.3 - Stream any movie file from...
Beamer streams to your Apple TV.... Plays any movie file - Just like the popular desktop movie players, Beamer accepts all common formats, codecs and resolutions. AVI, MKV, MOV, MP4, WMV, FLV. To... Read more
jAlbum Pro 14.0 - Organize your digital...
jAlbum Pro has all the features you love in jAlbum, but comes with a commercial license. You can create gorgeous custom photo galleries for the Web without writing a line of code! Beginner-friendly... Read more
Apple Remote Desktop Client 3.9.3 - Clie...
Apple Remote Desktop Client is the best way to manage the Mac computers on your network. Distribute software, provide real-time online help to end users, create detailed software and hardware reports... Read more

Latest Forum Discussions

See All

This War of Mine gets a new ending and m...
This War of Mine just got a big new update, featuring free DLC that adds a new ending to the game, among other exciting changes. The update is celebrating the game's two-year release anniversary. Apart from the new ending, which will be quite... | Read more »
Summon eight new heroes in Fire Emblem H...
Nintendo keeps coming at us with Fire Emblem Heroes updates, and it doesn't look like that trend is stopping anytime soon. The folks behind the game have just announced the new War of the Clerics Voting Gauntlet, expected to start next Tuesday. [... | Read more »
The best deals on the App Store this wee...
iOS publishers are pulling out all the stops this week -- there's a huge number of seriously great games at discounted prices this week. Let's not waste any time and get right down to business. [Read more] | Read more »
The House of da Vinci (Games)
The House of da Vinci 1.0.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0.0 (iTunes) Description: Enter The House of Da Vinci, a new must-try 3D puzzle adventure game. Solve mechanical puzzles, discover hidden... | Read more »
Solve the disappearance of history’s gre...
Blue Brain Games invites you to indulge in an immersive hands-on 3D puzzle adventure in similar vein to The Room series, with its debut release The House of Da Vinci. Set during the historic period of the Italian Renaissance (when Leonardo himself... | Read more »
Age of Rivals (Games)
Age of Rivals 3.3 Device: iOS Universal Category: Games Price: $.99, Version: 3.3 (iTunes) Description: Deep civilization-building strategy in a fast-paced card game! | Read more »
Panthera Frontier (Games)
Panthera Frontier 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: | Read more »
Angry Birds Evolution beginner's gu...
Angry Birds changes things up a fair bit in its latest iteration, Angry Birds Evolution. The familiar sling-shot physics mechanics are still there, but the game now features team-based gameplay, RPG elements, and a new top-down view. With all of... | Read more »
Sega Forever is for the retro game fans
Sega is launching a new retro games service titled Sega Forever, in a move that's sure to delight games enthusiasts with a bit of nostalgia. Sega's releasing five classic games for free. The titles include Sonic the Hedgehog, Phantasy Star II,... | Read more »
The Little Acre (Games)
The Little Acre 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: | Read more »

Price Scanner via MacPrices.net

ABBYY TextGrabber 6 for iOS Implements Instan...
ABBYY has announced the release of TextGrabber 6.0.0, an important feature update to the company’s productivity app developed for iOS and Android devices. TextGrabber 6.0 now offers Real-Time... Read more
vPhone, First Smartphone That Can’t Be Lost,...
Austin, Texas based Hypori has introduced the vPhone, a virtual smartphone that affords every business user the benefits of separate work and personal phones, conveniently delivered on a single... Read more
Save this weekend with 2016 refurbished MacBo...
Apple has dropped prices on Certified Refurbished 2016 15″ and 13″ MacBook Pros by as much as $590 off original MSRP. An Apple one-year warranty is included with each model, and shipping is free: -... Read more
New 27-inch 3.4GHz iMac on sale for $1699, sa...
MacMall has the new 2017 27″ 3.4GHz iMac (MNE92LL/A) in stock and on sale for $1699 including free shipping. Their price is $100 off MSRP. Read more
Clearance 2016 MacBook Pros available for up...
B&H Photo has clearance 2016 13″ and 15″ MacBook Pros in stock today and on sale for up to $400 off original MSRP. Shipping is free, and B&H charges NY & NJ sales tax only: - 15″ 2.7GHz... Read more
Apple Ranks 9th In comScore Top 50 U.S. Digit...
comScore, Inc. has released its monthly ranking of U.S. online activity at the top digital media properties for May 2017 based on data from comScore Media Metrix Multi-Platform. * Entity has... Read more
10.5-inch iPad Pros available for up to $20 o...
B&H Photo has the new 2017 10.5″ iPad Pros available for up to $20 off MSRP including free shipping plus NY & NJ sales tax only: - 64GB iPad Pro WiFi: $649 - 256GB iPad Pro WiFi: $749 - 512GB... Read more
Three Off-The-Beaten-Track iOS Apps That Dese...
One of the great things about using iPads and iPhones is the vast selection of apps available for most anything you want or need to do. The three outlined in this article have been in my core app... Read more
Apple No. 1 Spot In Gartner Top 100 Vendors i...
Gartner, Inc. has unveiled the top global 100 vendors in IT in 2016 based on their revenue across IT (excluding communication services) and component market segments. In the Gartner Global Top 100:... Read more
Clearance iMacs available for up to $300 off...
B&H Photo has clearance 21″ and 27″ Apple iMacs available starting at $949, each including free shipping plus NY & NJ sales tax only: - 27″ 3.3GHz iMac 5K: $1999 $300 off original MSRP - 27″... Read more

Jobs Board

*Apple* News Product Marketing Mgr., Publish...
…organizational consensus on strategy and vision for publisher tools, authoring, and Apple News Format.Carries this strategy and vision across the organization to Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Security Data Analyst - *Apple* Information...
…data sources need to be collected to allow Information Security to better protect Apple employees and customers from a wide range of threats.Act as the subject matter Read more
Lead *Apple* Solutions Consultant - Apple I...
…integrity, and trust.Success Metrics/Key Performance Indicators:Quantitative* Year over Year growth in Apple Product and Beyond the Box sales in the assigned Point of Read more
*Apple* Solutions Consultant till v%u00E5r...
…ethics, integrity, and trust.Success Metrics/Key Performance Indicators:QuantitativeYear over Year growth in Apple Product and Beyond the Box sales in the assigned Point Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.