TweetFollow Us on Twitter

Courteous Apps
Volume Number:9
Issue Number:12
Column Tag:C Workshop

Running in the Background

Writing courteous applications

By Geoff Clements, Chelmsford, Massachusetts

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

About the author

Geoff Clements is a radar engineer with a Master’s degree in Electrical Engineering who seems to find himself spending more time programming Macintoshes than directing electromagnetic energy. Geoff lives in Chelmsford, MA with his wife Michele, a dog named Tara, a bird named Disney, and a baby in development.


In a past article (March ’93 issue, Voxels), I described drawing a sphere that appeared 3-dimensional on the Macintosh. The application rendered a three dimensional sphere with two light sources during startup. Rendering images is a time consuming process, so the Macintosh appears to lock up while the sphere drawn. The sphere is rendered into an off screen graphics port so the application need only do it once. The sphere is copied from the off screen port when it is finished. When the screen needs updating the image is just copied from the off screen port. The window containing the drawing can be resized and when the user chooses quit, the application goes politely away. It’s a reasonably well behaved application, except during startup.

Now, I’d like to show how this same application can be modified to render the sphere in the background while the user interacts with another application in the foreground, (in fact the program is running in the background while I’m writing this). Remember that there is a cost to running an application in the background. Both the foreground application and background application will run slower. On the other hand, the cost is small in comparison with having to stare at an unresponsive screen while a time consuming task is being computed.

While we are making modifications we can add some extra code to update the screen with what’s been calculated when the application is brought to the foreground. This way, the user can see what the image looks like before it is done. If the user isn’t happy with the way the image is coming out they can stop it and try some new parameters rather than having to wait for the entire image to be drawn.


In order to understand how an application runs in the background, we need to understand how events are processed. For those of you who already understand events, skip to the source code section.

An event is generated whenever some kind of action happens to, or within, a Macintosh. For example, pressing the mouse button or pressing a key on the keyboard. Events are placed into an event queue, which is a list of events the operating system keeps track of. Even though there are several different event queues in the Macintosh, the Toolbox Event Manager procedures cause them to appear as a single queue which we will refer to as the “event queue.” When an application is ready, it will repeatedly access this queue and process the events the operating system passes back.

Events themselves are defined by the following structure:

