TweetFollow Us on Twitter

Measure Load
Volume Number:4
Issue Number:3
Column Tag:C Workshop

A Background Task for Measuring Load

By Peter Korn, Apple Computer

Peter Korn is a full time software quality assurance engineer for Apple Computer, and a full time undergraduate student in Mathematics at UC Berkely, which makes him a busy young man! In this article, he gives us a technique for measuring the activity under multifinder by timing null events in a background task.

True™ Multitasking

I don’t have to tell you that multitasking is good. By not having to wait on the computer to finish a task before you can go on to the next one you save time, frustration, and creative energies. There’s nothing as frustrating to me as having an idea and wanting to take it somewhere but not being able to do so because my computer is busy printing, or downloading, or compiling (admittedly with LightSpeed C my wait isn’t very long). But once we have the concept of multitasking, is multifinder True™ multitasking? Before I tackle that one, I want to give a brief history...

In the beginning there was the Macintosh (128K model). With it I could have a Desk Accessory or three pop up whenever I had an idea that I didn’t want to interrupt whatever else I was doing to work on. And, if I hadn’t foolishly started a print job or an {up,down} loading session on my modem, I was fine. Some of the usefulness of multitasking already!

When the 512K Mac came along there was more RAM to play with, and some programs took advantage of this RAM to use the Vertical Retrace Manager for more than just a cursor blinker and tick counter. With programs like SuperSpool, I could bring up a DA even while my program was printing. And the DAs were getting bigger too. There were spreadsheets, filers, outliners and word processors and terminal programs (even one called Backdown, that would download for me in the background). And while all of this took even more RAM, the Mac Plus was released shortly and life was pretty ok.

Except that for a program to allow itself to be run ‘in the background’, it had to go through a series of contortions, and deny itself use of the Memory Manager, and so very few programs were written this way. Certainly Backdown, while nice, wasn’t a full-blown terminal emulator. And still there was no way of checking spelling in the background, or compiling, or recalculating a spreadsheet, or what-have-you. The Vertical Retrace Manager just wasn’t cut out to be a scheduler.

Even with Switcher I still couldn’t do all these sorts of things at once; I could only switch between them when they were idle. And this I had to do by hand (with the exception of ThunderScan, but there’s no surprise there, as it shares authors with Switcher).

Fig. 1Our little Load Average Window Measures time between null events

A True™ multitasking system should allow me to run True™ tasks, and have them all going simultaneously (or close to simultaneously--you know what I mean). But an important question is, must this be preemptive? As a user, do I really care how it’s all done, so long as my download, spreadsheet recalculation, and mandelbrot plot all continue whilst I’m busy writing a letter to grandma? In fact, if I’m typing my letter, I don’t want the computer to be any slower responding to my keystrokes just because it’s doing other things--I’m being creative here, and I don’t want to have to deal with a sluggish interface that slows me down just because I have the computer doing other things as well.

In wider circles, True™ multitasking is considered preemptive multitasking. Each task (program, driver, what-have-you) is assigned some priority number (-10 to 10, say), and some scheduler program arbitrates which task gets how much CPU time when. First it looks at all the programs of the highest priority level, and for all of those that want time (some may not; perhaps their waiting for slow networking i/o, or are finished computing their mandelbrot and haven’t been given further instructions), it allocates that time evenly amongst them, interrupting each at some small, regular interval (100 milliseconds, say), and giving time over to the next needy task of equal priority level. When no tasks at that priority level want time, then the scheduler looks at tasks of a lower priority level and parcels out time as before to all of them, and so on. If the user doesn’t want his creativity disrupted, he merely sets the priority of the task he is working on to something higher than all the other tasks. And in between keystrokes (in the word processor, say), the other tasks will get time to do what they need to do (ie: when the user is idle [for some fraction of a second]).

Apple, in it’s infinite wisdom, didn’t do it this way. The main reason was for compatibility. Another was because of system architecture (while the Amiga can carry it off without a hardware Memory Management Unit that ensures that whatever memory address a program writes to isn’t taken by something else, certain developers [including Apple] have too long thought of the Macintosh as belonging entirely to the program currently running [allowing for those piddling desk accessories, maybe] to pull this off). But is Apple’s way also True™ multitasking? Well, if it gets the job done...

Multitasking the Macintosh way

Under the new operating system (System Disk 5.0, which contains System 4.2, Finder 6.0, MultiFinder 1.0, Chooser and Control Panel 3.2, and [aha, so this is where they got the number] LaserWriter Driver 5.0), we can run a program called MultiFinder. MultiFinder, (like Switcher and Servant before them) allows us to load in several programs at once, and switch between them at will, in a very clean fashion (click on window beneath belonging to another program, select the program from the Apple menu, or cycle through the program list on the upper right corner of the MenuBar; this type of program switching is what tech note #180 calls “Major Switching”). Additionally, programs that define themselves as ‘backgroundable’ can get time when the ‘foreground’ program (the one who’s window is foremost and active) is idle.

This is done by taking control when the foreground program calls GetNextEvent(), EventAvail(), or WaitNextEvent(), a new call under multifinder, and seeing what the foreground program’s event is. If the event is not a nullEvent, the foreground program gets it. If the event is a nullEvent, then things get interesting and somewhat confusing.

Null Event Processing

If our foreground program is not MultiFinder friendly, it’s doubtless using GetNextEvent(). In this case, MultiFinder doesn’t do anything on the first nullEvent. Or the second nullEvent (this is for programs that do work on nullEvents but were written before the program’s authors knew about MultiFinder, like MS-Word). But the third nullEvent the foreground program never sees (in the current version of MultiFinder -- in later versions GNE() calling apps may only see 1 nullEvent, or perhaps none). Instead MultiFinder looks about and sees if there are any background tasks running (I’ll describe those in a moment), and turns control over to one of them (this type of switching is called “Minor Switching” by tech note #180). That background task then calls GNE() or WNE(), and MultiFinder takes over immediately, checks the event, and if it’s not a nullEvent, returns control immediately to the foreground program. If it is another nullEvent, MultiFinder checks to see if there are any other background tasks, allocating nullEvents in a round-robin fashion until a non-nullEvent comes along, at which time control is returned to the ‘foreground’ task, which is returned that non-nullEvent.

For everything to work right, MultiFinder has to make certain assumptions. First, it assumes that all programs call GNE(), WNE(), or EA() regularly (which a program is under no obligation to do, though it would be nice...). If a program doesn’t, then when it’s in the foreground, no background tasks will ever get time. Furthermore, all programs that want to run as background tasks have to call one of these three, and call them pretty often, in order to ensure that the foreground task can quickly respond to any user event (a non-nullEvent, in this case). There’s no more a way to stop a renegade background task from taking over the CPU the moment it gets it than there is a way to stop a renegade program from making the machine crash -- programmers and users and the media will be the judge, not any hardware MMU.

So is it True™ multitasking? You decide.

How to be a (good) background task

Formally all you have to do to be a background task is to have a Size = -1 resource with the can background bit set. As a background task, to do any work, you also have to check for, and use, nullEvents. Furthermore, the obedient background task does no more than 50-100 milliseconds of work before calling GNE(), WNE(), or EA() again. for a wonderful example of a disobedient background task, look at Apple’s PrintMonitor that’s shipping with the 5.0 release (clearly following in MacWrite’s lawless ways...). Caveat: in MultiFinder 1.0 there is a bug when using GNE() from the background: you will get no nullEvents when you are first launched--you have to be switched out and then back in again before you start seeing those precious nullEvents.

As a background task, you can do almost anything a foreground task can do. You can write to the screen, read from disk, use the memory manager, play sound, etc. You can even be a foreground task (like a clock that updates the time constantly, and in the foreground allows the user to change from 12 hour to 24 hour display--or like a graphic load average program [which happens to be the subject of this article]). However... you are warned to do all of your work inside of windows. Drawing to the screen is a no-no. And if you are like a certain game I won’t mention (but who’s initials are Crystal Quest), and you don’t draw in a window and expect the user to click the mouse button whilst using your game, you will swiftly find yourself being switched (twitched, as it’s sometimes called) out while whatever program’s window was underneath the mouse when the mouseDown happened suddenly coming into the foreground. Also you shouldn’t put up a Modal Dialog box, as it won’t come up in the foreground but will stay in your layer and the user might never see it. Nor should you do anything that might affect the foreground task, like fiddling with the menuBar or cursor. Lastly, if your program is so uncouth as to change some system parameter (like the mouse tracking ratio, as done by a certain program with the same initials), you should at least be good enough to set it back to what it was when you get twitched out.

Which brings us to the next level of MultiFinder compatibility: accepting suspend/resume events (as the bit in the Size = -1 resource is labeled). These programs recognize two new event types that came about from the Switcher days: suspend and resume. A program (any program, not just backgroundable ones) that accepts suspend events doesn’t ever get that first nullEvent (on a Major Switch), (unless it’s got the background bit set, in which case it will share nullEvents with the other programs that have a background bit set). Instead it will see a suspend event. A suspend event is an app4Evt (theEvent.what = 15) with bit 0 of theEvent.message clear. A resume event is an app4Evt with bit 0 set to 1. A suspend event means that the program is about to be juggled (for some reason the future tense is juggled, and otherwise it’s called twitching), and the program should set the state of anything it muddled with back to what it was before it muddled with it and so forth, and then call GNE(), WNE() or EA(). Furthermore, if bit 1 of theEvent.message of the suspend event is set, the application should convert it’s internal clipboard to the deskscrap (or vice versa if the event is a resume event) so that other applications can use it. If that bit is clear, then no scrap conversion is necessary.

Another bit in the Size = -1 resource is the Juggler Aware bit. If this bit is set, the program uses WNE() instead of GNE() if MultiFinder is running (see the example in my code or in tech note #158 [where I stole it from] for how to do this). WNE() has two additional parameters that it gets passed: sleep (an unsigned long), and mouseRgn (a RgnHandle). Sleep is the number of ticks that the application can go without getting a nullEvent (for things like updating a blinking cursor or clock getting a character from the modem or some such). mouseRgn is a RgnHandle within which the mouse can move and the program needn’t be consulted as to it changing shape. An example of this is a terminal emulator, who’s cursor is an I-beam when it’s over the content region of the window, and an arrow when it’s over anything else. NIL cast to the proper variable type can be passed for either of these parameters.

Sayeth Apple: you shouldn’t set the Juggler Aware bit unless you use WNE(), and recognize suspend/resume events, and are in all ways cognizant of MultiFinder and running with other foreground and background tasks. And what does this involve?

Background tasking programs (in fact, all programs) should now do a number of things in order to better function in the MultiFinder environment. Programs should not do any work on updateEvents (other than updating the window in question with calls to BeginUpdate() and EndUpdate(), if nothing else). If a foreground program’s window is moved about, it my reveal a portion of a window underneath it that wasn’t revealed before. That program may all of a sudden decide that, on getting it’s updateEvent, that it wants to get some more characters from the modem and display them on the screen and such (like another program that I won’t mention who’s initials [really are] UW). All programs should include a Size = -1 resource, in which, if nothing else, they give a preferred memory partition size that they want to run in. If none is given, 384K is assumed (though this can be edited from the Get Info box in the Finder). Programs that were designed for the 128K Mac (in the 128K Mac days...) wind up taking gobs of RAM for no good reason. All programs need to support Desk Accessories, as it’s through this mechanism that Major Switching takes place. Lastly, to better utilize the MultiFinder environment (that allows multiple programs to be auto-launched on startup), programs should save their window positions and states so that the next time that they are invoked the user doesn’t have to fuss with moving around all of their windows to where he wants them. The kosher way to do this is with GlobalToLocal() on the upper left and lower right positions of your window (or just the upper left if it’s not resizable), and saving that information into the resource or data fork of another file (not the one that the program is in). Then call MoveWindow(savedPoint) to position it before making it visible. Alternately you could save a copy of the window resource into a configuration file. Just keep in mind that reading and writing to the window record itself a no-no (says Apple), ‘cause it may change in the future. And by writing to a file other than the program file, you allow yourself to be shared on a network (such as AppleShare or TOPS). Of course, if you don’t want to be shared, than this isn’t a problem. Unless you are a commercial program with single-user licensing only, you may as well allow yourself to be shared.

Graphic Load Average

When I first saw MultiFinder in action, I immediately thought that some means of measuring the ‘load average’ of the CPU was needed (after all, most all True™ multitasking systems have this). Being as there was no real way to measure this in the traditional sense (the number of processes the CPU is actively switching through), I decided that instead it would measure the number of nullEvents it got over a period of time, and graph it’s results (which is a more meaningful measure under MultiFinder).

Unfortunately someone beat me to it (actually, a lot of people beat me to it, but one sticks out in particular). I have to give credit to Erik Kilk, who posted Waiting to the Usenet some 72 hours before I had my program running. Clearly the only way I could salvage my ego was to try to make my program better than his.

Graphic Load Average (GLA) has four load meters, each of which can be set to a different sensitivity and update duration (and width). These settings are set via a hierarchical menu. Additionally it uses WNE(), and will not run if MultiFinder isn’t present (a dialog box comes up to nicely inform you of this). Also there is an option to Compress Juggler RAM, which makes a call to the new juggler call MFMaxMem(). While I have yet to see this call actually do something, certainly having it there somehow improves GLA (it also shows how to make the call from LightSpeed C v. 2.13, which doesn’t yet support these new calls -- see the modified-multifinder.h include file that I made, with the generous help of Ed Tecot of Apple, to use with LightSpeed C). [Note: The current version of LS C is 2.15. Updates are available from Think, or if purchased from MacTutor, from us. -Ed]

Graphic Load Average Controls

Each set of triplets controls three things: the width item, which is the width of the displayed graphic bar in the window, the ceiling, which is the number of ticks which will equal a full bar, and the time over which the null events will be averaged. The ceiling parameter is the sensitivity setting, as to how many ticks give a full height bar. The time parameter determines the number of ticks to wait before updating the display. If we set this to five, then we wait five ticks before updating the display with the average number received for that bar. We take the average, and divide it by the ceiling to calculate the height of the bar to be displayed. The ceiling is converted into pixels, divided by the number of ticks that equals a full ceiling to find the number of pixels to display.

By using the four indicators, you can have four different sensitivity settings for how many ticks would result in a full bar display. The maximum setting is a single tick. A tick is a 60th of a second. On each null event, the time is compared, so the average time between null events is being measured. The more bars you display, the longer the time between null events, which means more load on the machine.

Other points of interest and note: putting up a window in a saved position is all very nice, but what if the program is first run on a MacII, and then later is run on a MacPlus. It is important to check that window position is within the bounds of the window (better still, within the dragBounds that you use for MoveWindow()). I cheated in GLA, and took the cheap way out when it came to AppleShare. I wrote the configuration information into the same file as I execute from, which means that I cannot be shared under AppleShare (note: even if I was good, and wrote to a separate configuration file, I’d still not automatically be sharable. There’s a bit [there’s always a bit] that I need to set that says “I’m sharable, and won’t do anything bad”). [As we have reported in the past, forcing developers to create hundreds of little configuration files is a poor excuse for Apple’s failure to build a resource manager that is sharable. We don’t think this is the way to go and don’t particulary want our system file filled up with these things. Configuration information should be stored in a document instead. Documents are normally not expected to be sharable at the same time. In this program, Peter does another thing we don’t recommend: he opens a specific resource file by file name, a definite no-no. You should obtain the application file name from the finder info and open the file using that name instead of hard-coding a file name into the source. -Ed]

Dear Phil and Erich

(MultiFinder wish list)

While I’m very happy with all that I can now do with my Macintosh and MultiFinder, there are still things I’d like to see (especially as a programmer).

• I want some way of getting mouse clicks into a window when that mouse click caused a Major Switch (try clicking on GLA’s content region in a switch, dragging, and releasing the mouse--GLA’s window won’t drag)

• I’d like Alert and Dialog boxes that I can bring up via some sort of sublaunch mechanism that puts the dialog/alert ‘program’ into the foreground and my program in the background so that it can do work while the user takes his/her time responding to the dialog (I’d like a clean mechanism, not have to write my own ‘dialog/alert displaying task’ especially to do this).

• I want to see more backgroundware from Apple. A MacTerminal that downloads in the background would be very nice. Initializing a floppy diskette in the background would be great (though that requires multi-threaded i/o, another nice feature for a future MultiFinder)

• I’d like some kosher way of notifying a user that I need attention when I’m in the background. What does PrintMonitor know that we lowly developers don’t?

• I want to see documentation on this mysterious Layer Manager that’s managing all the app layers for me behind my back (and not sending me mouseDowns on Major Switches). In return, I promise to restrain myself from playing with undocumented traps in search of it.

• I’d like language developers to be seeded as early as possible with things like MultiFinder so that I’m not forced to use MPW to program on the cutting edge (try running MPW and MultiFinder and the app your writing on a 2 Meg machine sometime, not to mention the 80% of us who have 1 Meg machines!). Please don’t make me write glue for this--that’s what the language developers are for. [A swift kick in the rear to third party develoepers to update their products when they get the new interfaces is also in order. -Ed]

• I want MultiFinder to somehow guarantee my background task a nullEvent at least every so often, so that my communications software doesn’t time out due to it not getting any time. Just a little pre-emption so that connections don’t die just because MicroSomeone’s software decides to keep the CPU longer than it should have.

• I want the playing of sounds to not kill all user i/o. I want to be able to type characters and switch between programs while sound is playing. How about some more background tasks guys?

/* Graphic Load Average
 © 1987 Peter Korn

 This is a little program designed 
 to run in the backround under MultiFinder.
 It’s purpose:  to graphically indicate 
 the ‘load’ by creating a column chart of 
 the load.
 
*/
/*  Defines */

#define NIL  0
#define nullStopMask  0
#define MYALERT  128
#define MYDIALOG 150
#define MYWINDOW 128
#define DESK_ID  128
#define FILE_ID  129
#define EDIT_ID  130
#define CONFIGURE_ID 131
#define BASE_ID  200 /* heirarchical menus */
#define WINDOW_POSh150
#define WINDOW_POSv151
#define BAROFFSET10
#define WNETrapNum 0x60
#define UnImplTrapNum0x9F
#define SUSPEND_RESUME_EVT15
#define SUSPEND_RESUME_BIT0
#define CLIPBOARD_BIT0
#define MessageDialog258

/*  Includes*/

#include <Quickdraw.h>
#include <MacTypes.h>
#include <FontMgr.h>
#include <WindowMgr.h>
#include <MenuMgr.h>
#include <TextEdit.h>
#include <DialogMgr.h>
#include <EventMgr.h>
#include <DeskMgr.h>
#include <FileMgr.h>
#include <ToolboxUtil.h>
#include <ControlMgr.h>
#include <OSUtil.h>
#include <ResourceMgr.h>
#include <modified_MultiFinder.h>

/*  Globals */
 
typedef struct ConfigurationItem {
 int    value;
 Handle valueHandle;
 MenuHandle menuHandle;
}ConfigurationItem;

typedef struct ConfigurationTriplet {
 ConfigurationItem ceiling;
 ConfigurationItem interval;
 ConfigurationItem width;
};

struct  ConfigurationTriplettheConfiguration[4];

long    ticksGoneBy, tickSum[4], tickSumDivider[4];
int**windowPoshHandle, **windowPosvHandle;
GrafPtr theCurrentPort;
MenuHandledeskMenu, fileMenu, editMenu, configureMenu;
WindowPtr loadWindow;
Str255  daName;
Rect    dragBoundsRect;

/* restartProc */
restartProc()
{
 quitTime();
}

/* the Switches  */

long  CeilingSwitch (itemNumber)
 int    itemNumber;
{
 long returnVal;
 
 switch(itemNumber){
 case 1:
 returnVal = 1;
 break;
 case 2:
 returnVal = 2;
 break;
 case 3:
 returnVal = 3;
 break;
 case 4:
 returnVal = 4;
 break;
 case 5:
 returnVal = 5;
 break;
 case 6:
 returnVal = 6;
 break;
 case 7:
 returnVal = 7;
 break;
 case 8:
 returnVal = 8;
 break;
 case 9:
 returnVal = 9;
 break;
 case 10:
 returnVal = 10;
 break;
 case 11:
 returnVal = 15;
 break;
 case 12:
 returnVal = 20;
 break;
 case 13:
 returnVal = 30;
 break;
 case 14:
 returnVal = 60;
 break;
 }
 
 return(returnVal);
}

long  IntervalSwitch(itemNumber)
 int  itemNumber;
{
 long returnVal;
 
 switch(itemNumber){
 case 1:
 returnVal = 1;
 break;
 case 2:
 returnVal = 2;
 break;
 case 3:
 returnVal = 5;
 break;
 case 4:
 returnVal = 10;
 break;
 case 5:
 returnVal = 20;
 break;
 case 6:
 returnVal = 60;
 break;
 case 7:
 returnVal = 120;
 break;
 case 8:
 returnVal = 180;
 break;
 case 9:
 returnVal = 600;
 break;
 case 10:
 returnVal = 1200;
 break;
 }

 return(returnVal);
}

long  WidthSwitch(itemNumber)
 int    itemNumber;
{
 long returnVal;

 switch(itemNumber){
 case 1:
 returnVal = 1;
 break;
 case 2:
 returnVal = 2;
 break;
 case 3:
 returnVal = 3;
 break;
 case 4:
 returnVal = 4;
 break;
 case 5:
 returnVal = 5;
 break;
 }
 return(returnVal);
}

/* doMessage */

/* Politely inform user of messages like no
 multifinder running. Note- this is not
 the kosher way to do things since it doesn’t
 involve string resources, which can be edited 
 or translated. But it is much faster to develop. */

doMessage (message0,message1,message2,message3)
Str255  message0;
Str255  message1;
Str255  message2;
Str255  message3;
{
DialogPtr dialogP;
intitem;

 ParamText(message0, message1, message2, message3);
 dialogP = GetNewDialog(MessageDialog, (Ptr)NIL, (Ptr)-1);
 if (dialogP == NIL) {
 SysBeep(5);
 ExitToShell();
 }
 else {
 InitCursor(); 
 ModalDialog((Ptr)NIL, item);
 DisposDialog(dialogP); 
 } 
}

/* setUpWorld */

setUpWorld()
{
 int    i;
 SysEnvRectheWorld;
 OSErr  err;
 
 InitGraf(&thePort);
 InitFonts();
 FlushEvents(everyEvent,nullStopMask);
 InitWindows();
 InitMenus();
 TEInit();
 InitDialogs(restartProc);
 InitCursor();

 /*check if WNE is implemented, and exit if not
 ...stolen from Tech Note #158*/
 err = SysEnvirons(1, &theWorld);
 if ((theWorld.machineType < 0) ||
 (NGetTrapAddress(WNETrapNum,ToolTrap) == NGetTrapAddress(UnImplTrapNum,ToolTrap))) 
{
 doMessage(“\pMultifinder not active”,””,””,””);
 ExitToShell();
 }
 SetRect(&dragBoundsRect, screenBits.bounds.left +4,
 screenBits.bounds.top + MBarHeight, 
 screenBits.bounds.right -4, screenBits.bounds.bottom -4);

 /*get saved resources  & don’t let ‘em get purged */

 OpenResFile(“\pGLA appl”); 
 /* note: this is not nice. Never hard code a file name. */
 
 for (i = 0; i < 4; i++) {
 theConfiguration[i].ceiling.valueHandle = GetResource((ResType) ‘INFO’, 
(BASE_ID + i*3));
 HNoPurge(theConfiguration[i].ceiling.menuHandle);
 theConfiguration[i].ceiling.value = CeilingSwitch(**theConfiguration[i].ceiling.valueHandle);
 
 theConfiguration[i].interval.valueHandle = GetResource((ResType) ‘INFO’, 
(BASE_ID + 1 + i*3));
 HNoPurge(theConfiguration[i].interval.menuHandle);
 theConfiguration[i].interval.value = IntervalSwitch(**theConfiguration[i].interval.valueHandle);

 theConfiguration[i].width.valueHandle = GetResource((ResType) ‘INFO’, 
(BASE_ID + 2 + i*3));
 HNoPurge(theConfiguration[i].width.menuHandle);
 theConfiguration[i].width.value = WidthSwitch(**theConfiguration[i].width.valueHandle);
 }

 /*call ResError(), and set them manually if get error */
 windowPoshHandle = (int **) GetResource( (ResType) ‘INFO’, WINDOW_POSh);
 HNoPurge(windowPoshHandle);
 
 windowPosvHandle = (int **) GetResource( (ResType) ‘INFO’, WINDOW_POSv);
 HNoPurge(windowPosvHandle);
 
 /*if point not inside dragBoundsRect, set default */
 if ((**windowPoshHandle < dragBoundsRect.left) ||
 (**windowPoshHandle > dragBoundsRect.right) ||
 (**windowPosvHandle > dragBoundsRect.bottom) ||
 (**windowPosvHandle < dragBoundsRect.top)) {
 
 **windowPoshHandle = (int) ((dragBoundsRect.right - dragBoundsRect.left)/2);
 **windowPosvHandle = (int) ((dragBoundsRect.bottom - dragBoundsRect.top)/2);
 }
 
 loadWindow = GetNewWindow(MYWINDOW, (Ptr) NIL, (Ptr) -1);
 MoveWindow(loadWindow, **windowPoshHandle, **windowPosvHandle, FALSE);
 ShowWindow(loadWindow);

 SetPort(loadWindow);
 PenNormal();

}

/* setUpMenus */

setUpMenus()
{
 int    i;
 
 deskMenu = GetMenu(DESK_ID);
 AddResMenu(deskMenu, ‘DRVR’);
 InsertMenu(deskMenu, 0);
 
 fileMenu = GetMenu(FILE_ID);
 InsertMenu(fileMenu, 0);
 
 editMenu = GetMenu(EDIT_ID);
 InsertMenu(editMenu, 0);
 
 configureMenu = GetMenu(CONFIGURE_ID);
 InsertMenu(configureMenu, 0);
 
 for (i = 0; i < 4; i++) {

 theConfiguration[i].ceiling.menuHandle = GetMenu(BASE_ID + i*3);
 InsertMenu(theConfiguration[i].ceiling.menuHandle, -1);
 CheckItem(theConfiguration[i].ceiling.menuHandle, (int) **theConfiguration[i].ceiling.valueHandle, 
TRUE);
 
 theConfiguration[i].interval.menuHandle = GetMenu(BASE_ID + i*3 + 1);
 InsertMenu(theConfiguration[i].interval.menuHandle, -1);
 CheckItem(theConfiguration[i].interval.menuHandle, (int) **theConfiguration[i].interval.valueHandle, 
TRUE);
 
 theConfiguration[i].width.menuHandle = GetMenu(BASE_ID + i*3 + 2);
 InsertMenu(theConfiguration[i].width.menuHandle, -1);
 CheckItem(theConfiguration[i].width.menuHandle, (int) **theConfiguration[i].width.valueHandle, 
TRUE);
 }
 
 DrawMenuBar();
}


/* doMenu */

doMenu(menuResult)
 long menuResult;
{
 int    menuID, itemNumber, newHPos;
 int    newVPos, itemHit, i, configSetting;
 long   longPointer;
 ProcPtrmyFilterProc;

/* if (menuResult == (long) NIL)
 menuResult = MenuChoice(); */
 
 menuID = HiWord(menuResult);
 itemNumber = LoWord(menuResult);
 
 switch(menuID)
 {
 case DESK_ID:   /*Apple Menu */
 if (itemNumber == 1){
 Alert(MYALERT, NIL);
 break;
 }
 else if (itemNumber == 0)/* b/c of nested menus */
 break;
 else
 {
 GetItem(deskMenu, itemNumber, &daName);
 GetPort(&theCurrentPort);
 OpenDeskAcc(&daName);
 SetPort(theCurrentPort);
 
 break;
 }
 break;
 
 case FILE_ID:   /*  the File Menu */
 switch(itemNumber)
 {
 case 1:/*the print command */
 break;
 case 2:/*the quit command*/
 quitTime();
 break;
 }
 break;
 
 case EDIT_ID:   /*the Edit Menu */
 switch(itemNumber){
 case 1:/*the undo command*/
 break;
 case 2:/*just dashed lines */
 break;
 case 3:/*the cut command */
 break;
 case 4:/*the copy command*/
 break;
 case 5:/*the paste command */
 break;
 case 6:/*the clear command */
 break;
 }
 break;
 
 case CONFIGURE_ID:/*the Configure Menu*/
 switch(itemNumber){
 case 1:/*Set Time:Heirarchical  */
 case 2:/*Average Over: Heirarchical */
 case 3:/*Set Width: Heirarchical  */
 break;
 case 4:/*spacer */
 break;
 case 5:/*Set Time:Heirarchical  */
 case 6:/*Average Over: Heirarchical */
 case 7:/*Set Width: Heirarchical  */
 break;
 case 8:/*spacer */
 break;
 case 9:/*Set Time:Heirarchical  */
 case 10: /*Average Over: Heirarchical */
 case 11: /*Set Width:    Heirarchical */
 break;
 case 12: /*spacer */
 break;
 case 13: /*Set Time:Heirarchical  */
 case 14: /*Average Over: Heirarchical */
 case 15: /*Set Width:    Heirarchical */
 break;
 case 16: /*spacer */
 break;
 case 17: /*compress juggler RAM...*/
 MFMaxMem(&longPointer);
 break;
 } /* end switch */
 break;
 
 case BASE_ID:
 case (BASE_ID + 3):
 case (BASE_ID + 6): 
 case (BASE_ID + 9):
 
 configSetting = ((menuID - BASE_ID)/3);
 CheckItem(theConfiguration[configSetting].ceiling.menuHandle, (int) 
**theConfiguration[configSetting].ceiling.valueHandle, FALSE);
 **theConfiguration[configSetting].ceiling.valueHandle = (SignedByte) 
itemNumber;
 CheckItem(theConfiguration[configSetting].ceiling.menuHandle, (int) 
**theConfiguration[configSetting].ceiling.valueHandle, TRUE);
 theConfiguration[configSetting].ceiling.value = CeilingSwitch(itemNumber);
 break;

 case (BASE_ID + 1):
 case (BASE_ID + 4):
 case (BASE_ID + 7): 
 case (BASE_ID + 10):
 configSetting = (menuID - BASE_ID - 1)/3;
 CheckItem(theConfiguration[configSetting].interval.menuHandle, (int) 
**theConfiguration[configSetting].interval.valueHandle, FALSE);
 **theConfiguration[configSetting].interval.valueHandle = (SignedByte) 
(itemNumber);
 CheckItem(theConfiguration[configSetting].interval.menuHandle, (int) 
**theConfiguration[configSetting].interval.valueHandle, TRUE);
 theConfiguration[configSetting].interval.value = IntervalSwitch(itemNumber);
 break;
 
 case (BASE_ID + 2):
 case (BASE_ID + 5):
 case (BASE_ID + 8): 
 case (BASE_ID + 11):
 configSetting = (menuID - BASE_ID - 2)/3;
 CheckItem(theConfiguration[configSetting].width.menuHandle, (int) **theConfiguration[configSetting].width.valueHandle, 
FALSE);
 **theConfiguration[configSetting].width.valueHandle = (SignedByte) itemNumber;
 CheckItem(theConfiguration[configSetting].width.menuHandle, (int) **theConfiguration[configSetting].width.valueHandle, 
TRUE);
 theConfiguration[configSetting].width.value = WidthSwitch(itemNumber);
 break;

 }
 HiliteMenu(0);
}

/* doLoad */
 
doLoad()
{
 long   currentTicks, deltaTicks, barHeight, barWidth; 
 long   leftEdge, rightEdge, topEdge, bottomEdge;
 Rect   loadBar, eraseBar;
 int    i;
 

 /*sample the load */
 currentTicks = TickCount();
 deltaTicks = currentTicks - ticksGoneBy;
 ticksGoneBy = currentTicks;

 /*increment accumulators and draw load*/
 for (i = 0; i < 4; i++) {
 tickSum[i] += deltaTicks;
 tickSumDivider[i]++;
 if (tickSum[i] > theConfiguration[i].interval.value) {
 
 leftEdge = 5 + (i * BAROFFSET);
 bottomEdge = 35;/*will become resizable     */
 topEdge = 0;
 barWidth = theConfiguration[i].width.value;
 
 barHeight = (40 - ((tickSum[i] * 35)/(tickSumDivider[i] * theConfiguration[i].ceiling.value)));
 /*eliminate decimals */
 SetRect (&loadBar, leftEdge, barHeight, leftEdge + barWidth, bottomEdge);
 SetRect (&eraseBar, leftEdge, topEdge, leftEdge + barWidth, barHeight);
 EraseRect(&eraseBar);
 PaintRect(&loadBar);
 
 tickSum[i] = 0;
 tickSumDivider[i] = 0;
 } /* endif */
 } /* end for  */
}

/* quitTime */

quitTime()
{/*time to write resources, etc.   */
 int    i;
 Point  p;
 
 for (i = 0; i < 4; i++) {
 ChangedResource(theConfiguration[i].ceiling.valueHandle);
 ChangedResource(theConfiguration[i].interval.valueHandle);
 ChangedResource(theConfiguration[i].width.valueHandle);
 }
 
 SetPort(loadWindow);
 
 p.h = 0;
 p.v = 0;
 
 LocalToGlobal(&p);
 
 **windowPoshHandle = p.h;
 **windowPosvHandle = p.v;

 ChangedResource((Handle) windowPosvHandle);
 ChangedResource((Handle) windowPoshHandle);
 
 ExitToShell();
}


/* main */

main()
{

 /*variables*/
 
 EventRecordtheEvent;
 Point  eventPt;
 char   eventChar;
 WindowPtrwhichWindow, eventWindow;
 short  windowCode, stillInGoAway, controlCode, whichItem,
 scrapIndex;
 
 setUpWorld();
 setUpMenus();
 
 
 while (TRUE) {
 WaitNextEvent(everyEvent, &theEvent, (long) NIL, (RgnHandle) NIL);
 switch (theEvent.what){
 case SUSPEND_RESUME_EVT:
 if ( ! BitTst( (Ptr) theEvent.message, SUSPEND_RESUME_BIT))   
 /*suspend event */
 ;
 else (BitTst( (Ptr) theEvent.message, SUSPEND_RESUME_BIT))    
 /*resume event  */
 ;
 if ( ! BitTst( (Ptr) theEvent.message, CLIPBOARD_BIT))        /*
 don’t convert clipboard  */
 ;
 else (BitTst( (Ptr) theEvent.message, CLIPBOARD_BIT))         /*
 convert clipboard */
 ;
 break;
 case mouseDown:
 eventPt = theEvent.where;
 windowCode = FindWindow(eventPt, &eventWindow);
 switch (windowCode) {
 case inSysWindow:
 SystemClick(&theEvent, eventWindow);
 break;
 case inContent: 
 /*won’t work on minor switch 
 b/c of compatibility issues w/Excel */
 case inGrow:
 case inGoAway:
 if (eventWindow == loadWindow)
 DragWindow(eventWindow, eventPt, &dragBoundsRect);
 break;
 case inDrag:
 DragWindow(eventWindow, eventPt, &dragBoundsRect);
 break;
 case inDesk:
 break;
 case inMenuBar:
 doMenu(MenuSelect(theEvent.where));
 break;
 default: 
 break;
 } /* end switch(windowCode)*/
 break;
 
 case keyDown:
 case autoKey:
 eventChar = theEvent.message;
 if (theEvent.modifiers & cmdKey) {
 doMenu(MenuKey(eventChar));
 HiliteMenu(0);
 }
 break;
 case activateEvt:
 break;
 case updateEvt: /*absolutely necessary*/
 BeginUpdate(theEvent.message);
 EndUpdate(theEvent.message);
 break;
 case nullEvent: 
 doLoad();
 break;
 default: ;
 } /* end of case theEvent.what */
 } /* while */
}


/*
 MultiFinder.h -- MultiFinder Interfaces

 C Interface to the Macintosh Libraries
 Copyright Apple Computer,Inc.1987
 All rights reserved.
*/

#ifndef __MULTIFIN__
#define __MULTIFIN__
#ifndef __EVENTS__
#endif
#ifndef __QUICKDRAW__
#endif


/* MultiFinder dispatch trap */

#define _OSDISPATCH0xA88F
#define _WAITNEXTEVENT    0xA860



/* Routine selector values */

#define mfMaxMemSel21
#define mfFreeMemSel 24
#define mfTempNewHandleSel29
#define mfTempHLockSel    30
#define mfTempHUnLockSel  31
#define mfTempDisposHandleSel 32


#define MFMaxMem(grow) \
 cMFMaxMem(grow,mfMaxMemSel)
 
#define MFFreeMem() \
 cMFFreeMem(mfFreeMemSel)
 
#define MFTempNewHandle(logicalSize,resultCode) \
 cMFTempNewHandle(logicalSize,resultCode,mfTempNewHandleSel)
 
#define MFTempHLock(h,resultCode) \
 cMFTempHLock(h,resultCode,mfTempHLockSel)
 
#define MFTempHUnLock(h,resultCode) \
 cMFTempHUnLock(h,resultCode,mfTempHUnLockSel)
 
#define MFTempDisposHandle(h,resultCode) \
 cMFTempDisposHandle(h,resultCode,mfTempDisposHandleSel)


/* WaitNextEvent was released in MPW 2.0 interfaces. It is
 commented out below to avoid a duplicate declaration.
 Uncomment only if working with earlier interfaces. */

pascal Boolean WaitNextEvent(mask,event,sleep,mouseRgn)
 unsigned short mask;
 EventRecord *event;
 unsigned long sleep;
 RgnHandle mouseRgn;
 {
 asm {
 SUBQ.L #2, SP
 MOVE.W 20(A6), -(SP)/* short mask */
 MOVE.L 16(A6), -(SP)/* long *event*/
 MOVE.L 12(A6), -(SP)/* long sleep */
 MOVE.L 8(A6), -(SP) /* long handle*/
 DC.W _WAITNEXTEVENT
 MOVE.W (SP)+, 22(A6)/* return stack pointer state*/
 }
 }

pascal long cMFMaxMem(grow, SW)
 long   *grow;
 short  SW;
 {
 asm{
 SUBQ.L #4, SP
 MOVE.L 10(A6), -(SP)/* long *grow */
 MOVE.W 8(A6), -(SP) /* short SW */
 DC.W _OSDISPATCH
 MOVE.L (SP)+, 14(A6)/* return stack pointer state */
 }
 }

pascal Size cMFFreeMem(SW)
 short  SW;
 {
 asm{
 DC.W _OSDISPATCH
 }
 }
 
pascal Handle cMFTempNewHandle(logicalSize, resultCode, SW)
 unsigned long logicalSize;
 short  *resultCode;
 short  SW;
 {
 asm{
 DC.W _OSDISPATCH
 }
 }
 
pascal void cMFTempHLock(h, resultCode, SW)
 Handle h;
 short  *resultCode;
 short  SW;
 {
 asm{
 DC.W _OSDISPATCH
 }
 }
 
pascal void cMFTempHUnLock(h, resultCode, SW)
 Handle h;
 short  *resultCode;
 short  SW;
 {
 asm{
 DC.W _OSDISPATCH
 }
 }
 
pascal void cMFTempDisposHandle(h, resultCode, SW)
 Handle h;
 short  *resultCode;
 short  SW;
 {
 asm{
 DC.W _OSDISPATCH
 }
 }
 

#endif


*Graphic Load Appl.R
*
GLA.rsrc
RSRCWAKA

Type WAKA = STR 
 ,0
Graphic Load Average \0D© by Peter Korn \0Dver 28 JAN 1988
 
Type FREF
,128
APPL 0

Type BNDL
,128
WAKA 0
ICN#
0 128
FREF 
0 128

TYPE WIND
BarWindow,128
load
40 350 80 400
Invisible NoGoAway
3
0

TYPE SIZE = GNRL
JugglerSize, -1
5800 0000 8000 0000 8000  ;; gotten by looking at Size = -1 resource 
as general

TYPE MENU
AppleMenu, 128
\14
About Load Average
(-

FileMenu, 129
File
(Print/P
Quit/Q

EditMenu, 130
Edit
(Undo/Z
(-
(Cut/X
(Copy/C
(Paste/P
(Clear/B

ConfigureMenu, 131
Configure
Tick ceiling/\1B!\C8
Interval time/\1B!\C9
Measurement width/\1B!\CA
(-
Tick ceiling/\1B!\CB
Interval time/\1B!\CC
Measurement width/\1B!\CD
(-
Tick ceiling/\1B!\CE
Interval time/\1B!\CF
Measurement width/\1B!\D0
(-
Tick ceiling/\1B!\D1
Interval time/\1B!\D2
Measurement width/\1B!\D3
(-
Compress juggler RAM

Ceiling1Menu, 200
Ceiling1
1
2
3
4
5
6
7
8
9
10
15
20
30
60

Interval1Menu, 201
Interval1
1
2
5
10
20
60
120
180
600
1200

Width1Menu, 202
Width1
1
2
3
4
5

Ceiling2Menu, 203
Ceiling2
1
2
3
4
5
6
7
8
9
10
15
20
30
60

Interval2Menu, 204
Interval2
1
2
5
10
20
60
120
180
600
1200

Width2Menu, 205
Width2
1
2
3
4
5

Ceiling3Menu, 206
Ceiling3
1
2
3
4
5
6
7
8
9
10
15
20
30
60

Interval3Menu, 207
Interval3
1
2
5
10
20
60
120
180
600
1200

Width3Menu, 208
Width3
1
2
3
4
5

Ceiling4Menu, 209
Ceiling4
1
2
3
4
5
6
7
8
9
10
15
20
30
60

Interval4Menu, 210
Interval4
1
2
5
10
20
60
120
180
600
1200

Width4Menu, 211
Width4
1
2
3
4
5

* Program Messages Dialog box...
type DLOG
 ,258
Program Messages
100 100 200 400
Visible NoGoAway
1
0
258

type DITL
 ,258
3
BtnItem Enabled
65 230 95 285
OK

StatText Disabled
15 60 85 222 
^0\0D^1\0D^2\0D^3

IconItem Disabled
10 10 42 42
1

TYPE INFO = GNRL
Window Pos h, 150
0060    ;; initial hor window position

Window Pos v, 151
0060    ;; initial ver window position

Ceiling1, 200
01 ;; initial Ceiling1 value

Interval1, 201
01 ;; initial Interval1 value

Width1, 202
05 ;; initial Width1 value

Ceiling2, 203
02 ;; initial Ceiling2 value

Interval2, 204
02 ;; initial Interval2 value

Width2, 205
05 ;; initial Width2 value

Ceiling3, 206
03 ;; initial Ceiling3 value

Interval3, 207
03 ;; initial Interval3 value

Width3, 208
05 ;; initial Width3 value

Ceiling4, 209
04 ;; initial Ceiling4 value

Interval4, 210
05 ;; initial Interval4 value

Width4, 211 
05 ;; initial Width4 value


TYPE ALRT
MyAlert, 128 (2)
79 139 192 450
128
4444

TYPE DITL
MyDialogList, 128 (2)
4
 ButtonItem Enabled
 81 127 101 177
 OK
 
 StatText Enabled
 8 78 28 228
 Graphic Load Average
 
 StatText Enabled
 28 78 48 228
 written by Peter Korn
 
 StatText Enabled
 53 9 72 294
 Portions of this code © Think Technologies

Type ICN# = GNRL
  ,128 (0)
.H
0000 0000 0000 0000 00FF FF80 0300 0060
0400 0010 0800 0008 1000 0004 1000 0004
2000 0002 2000 0002 2000 0002 2000 F002
2000 F002 2000 F002 2000 F002 2000 F002
21E0 F002 21E0 F002 21E0 F002 21E0 F0E2
21E0 F0E2 21E0 F0E2 21E0 F0E2 21E0 F0E2
11E0 F0E4 11E0 F0E4 09E0 F0E8 05E0 F0F0
03E0 F0E0 00FF FF80 0000 0000 0000 0000
*
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
 
AAPL
$112.94
Apple Inc.
+1.16
MSFT
$47.98
Microsoft Corpora
+0.32
GOOG
$524.87
Google Inc.
+8.52

MacTech Search:
Community Search:

Software Updates via MacUpdate

NeoOffice 2014.6 - Mac-tailored, OpenOff...
NeoOffice is a complete office suite for OS X. With NeoOffice, users can view, edit, and save OpenOffice documents, PDF files, and most Microsoft Word, Excel, and PowerPoint documents. NeoOffice 3.x... Read more
LibreOffice 4.3.5.2 - Free Open Source o...
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
CleanApp 5.0.0 Beta 5 - Application dein...
CleanApp is an application deinstaller and archiver.... Your hard drive gets fuller day by day, but do you know why? CleanApp 5 provides you with insights how to reclaim disk space. There are... Read more
Monolingual 1.6.2 - Remove unwanted OS X...
Monolingual is a program for removing unnecesary language resources from OS X, in order to reclaim several hundred megabytes of disk space. It requires a 64-bit capable Intel-based Mac and at least... Read more
NetShade 6.1 - Browse privately using an...
NetShade is an Internet security tool that conceals your IP address on the web. NetShade routes your Web connection through either a public anonymous proxy server, or one of NetShade's own dedicated... Read more
calibre 2.13 - Complete e-library manage...
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
Mellel 3.3.7 - Powerful word processor w...
Mellel is the leading word processor for OS X and has been widely considered the industry standard since its inception. Mellel focuses on writers and scholars for technical writing and multilingual... Read more
ScreenFlow 5.0.1 - Create screen recordi...
Save 10% with the exclusive MacUpdate coupon code: AFMacUpdate10 Buy now! ScreenFlow is powerful, easy-to-use screencasting software for the Mac. With ScreenFlow you can record the contents of your... Read more
Simon 4.0 - Monitor changes and crashes...
Simon monitors websites and alerts you of crashes and changes. Select pages to monitor, choose your alert options, and customize your settings. Simon does the rest. Keep a watchful eye on your... Read more
BBEdit 11.0.2 - Powerful text and HTML e...
BBEdit is the leading professional HTML and text editor for the Mac. Specifically crafted in response to the needs of Web authors and software developers, this award-winning product provides a... Read more

Latest Forum Discussions

See All

This Week at 148Apps: December 15-19, 20...
Happy Holidays from 148Apps!   How do you know what apps are worth your time and money? Just look to the review team at 148Apps. We sort through the chaos and find the apps you’re looking for. The ones we love become Editor’s Choice, standing out... | Read more »
New Version of Tempo Smart Calendar Help...
New Version of Tempo Smart Calendar Helps You Plan Your Day Without Opening the App Posted by Jessica Fisher on December 22nd, 2014 [ permalink ] | Read more »
Sparkle - Advanced Cross-Synthesis (Mus...
Sparkle - Advanced Cross-Synthesis 1.0 Device: iOS Universal Category: Music Price: $6.99, Version: 1.0 (iTunes) Description: Sparkle is a tool for advanced spectral hybridizations made of several algorithms that operate on frequency... | Read more »
DICETINY is coming to iOS in 2015
DICETINY is coming to iOS in 2015 Posted by Jessica Fisher on December 22nd, 2014 [ permalink ] Fakedice has announced that they’re bringing their digital board game DICETINY to iOS. | Read more »
It Came From Canada: The Witcher Battle...
The Witcher 3: Wild Hunt may still be a few months away, but very soon players will be able to get a new taste of the acclaimed Polish RPG on their mobile devices with The Witcher Battle Arena. While it trades open-world exploration for compact... | Read more »
The Babies Get Lost Again in the New Azt...
The Babies Get Lost Again in the New Aztec Ruins Update for Light in the Dark Posted by Jessica Fisher on December 22nd, 2014 [ permalink ] | Read more »
Living Room 3D for IKEA Makes All In-App...
Living Room 3D for IKEA Makes All In-App Purchases Free Until 2015 Posted by Jessica Fisher on December 22nd, 2014 [ permalink ] | Read more »
Crossbow Warrior – The Legend of William...
Crossbow Warrior – The Legend of William Tell Review By Lee Hamlet on December 22nd, 2014 Our Rating: :: MISSES THE MARKUniversal App - Designed for iPhone and iPad Crossbow Warrior details the entertaining adventures of legendary... | Read more »
A New Update Races onto Asphalt 8: Airbo...
A New Update Races onto Asphalt 8: Airborne Posted by Jessica Fisher on December 22nd, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Workflow: Powerful Automation Made Simpl...
Workflow: Powerful Automation Made Simple Review By Campbell Bird on December 22nd, 2014 Our Rating: :: GO WITH THE FLOWUniversal App - Designed for iPhone and iPad This powerful app lets users accomplish multiple tasks at touch of... | Read more »

Price Scanner via MacPrices.net

13-inch 2.4GHz Retina MacBook Pro (Apple refu...
The Apple Store has previous-generation Apple Certified Refurbished 13″ 2.4GHz/128GB Retina MacBook Pros available for $999. Apple’s one-year warranty is standard, and shipping is free: - 13″ 2.4GHz/... Read more
Apple resellers offer free overnight shipping
The Apple Store is now offering free next-day shipping on all in stock items if ordered before 12/23/14 at 10:00am PT. Local store pickup is also available within an hour of ordering for any in stock... Read more
Holiday sales continue: MacBook Airs for up t...
 B&H Photo has 2014 MacBook Airs on sale for up to $120 off MSRP, for a limited time, for the Thanksgiving/Christmas Holiday shopping season. Shipping is free, and B&H charges NY sales tax... Read more
Holiday sale continues: 13-inch Retina MacBoo...
 B&H Photo has new 13″ MacBook Pros on sale for up to $150 off MSRP as part of their Holiday pricing. Shipping is free, and B&H charges NY sales tax only: - 13″ 2.5GHz MacBook Pro: $979 save... Read more
Holiday sale continues: 15-inch Retina MacBoo...
 B&H Photo has the new 2014 15″ Retina MacBook Pros on sale for up to $300 off MSRP for a limited time. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.2GHz Retina MacBook Pro: $... Read more
Holiday sale: 13-inch 128GB MacBook Air for $...
 Best Buy has the 2014 13-inch 1.4GHz 128GB MacBook Air on sale for $849.99, or $150 off MSRP, on their online store. Choose free home shipping or free local store pickup (if available). Price valid... Read more
13-inch 2.6GHz Retina MacBook Pro on sale for...
Best Buy has lowered their price on the 2014 13″ 2.6GHz/128GB Retina MacBook Pro to $1149.99 on their online store for a limited time. That’s $150 off MSRP and the lowest price available for this... Read more
Kodak Returns to CES With New Consumer Produ...
Former photography colossus Kodak is returning to CES for the first time in three years where the Kodak booth (#21818 South Hall 1) will showcase a wide range of innovative, imaging-related products... Read more
Invaluable Launches New Eponymously -Named A...
Invaluable, the world’s largest online live auction marketplace, hhas announced the official launch of the Invaluable app for iPad, now available for download in the iTunes App Store. Invaluable... Read more
IDC Reveals Worldwide Mobile Enterprise Appli...
International Data Corporation (IDC) last week hosted the IDC FutureScape: Worldwide Mobile Enterprise Applications and Solutions 2015 Predictions Web conference. The session provided organizations... Read more

Jobs Board

*Apple* Store Leader Program (US) - Apple, I...
…Summary Learn and grow as you explore the art of leadership at the Apple Store. You'll master our retail business inside and out through training, hands-on experience, Read more
Project Manager, *Apple* Financial Services...
**Job Summary** Apple Financial Services (AFS) offers consumers, businesses and educational institutions ways to finance Apple purchases. We work with national and Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.