struct EventRecord {
 short  what;
 long   message;
 long   when;
 Point  where;
 short  modifiers;
typedef struct EventRecord EventRecord;

The only field of this structure that we will concern ourselves with is the “what” field which specifies the type of event.

The different types of events an application receives can be sorted into three categories: low-level, operating system, and high-level. The low level events, include “mouse down” and “key pressed” events. Examples of operating system events include “suspend” and “resume” events. The high level events, are the new “apple events” included in System 7. I’ll refer to the high level events as apple events from now on. An application running in the foreground can receive any of these categories of events. On the other hand an application running in the background only receives a small subset. Background applications receive only null events (a low-level event), update events (also a low-level event), and apple events.

Apple events are a mechanism that applications can use to send messages to one another. Apple has specified that an application must handle four required apple events for an application to be System 7 savvy: “open application”, “open document”, “print document”, “quit application”. The System 7 finder sends one of the first three of these events to an application when the application first starts up depending on how the user started the application. For example, if the user drops a document onto the icon for the application the finder sends an open document event. The open document event includes a file specification for the file to be opened. In response the application should initialize itself, then open the document as if the user had chosen ‘Open’ from the file menu. The quit application apple event is a polite way of telling an application to shut itself down and clean up after itself.

The operating system will only send apple events to an application that has the ‘high level event aware’ flag set in the ‘SIZE’ resource. The SIZE resource contains information that the operating system uses to start up an application such as: whether or not to send apple events to the application and if the application is 32 bit clean.

Update events just notify the application that it needs to redraw part or all of one of its windows. Null events are for the most part ignored. Figure 1 shows a block diagram of how events are sent from the operating system to an application.

Figure 1

At this point, we need to make a small digression to clarify how events are added to the event queue. Events have a priority associated with them. With the exception of the Null event, the low-level events have the highest priority. Next come the operating system events, then the apple events. Null events have the lowest priority.

Events are inserted into the event queue in FIFO (first in first out) order. Events in the queue are sorted by priority so that low level events are always inserted before apple and operating system events; and operating system events are always inserted in front of apple events. Null events are added at the very end of the event queue.

Applications receive events by calling the Toolbox procedure WaitNextEvent. The next available event can also be retrieved using the procedure GetNextEvent; but GetNextEvent does not provide the support for multi-tasking that WaitNextEvent does. Apple recommends using WaitNextEvent. Following Apple’s recommendations is usually a good idea. An application can peek at the next event by calling EventAvail.

The prototype for WaitNextEvent is:

pascal Boolean WaitNextEvent(short eventMask,
    EventRecord *theEvent, unsigned long sleep,
    RgnHandle mouseRgn);

eventMask is a set of events that the application wants to be notified about. In our case we will use everyEvent. theEvent is a pointer to an EventRecord that the operating system will fill in. The sleep parameter is the number of ticks that an application is willing to wait in the WaitNextEvent call if there are no events in the event queue, (a tick is 1/60th of a second). mouseRgn is a handle to a region that defines an area in which mouse movement does not generate mouse moved events. We will pass NULL in mouseRgn.

When a foreground application calls WaitNextEvent several things can happen. If there is an event in the event queue the operating system immediately returns it. If there are no events in the event queue and the application has been waiting for longer than sleep ticks then the operating system returns a null event. If there are no events in the event queue and the application has been waiting less than sleep ticks, null events are sent to applications running in the background that are waiting for their call to WaitNextEvent to return. WaitNextEvent will not return until sleep ticks worth of time has expired; or until a non-null event is pending.

This is the feature we’ll use to render the sphere in the background. During start up, the application will calculate a pixel’s color for each event received no matter what kind of event it is. Almost all of the pixels will be calculated while processing null events.

Source Code

Since everyone already has the code for the sphere application, I’ll just describe the changes that need to be made in order to render the sphere in the background during start up. (You did save that copy of MacTech, right? Just kidding, all the source is included.) We’ll start with the main procedure.

We first change how the application calls the initialization procedure Init. If there is a problem during initialization, the application quietly exits as before; but, rather than using doneFlag to signal that the application is quitting, Init will return a false boolean value. In fact, I’ve eliminated the need for doneFlag entirely. If Init returns successfully the application calls InitCursor and then enters the main event loop.

Next, we change the DoEvent procedure. When a user clicks in the content portion of the window, the application copies what’s been calculated so far from the off screen port into the content region of the window. This allows the user to view how much of the sphere has been drawn. If an activate event is received the application redraws the menu bar and sets the cursor to the arrow. (Users usually like having the proper cursor showing when an application is activated. It’s rude to have to click on something with a watch cursor.)

While we are changing DoEvent we can add support for the suspend and resume operating system events by adding cases to the DoEvent switch statement.

The only change to CleanUp is to replace setting doneFlag equal to one with a call to ExitToShell. It is important to note that ExitToShell should only be called from your application. This sounds silly. How could ExitToShell be called otherwise? It can if, for instance, you are supporting the new apple events and your handler for the quit application apple event calls ExitToShell. In this case the operating system is calling ExitToShell, not your application. During start up, an application registers the apple event handlers it understands with the operating system. When the application receives an apple event, it asks the operating system to take care of calling the proper handler depending on the event received. The operating system calls the apple event handler and the event handler calls ExitToShell and then bad things happen. This can happen with any code called indirectly through the operating system.

We have been working our way up from the bottom of the source listing and we’ve come to Init. As you might expect, the biggest changes are made to Init. Init now returns a boolean. If Color Quickdraw is not available or if the palette didn’t load, return 0 rather than setting doneFlag equal to one. If the call to NewGWorld fails, return 0 rather than setting doneFlag equal to one. Since the application will be updating the screen before the entire sphere has been rendered, erase the off screen port with a call to EraseRect.

Those were the simple changes, now come the big changes. The loop to calculate the pixel color is modified from this:

 for (j=0;j<volSize;j++) {
 k = 0;
 do {
 DoColor(i, j, k, &pixColor);
 } while (( == 0) & (k < volSize));
 SetCPixel (i, j, &pixColor);

to this:

/* 1*/

 for (j=0;j<volSize;j++) {
 k = 0;
 do {
 DoColor(i, j, k, &pixColor);
 } while (( == 0) & (k < volSize));
 SetCPixel (i, j, &pixColor);
 UnlockPixels (wallyWorld->portPixMap);
 SetGWorld (savedPort, savedDevice);
 if (WaitNextEvent(everyEvent,&event,0,NULL))
 DoEvent ();
 SetGWorld (wallyWorld, NULL);
 LockPixels (wallyWorld->portPixMap);

Once the application has calculated a single pixel color we unlock the pixels, set the graphics world to the on screen port, and call WaitNextEvent with sleep = 0. Using a value of zero for sleep tells the operating system that the application is willing to wait if another application has an event pending, otherwise it wants the processor back.

The reason we change the graphics port is that DoEvent can process any category of event. This includes update events which cause drawing in the on screen port. Being cautious of the current graphics world allows us to use a generic DoEvent procedure to process all events rather than a generic DoEvent procedure in the main event loop and a specialized one in our pixel color calculation loop.

When WaitNextEvent returns and DoEvent finishes, we can set the graphics world to the off screen port and calculate the color of another pixel. As you might expect, swapping graphics worlds and processing events takes time. The application running in the background, generating a 128x128 image, takes about a minute 45 seconds. The original application, generating the same image, takes about a minute and 10 seconds. Although 35 seconds over the course of calculating 16384 pixels is significant, staring at an unresponsive screen for a minute 10 seconds is less appealing. Your performance may differ depending on how fast you type in a foreground application while the sphere is rendered in the background.

The last change to Init is drawing the completed sphere. Even if the application is running in the background, the completed sphere is drawn and the user can see that the application has finished.

There are only two other changes that need to be made to the sphere rendering application. We need to set the “can Background” and “accept suspend/resume events” flags in the ThinkC project and add prototypes for all the functions. Adding prototypes may seem unnecessary, but if the compiler is willing to check to make sure reasonable variable types are passed to procedures I’ll let it. This is a personal preference. As a final illustration of the utility of running applications in the background, I’d like to describe faceless background applications (FBAs).

Faceless Background Applications

Recently, in an Apple publication, I read about applications called faceless background applications. These applications do all of their processing in the background. Most have no user interface. They trundle along in the background taking care of tasks unnoticed and unappreciated. Like emptying the trash can every half hour or beeping every fifteen minutes to let you know you should rest your eyes. FBAs are full fledged applications that serve a useful purpose without interaction with a user at all.

Now that you have seen how to make an application do something useful between key presses, try adding this capability to your own applications. Not every application can benefit by processing null events in the background. But any application that needs time to process a request can benefit by occasionally making a call to WaitNextEvent and letting another application have a crack at the processor.


Thanks to Howard Clements my brother, Doug Cuthbertson my friend, and my wife Michele, all of whom read this article and made it readable.


Apple Computer, Inc., Inside the Macintosh, Volume VI, Addison Wesley, 1992

Clements, Geoffrey, “What are Voxels?,” MacTech Magazine, March 1993

Huan C. K., “Be Our Guest: Background-Only Applications in System 7,” Develop, Issue 10

Listing: Voxel.c

#include <Palettes.h>
#include <SANE.h>
#include <QDOffscreen.h>

/* size of the voxel data */
#define volSize  128
/* half the size of voxel data */
#define halfVolSize64
/* the radius of the sphere */
#define sphere_r 60
/* sphere_r*sphere_r */
#define volumeMag3600.0
/* sqrt(3.0)*sphere_r */
#define sqrt3r   103.9230
/* sphere_r*sqrt(6+2*sqrt(3)) */
#define rsqrt6   184.5827

/* resource numbers for the window, palette and menus */
#define windowRscr 128
#define paletteRscr128

#define appleID  128
#define appleM   0
#define appleAbout 1

#define fileID   129
#define fileM    1
#define fileQuit 1

#define editID   130
#define editM    2
#define editUndo 1
#define editCut  3
#define editCopy 4
#define editPaste  5
#define editClear  6

#define sleepTicks 30

#define aboutDialog  128

/* these constants define the Phong shading */
/* ambient reflection coefficient */
#define ambientReflCoef 0.1
/* depth cueing coefficient */
#define depthCueCoef  1.0
/* diffuse reflection coefficient */
#define diffReflCoef 5.0
/* specular reflection coefficient */
#define specReflCoef 5.0
/* first light source intensity */
#define light    1.0
/* coefficient to approx highlight */
#define highlightCoef 30

char aChar;
WindowPtr currentWindow;
MenuHandle myMenus[editM+1];
Rect dragRect, growRect;
long newSize;
EventRecord event;
WindowPtr whichWindow;
RGBColor pixColor;
short i, j, k;
PaletteHandle palH;
DialogPtr dPtr;
short doneDlg;
OSErr err;
SysEnvRec envRec;

Rect copyRect;
GWorldPtr wallyWorld;
GDHandle savedDevice;
CGrafPtr savedPort;
double PowerOfN (double x, short r);
short CalcVolumeData (short i,short j,short k);
void DoColor (short i, short j, short k,
 RGBColor *RGBVal);
void OpenWindow (void);
Boolean Init (void);
void DoAboutBox (void);
void CleanUp (void);
void DoCommand (long menuResult);
void DoEvent (void);

double PowerOfN (double x, short r) {
 double ans;
 ans = 1.0;
 while (r-- > 0) ans *= x;
 return ans;

double fx, fy, fz;

short CalcVolumeData(short i,short j,short k) {
 long x, y, z;
 fx = -(double)(i - halfVolSize);
 fy = -(double)(j - halfVolSize);
 fz = -(double)(k - halfVolSize);
 if((fx*fx+fy*fy+fz*fz) <= volumeMag) return 1;
 else return 0;

void DoColor (short i, short j, short k,
 RGBColor *RGBVal) {
 double n_dot_h, n_dot_l, n_dot_h2, n_dot_l2;
 double shade;
 unsigned short color;
 if (CalcVolumeData (i, j, k)) {
 n_dot_l = (fx + fy + fz)/sqrt3r;
 n_dot_h = (fx + fy + 2.7321*fz)/rsqrt6;
 shade = light*ambientReflCoef
 *PowerOfN (n_dot_h, highlightCoef)));

 /* second light source */
 n_dot_l2 = -fx/sphere_r;
 n_dot_h2 = (-fx + fz)/(1.4142*sphere_r);
 shade += light/((double)(k)+depthCueCoef)
 *PowerOfN (n_dot_h2, highlightCoef));

 color = (unsigned short)(shade * 65534.0);
 RGBVal->red = color;
 RGBVal->green = color;
 RGBVal->blue = color;
 else {
 RGBVal->red = 0;
 RGBVal->green = 0;
 RGBVal->blue = 0;

void OpenWindow (void) {
 currentWindow = (WindowPtr)GetNewCWindow
 (windowRscr, NULL, (Ptr)-1);
 SizeWindow(currentWindow, volSize + 25,
 volSize + 25, 1);
 SetWTitle(currentWindow, &"\pVol3D");

Boolean Init (void) {
 short i, j, k;

 InitFonts ();
 FlushEvents (everyEvent, 0);
 InitWindows ();
 InitMenus ();
 TEInit ();
 InitDialogs (NULL);

 myMenus[appleM] = GetMenu(appleID);
 AddResMenu(myMenus[appleM], 'DRVR');

 myMenus[fileM] = GetMenu(fileID);
 myMenus[editM] = GetMenu(editID);

 for (i=appleM;i<=editM;i++)
 InsertMenu(myMenus[i], 0);

 DrawMenuBar ();

 SetRect(&dragRect, 30, 20,
 screenBits.bounds.right - 10,
 screenBits.bounds.bottom - 30);
 SetRect(&growRect, 50, 50,
 screenBits.bounds.right - 20,
 screenBits.bounds.bottom - 50);
 err = SysEnvirons(1, &envRec);
 if (!envRec.hasColorQD) return 0;
 else {
 OpenWindow ();
 palH = GetNewPalette (paletteRscr);
 if (palH == NULL) {
 return 0;
 else {
 SetPalette (currentWindow, palH, 1);
 /* set up the offscreen drawing port */
 GetGWorld (&savedPort, &savedDevice);
 SetRect (&copyRect, 0, 0, volSize-1,
 LocalToGlobal (&;
 LocalToGlobal (&copyRect.bottom);
 err = NewGWorld (&wallyWorld, 0,
 &copyRect, NULL, NULL, 0);
 GlobalToLocal (&;
 GlobalToLocal (&copyRect.bottom);

 if (err != noErr) return 0;
 else {
 SetGWorld (wallyWorld, NULL);
 if (LockPixels (wallyWorld->portPixMap)) {
 /* draw off screen here */
 EraseRect (&copyRect);
 for (j=0;j<volSize;j++) {
 k = 0;
 do {
 DoColor(i, j, k, &pixColor);
 } while (( == 0)
 & (k < volSize));
 SetCPixel (i, j, &pixColor);
 UnlockPixels (wallyWorld->portPixMap);
 SetGWorld (savedPort, savedDevice);
 if (WaitNextEvent (everyEvent, &event, 0, NULL))
 DoEvent ();
 SetGWorld (wallyWorld, NULL);
 LockPixels (wallyWorld->portPixMap);
 UnlockPixels (wallyWorld->portPixMap);
 else return 0;
 /* the drawing is done set the current
 port back to the display window */
 SetGWorld (savedPort, savedDevice);
 if (LockPixels(wallyWorld->portPixMap)){
 InsetRect (&currentWindow->portRect, 8, 8);
 &currentWindow->portBits, &copyRect,
 &currentWindow->portRect, srcCopy, NULL);
 OffsetRect (&currentWindow->portRect,8,8);
 UnlockPixels (wallyWorld->portPixMap);
 return 1;

void DoAboutBox (void) {

 dPtr = GetNewDialog(aboutDialog,NULL,(Ptr)-1);
 ModalDialog(NULL, &doneDlg);
 while (!doneDlg);

void CleanUp (void) {
 HideWindow (currentWindow);
 DisposeGWorld (wallyWorld);
 DisposePalette (palH);
 DisposeWindow (currentWindow);
 ExitToShell ();

void DoCommand (long menuResult) {
 short menuID, menuItem;
 Str255 daName;
 short daErr;

 menuItem = LoWord (menuResult);
 menuID = HiWord (menuResult);

 switch (menuID) {
 case appleID: 
 if (menuItem == appleAbout)
 DoAboutBox ();
 else {
 daErr = OpenDeskAcc(daName);
 if (currentWindow)
 SetPort (currentWindow);
 case fileID: 
 switch (menuItem) { 
 case fileQuit: 
 CleanUp ();

void DoEvent (void) {

 switch (event.what) {
 case mouseDown: 
 switch (FindWindow (event.where,
 &whichWindow)) {
 case inMenuBar: 
 case inSysWindow: 
 SystemClick (&event, whichWindow);
 case inDrag: 
 DragWindow(whichWindow, event.where, &dragRect);
 case inGrow: 
 newSize = GrowWindow (whichWindow, 
 event.where, &growRect);
 LoWord(newSize), HiWord(newSize), 1);
 InvalRect (&currentWindow->portRect);
 case inContent:
 if (LockPixels(wallyWorld->portPixMap)) 
 DrawGrowIcon (currentWindow);
 InsetRect(&currentWindow->portRect, 8, 8);
 OffsetRect (&currentWindow->portRect, -8, -8);
 &currentWindow->portBits, &copyRect,
 OffsetRect (&currentWindow->portRect, 8, 8);
 InsetRect(&currentWindow->portRect, -8, -8);
 case inGoAway: 
 if(TrackGoAway(whichWindow, event.where))
 CleanUp ();
 } /* case findwindow (...) */
 case keyDown:
 case autoKey: 
 aChar = (char)(BitAnd (event.message, charCodeMask));
 if (BitAnd (event.modifiers, cmdKey))
 case activateEvt: 
 if (BitAnd(event.modifiers, activeFlag))
 DisableItem(myMenus[editM], 0);
 EnableItem(myMenus[editM], 0);
 DrawMenuBar ();
 SetCursor (&arrow);

 case updateEvt: 
 InsetRect (&currentWindow->portRect, 8, 8);

 if (LockPixels (wallyWorld->portPixMap)) {
 &currentWindow->portBits, &copyRect,
 &currentWindow->portRect, srcCopy, NULL);
 UnlockPixels (wallyWorld->portPixMap);
 OffsetRect(&currentWindow->portRect, 8, 8);
 InsetRect (&currentWindow->portRect, -8, -8);
 case osEvt:
 if (BitAnd(event.message, resumeFlag)) {
 DisableItem(myMenus[editM], 0);
 else EnableItem(myMenus[editM], 0);

void main (void) {
 currentWindow = NULL;
 if (Init ()) {
 InitCursor ();
 while (1)
 if (WaitNextEvent (everyEvent, &event,
 sleepTicks, NULL))
 DoEvent ();
Apple Inc.
Microsoft Corpora
Google Inc.

MacTech Search:
Community Search:

Software Updates via MacUpdate

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
Autopano Giga 3.6 - Stitch multiple imag...
Autopano Giga allows you to stitch 2, 20, or 2,000 images. Version 3.0 integrates impressive new features that will definitely make you adopt Autopano Pro or Autopano Giga: Choose between 9... Read more
Airfoil 4.8.7 - Send audio from any app...
Airfoil allows you to send any audio to AirPort Express units, Apple TVs, and even other Macs and PCs, all in sync! It's your audio - everywhere. With Airfoil you can take audio from any... Read more
Microsoft Remote Desktop 8.0.8 - Connect...
With Microsoft Remote Desktop, you can connect to a remote PC and your work resources from almost anywhere. Experience the power of Windows with RemoteFX in a Remote Desktop client designed to help... Read more
xACT 2.30 - Audio compression toolkit. (...
xACT stands for X Aaudio Compression Toolkit, an application that encodes and decodes FLAC, SHN, Monkey’s Audio, TTA, Wavpack, and Apple Lossless files. It also can encode these formats to MP3, AAC... Read more
Firefox 31.0 - Fast, safe Web browser. (...
Firefox for Mac offers a fast, safe Web browsing experience. Browse quickly, securely, and effortlessly. With its industry-leading features, Firefox is the choice of Web development professionals... Read more
Little Snitch 3.3.3 - Alerts you to outg...
Little Snitch gives you control over your private outgoing data. Track background activityAs soon as your computer connects to the Internet, applications often have permission to send any... Read more
Thunderbird 31.0 - Email client from Moz...
As of July 2012, Thunderbird has transitioned to a new governance model, with new features being developed by the broader free software and open source community, and security fixes and improvements... Read more

Latest Forum Discussions

See All

Reddme for iPhone - The Reddit Client (...
Reddme for iPhone - The Reddit Client 1.0 Device: iOS iPhone Category: News Price: $.99, Version: 1.0 (iTunes) Description: Reddme for iPhone is an iOS 7-optimized Reddit client that offers a refreshing new way to experience Reddit... | Read more »
Jacob Jones and the Bigfoot Mystery : Ep...
Jacob Jones and the Bigfoot Mystery : Episode 2 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: Jacob Jones is back in Episode 2 of one of Apples 'Best of 2013' games and an App Store... | Read more »
New Trailer For Outcast Odyssey, A New K...
New Trailer For Outcast Odyssey, A New Kind of Card Battler Posted by Jennifer Allen on July 25th, 2014 [ permalink ] Out this Fall is a new kind of card battle game: Outcast Odyssey. | Read more »
Garfield: Survival of the Fattest Coming...
Garfield: Survival of the Fattest Coming to iOS this Fall Posted by Jennifer Allen on July 25th, 2014 [ permalink ] Who loves lasagna? Me. Also everyone’s favorite grumpy fat cat, Garfield. | Read more »
Happy Flock Review
Happy Flock Review By Andrew Fisher on July 25th, 2014 Our Rating: :: HERD IT ALL BEFOREUniversal App - Designed for iPhone and iPad Underneath the gloss of Happy Flock’s visuals is a game of very little substance. It’s cute, but... | Read more »
Square Register Updates Adds Offline Pay...
Square Register Updates Adds Offline Payments Posted by Ellis Spice on July 25th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Looking For Group – Hearthstone’s Curse...
For the first time since its release (which has thankfully been a much shorter window for iPad players than their PC counterparts), Blizzard’s wildly successful Hearthstone: Heroes of Warcraft CCG is sporting some brand new content: the single... | Read more »
Poptile Review
Poptile Review By Jennifer Allen on July 25th, 2014 Our Rating: :: SIMPLY FUNUniversal App - Designed for iPhone and iPad Simple yet a little bit glorious, Poptile is a satisfying entertaining puzzle game with oodles of the ‘one... | Read more »
Modern Combat 5: Blackout Review
Modern Combat 5: Blackout Review By Brittany Vincent on July 25th, 2014 Our Rating: :: LESS QQ, MORE PEW PEWUniversal App - Designed for iPhone and iPad The fifth entry into the blockbuster Modern Combat series is what mobile... | Read more »
Watch and Share Mobile Gameplay Videos W...
Watch and Share Mobile Gameplay Videos With Kamcord Posted by Jennifer Allen on July 25th, 2014 [ permalink ] iPhone App - Designed for the iPhone, compatible with the iPad | Read more »

Price Scanner via

iMacs on sale for $150 off MSRP, $250 off for...
Best Buy has iMacs on sale for up to $160 off MSRP for a limited time. Choose free home shipping or free instant local store pickup (if available). Prices are valid for online orders only, in-store... Read more
Mac minis on sale for $100 off MSRP, starting...
Best Buy has Mac minis on sale for $100 off MSRP. Choose free shipping or free instant local store pickup. Prices are for online orders only, in-store prices may vary: 2.5GHz Mac mini: $499.99 2.3GHz... Read more
Global Tablet Market Grows 11% in Q2/14 Notwi...
Worldwide tablet sales grew 11.0 percent year over year in the second quarter of 2014, with shipments reaching 49.3 million units according to preliminary data from the International Data Corporation... Read more
New iPhone 6 Models to Have Staggered Release...
Digitimes’ Cage Chao and Steve Shen report that according to unnamed sources in Apple’s upstream iPhone supply chain, the new 5.5-inch iPhone will be released several months later than the new 4.7-... Read more
New iOS App Helps People Feel Good About thei...
Mobile shoppers looking for big savings at their favorite stores can turn to the Goodshop app, a new iOS app with the latest coupons and deals at more than 5,000 online stores. In addition to being a... Read more
Save on 5th generation refurbished iPod touch...
The Apple Store has Apple Certified Refurbished 5th generation iPod touches available starting at $149. Apple’s one-year warranty is included with each model, and shipping is free. Many, but not all... Read more
What Should Apple’s Next MacBook Priority Be;...
Stabley Times’ Phil Moore says that after expanding its iMac lineup with a new low end model, Apple’s next Mac hardware decision will be how it wants to approach expanding its MacBook lineup as well... Read more
ArtRage For iPhone Painting App Free During C...
ArtRage for iPhone is currently being offered for free (regularly $1.99) during Comic-Con San Diego #SDCC, July 24-27, in celebration of the upcoming ArtRage 4.5 and other 64-bit versions of the... Read more
With The Apple/IBM Alliance, Is The iPad Now...
Almost since the iPad was rolled out in 2010, and especially after Apple made a 128 GB storage configuration available in 2012, there’s been debate over whether the iPad is a serious tool for... Read more
MacBook Airs on sale starting at $799, free s...
B&H Photo has the new 2014 MacBook Airs on sale for up to $100 off MSRP for a limited time. Shipping is free, and B&H charges NY sales tax only. They also include free copies of Parallels... Read more

Jobs Board

*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
*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 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
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.