TweetFollow Us on Twitter

Hourglass
Volume Number:5
Issue Number:5
Column Tag:HindCight

Related Info: Vert. Retrace Mgr

Lisa's Hourglass Is Back!

By Mike Morton, Waipahu, HI

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

Back to the Future: The Lisa’s hourglass cursor comes to life

In the rivalry between Lisa and Macintosh at Apple, many Lisa features weren’t carried over into Mac development: a large screen, multi-tasking, stationery pads, virtual hardware, a huge keyboard Now that these features are slowly reappearing in Macs, it’s time to bring back one more dead Lisa feature -- the hourglass cursor -- and also breathe a little life into it. (Let’s just not bring back rectangular pixels.)

This article actually shows you the low-level mechanics of three kinds of animated cursors:

• a one-handed watch, a simple sequence of ordinary cursors

• a two-handed watch, built by combining cursors

• an hourglass with falling sand: “drawn” by the application

There’s been a lot of discussion (see Further Reading) of whether an animated cursor should be done by a VBL (timed) task so the main program doesn’t have to keep calling it. When I originally wrote these routines some years back (in MDS assembler), I made them a VBL task. I’m no longer sure that’s a good idea. So this package doesn’t animate on its own, but it should be easy to write a timed task to call them.

Figure 1. Details of building the hourglass

Figure 2. Components of watch cursor

Some notes on VBL cursor animation

In case you do want to make the cursor run on its own, here are some things to keep in mind. (Thanks to Seth Lipkin for telling me about a number of these surprises )

• Remember that when a VBL task wakes up, the globals pointer (A5) isn’t guaranteed and memory management can’t be performed. Further, under MultiFinder, the CurrentA5 variable may hold someone else’s A5! You should store your A5, if you need it, adjacent to your task’s VBL entry.

• There’s a low RAM location called CrsrBusy. As I understand it, when this byte is non-zero, you shouldn’t do a SetCursor -- I suspect it means there’s a SetCursor already in progress. If your VBL task sees this flag, it should probably just try again in one tick.

• The low-memory CrsrVis flag is cleared when the cursor’s not visible (it’s been hidden or temporarily obscured). Again, call back later.

• Probably the biggest problem with VBL tasks is that they keep running no matter what. If your application locks up, the user will still see some life, and may not realize what’s going on. If you must use the VBL trick, you might consider making the same task function as a “watchdog timer”, trying to figure out if the application is doing anything. If the application fails to bump some counter at least every n seconds, the task could hint at this with a different cursor. It’s very risky to tell the user any other way, since any dialog would mean memory management. (I’m not sure if a VBL task can use the Notification Manager )

Figure 3. Assembling a two-handed watch

Drawing methods

So if this package isn’t going to run the cursor on its own, what good is it? Well, it does various kinds of drawing, from simple to tricky. Each of the three cursor types has a different drawing method.

The watch cursor functions a lot like the Finder’s. There’s a single list of cursors which are shown in a cycle. This could be done with a Finder-style ACUR resource, but if you want to do the animation with a timed task, you don’t want to do GetResource calls. (Actually, you could load the resources and make them non-purgeable before starting. But another reason is that all the data used by this watch is also used by the two-handed variant.)

There are 12 frames to this animation sequence, shown in the top part of Figure 2.

The two-handed watch is only slightly more complicated. It uses two sets of data, one for the minute hand and one (in the bottom of Figure 2) for the hour hand. The hour hand has only 8 positions; I couldn’t draw 12 hands that small and keep it looking nice. So don’t worry if it looks like “four-thirty o’clock”.

Figure 3 shows how the hour and minute hand are logically “or”-ed together to make a two-handed watch. Like a real clock, the hour hand’s position advances only once per revolution of the minute hand.

The hourglass is a lot more complicated. Looking at parts of Figure 1 shows some examples of how a grain of sand, a black pixel, moves: At any given time, a single grain of sand is moving (a). When it lands on top of another grain (b), it randomly falls to one side or the other (c). If it lands with only one side open (d), it falls to the open side (e). If it lands with several steps to fall (f), it falls all the way until it doesn’t have an opening on either side below (g). [Note that the bottom line of the hourglass must already be solid black pixels, or the sand will try to “leak out”.] Finally, when a grain of sand drops as far as it can, and it’s above a certain level (h), the bottom chamber is full, and the cycle starts over.

Every movement by the grain takes a single animation frame. A similar process is “stealing” a grain from the top chamber. This follows a similar path upwards, but walks the whole path at once each time it needs a new grain -- see the comments below on the stealGrain function.

The sample driver program

This main program isn’t a shining example of Macintosh programming style. It’s just meant to show all the functionality of the subroutines.

Menu commands let you select from among the three types of cursors; control the speed; and quit. That’s about it.

The structure of the program is simple. The main loop calls the cursor animation routine at idle time, also calls SystemTask, and then does simple event handling -- just enough to operate the menus.

One thing to note while using the program is the flicker. On a Macintosh Plus or SE, the screen refresh is linked to the tick count. Even though the task is not implemented as a VBL task, the cursor update takes place near the beginning of a tick. This is apparent on the Plus or SE because the cursor flickers more when it’s near the top of the screen. On a Mac II, where the monitor’s refresh rate isn’t sync’d with the ticker, the cursor flickers sporadically at any point on the screen.

A feature I included in the original (ca. 1986) program was a way to measure how much CPU time the cursor animation takes up. The program would see how many times it could execute a loop with the cursor running at various speeds, and not running at all. I haven’t done the measurements for this LightspeedC version, but that assembler version took up less than 2% of the CPU time if the animation was 15 times per second or less. Animating at 60 times per second could take up to around 7% of the time. You have to watch out for this, since your application is presumably showing the cursor to apologize for some slow operation in the first place!

[A side note: the time used is dependent on the cursor’s horizontal position, since SetCursor has to shift the image into position -- the function is a sawtooth curve with a 16-pixel period on a Mac Plus or SE. This took a long time to find ]

Finally, note that “main.c” includes “AnimCurs.h”, which contains the prototypes specifying the interface to the package.

The subroutines

Here’s a quick tour through the contents of the subroutine package.

Data structures: Each of the three cursor variants has a struct defined for it, remembering the state of the drawing so it can be updated. Then there’s a type “cursInfo”, which is a union of all three, plus the current cursor, timing information, and the variable controlling which type of cursor is being shown.

Note that this structure has to remember the whole state of the cursor. For the watches, it just has to remember one or two hand positions. For the hourglass, it must keep track of whether or not there’s a falling grain of sand, and the current column (stored as a bit) and row the sand is at. Unlike with the other types, the cursor data itself is part of the information, because some routines examine its bits to see where the sand should fall.

Data:

I’ve included all the masks and data in-line. They probably ought to be resources. If they were, some care would be needed if the routines were being called from a VBL task.

Functions:

The three initialization (acStartxxx) routines all do about the same thing: set up the delay, the type, the cursor mask and data, and type-specific information.

Two utility routines (copy16, or16) are used to copy and combine the “Bits16” type, which holds a cursor’s mask or data.

hideGrain and showGrain just change the visibility of the current grain of sand. They’re a good example of how the state information is self-contained; they need no parameters. moveGrain just updates the position by hiding, moving, and showing the grain.

coinFlip is kind of cool. I didn’t want to use QuickDraw’s random number generator. (In addition to needing A5, it can mess up an application’s random sequence by stealing elements from it nondeterministically.) So I used a method which is simplified from the engine used in the “DissBits” subroutine. Although the random numbers used in that subroutine are poor, the random bits used by coinFlip() are quite random. [See Knuth in Further Reading for details.]

stealGrain takes a random pixel from the top chamber and turns it white. It works by percolating through black pixels until it reaches the top or runs out of black pixels. It’s a lot like the way a single black pixel percolates down through white ones, but it percolates all at once when a new grain is needed. dropGrain just steals a grain from the top, then sets up a new grain and marks it as moving.

Three routines advance specific cursor types. nextWatch and nextWatch2 are very simple. nextHour drops a grain if needed and then advances the current grain by one pixel. doNextFrame just cases out on the current cursor type to call one of these three.

Two final routines are called from the application: acNext should be called as often as possible. When it’s time to do so, it computes and displays the next cursor. acDelay can be called to set the delay, in ticks, between frames.

Projects for a rainy day

I’ve kept the scope of this project small. Here are some varied ways you could take it from here:

• Intercept GetResource calls for type ACUR and CURS in someone else’s application. When they think they’re just displaying a sequence of cursors, you could be computing and displaying something much more complex, such as the hourglass.

• Sort of the opposite: Intercept SetCursor calls and record the cursors and the delays in between them. Automatically build and save an ACUR resource. Then anything drawn “on the fly” (like the hourglass) can be transcribed as an ACUR and stored for simple programs (like the Finder) to use. Of course, these may turn out quite large.

• Experiment with changing the mask in the hourglass so the glass part is “transparent”. You’ll have to modify the mask as the data portion is modified, too.

• Add an arrow type to the set of cursors supported, so acNext () can always be called at idle, whether or not there’s animation going on. Hint: if the cursor variant is an arrow, acNext () does nothing.

• Handle color cursors.

• Time the routines and choose an optimal animation rate to keep the animation smooth yet lessen flicker and not use too much CPU time. Try it on various CPUs and monitors to check both performance and appearance.

• Write a VBL task which makes the cursor animate automatically. Have it notice when another part of the program does a SetCursor trap, and assume this means it should turn itself off. (In an older program, I examined the low-memory cursor data to see if the cursor had changed; probably a bad move for color cursors )

• Put everything into a driver, so any development system can use it. Could you have it get time during SystemTask calls, so the application needn’t call it?

Further reading

For more on the method used in the coinFlip() routine, see:

• Donald Knuth, The Art of Computer Programming, 2nd ed., Vol II: Seminumerical Algorithms,pp. 29-31

• Mike Morton, “A Digital Dissolve Effect for Bitmapped Graphics Screens”, Dr. Dobb’s Journal , November 1986

• Mike Morton, “The DissBits Subroutine”, MacTutor, December 1985

• William H. Press, et al, Numerical Recipes: The Art of Scientific Computation, pp. 209-213

Knuth’s writeup is the most interesting as far as a theoretical basis. The Recipes includes a useful table of constants. My DDJ article is more in-depth as far as applying the method.

For more on the vertical retrace manager, see:

• “The Vertical Retrace Manager”, Inside Macintosh, Vol. II, pp. 347-354

• Robert B. Denny, “Using the Vertical Retrace Manager”, August 1985

For more on animation (of cursors or anything), see:

• Dick Chandler, “VBL Task Animation”, MacTutor, February 1989

• Stuart Gordon, dir., “Re-Animator”, 1985

• Letters, MacTutor, March 1988, p. 12

• Mike Morton, “Alternate Video Screen Animation”, MacTutor, June 1986

• David Stoops, “Animated Cursors”, Letters, MacTutor, December 1988, pp. 108-109

Conclusions

We’ve covered three ways to animate cursors -- two simple ones based on resource-like data and one which does the drawing more “by hand”. Doing the drawing directly into a cursor with bit manipulation is much faster than using QuickDraw to set and clear pixels. It’s acceptable because the format of a monochrome cursor isn’t about to change.

The animation routines are decoupled from the issue of whether the animation should be invoked from an idle routine or from a timed task. Timed tasks bring the risk that a user gets no indication of when the application is hung up, along with various technical subtleties. If you do want to make a task animate your cursor, it might be a good idea to make the task also check for signs of life in the application.

Listing:  AnimCurs.h

/* Prototypes for the animated cursor subroutines.
 See “AnimCurs.c” for details on how to call these.
*/

void acStartHG (int delay);/* set up for hourglass cursor */
void acStartW1 (int delay);/* set up for one-handed watch */
void acStartW2 (int delay);/* set up for two-handed watch */

void acDelay (int delay); /* set delay between frames */

void acNext (void);/* idle-time call: advance cursor */
Listing:  AnimCurs.c

/* Animated Cursor subroutines.

Copyright © 1989 by Michael S. Morton, all rights reserved.
Written February ’89 for MacTutor.  Feel free to use these or
modify them so long as the original author and source are noted.

 Routines included are:
 • acStartHG -- set the cursor to be an hourglass
 • acStartW1, acStartW2 -- set the cursor to be a 1- or 2-handed watch
 • acDelay -- set the delay, in ticks, between animation steps
 • acNext -- idle-time routine 

To set up any of these cursors, call the acStart___ routine, passing 
the delay you’d like between frames.  Then call acNext during your idle 
routine.  To change the delay, call acDelay.  To get a different kind 
of cursor, stop calling acNext and use SetCursor to get it.
*/

/* State information for three cursor types: */
typedef struct   /* info on the HOURGLASS: */
{long coin; /* used in random number generator */
 int grainRow;   /* row number (0 15) of falling grain */
 int grainBit;   /* bit mask for falling grain */
 Boolean grainMoving;/* flag: is the grain still moving? */
} hourInfo; /* define this type */

typedef struct   /* info on ONE-HANDED WATCH: */
{int wFrame;/* which frame of animation are we on? */
} watch1Info;    /* define this type */

typedef struct   /* info on TWO-HANDED WATCH: */
{int mFrame;/* frame of minute hand */
 int hFrame;/* frame of hour hand */
} watch2Info;    /* define this type */

/* Generalized cursor type: */
typedef enum
{ hgType, w1Type, w2Type } cursType; /* selects one of above structs 
*/

typedef struct   /* tracks any kind of cursor */
{Cursor curs;    /* current cursor */
 int delay; /* delay between frames (ticks) */
 long nextFrame; /* time of next frame (ticks) */
 cursType type;  /* type of cursor */
 union  /* depending on type of cursor: */
 { hourInfo hg;  /*  • info on hourglass */
 watch1Info w1;  /*  • info on one-handed watch */
 watch2Info w2;  /*  • info on two-handed watch */
 } u;   /* give union an easy name */
} cursInfo, *ciPtr;

/* cursor information is used globally all through file. */
cursInfo theInfo;/* sole instance of this struct */

/* 16x16 data and masks for cursors.  Some of these are OR’d together 
to make the two-handed watch.  Others are just backgrounds which are 
drawn on, such as for the hourglass. */
int hourData [16] =/* hourglass, about to start falling */
 { 0xFFFE, 0x7FFC, 0x7FFC, 0x7FFC, 0x5FF4, 0x4FE4, 0x47C4, 0x4384, 0x4284, 
0x46C4, 0x4C64, 0x5834, 0x701C, 0x600C, 0x4004, 0xFFFE };
int hourMask [16] = { 0xFFFE, 0x7FFC, 0x7FFC, 0x7FFC, 0x5FF4, 0x4FE4, 
0x47C4, 0x4384, 0x4384, 0x47C4, 0x4FE4, 0x5FF4, 0x7FFC, 0x7FFC, 0x7FFC, 
0xFFFE };

int watchMask [16] = {  0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x7F00, 0xFF80, 
0xFF80, 0xFFC0, 0xFFC0, 0xFF80, 0x7F00, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 
0x0000 };

int watchMinutes [12][16] = /* twelve minute-hand positions */
{
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4900, 0x8880, 0x8880, 0x88C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4300, 0x8480, 0x8480, 0x88C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8180, 0x8680, 0x88C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x8FC0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x88C0, 0x86C0, 
0x8180, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x88C0, 0x84C0, 
0x8480, 0x4300, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x88C0, 0x88C0, 
0x8880, 0x4900, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x88C0, 0x90C0, 
0x9080, 0x6100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x88C0, 0xB0C0, 
0xC080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0xF8C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0xC080, 0xB080, 0x88C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x6100, 0x9080, 0x9080, 0x88C0, 0x80C0, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 }
};

int watchHours [8][16] =  /* eight hour-hand positions */
{
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8880, 0x8880, 0x8880,0x8080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8480, 0x8880,0x8080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x8E80,0x8080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x8880, 0x8480, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x8880, 0x8880, 
0x8880, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0x8880, 0x9080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x8080, 0xB880, 0x8080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 },
 { 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x4100, 0x8080, 0x9080, 0x8880, 0x8080, 
0x8080, 0x4100, 0x3E00, 0x3E00, 0x3E00, 0x3E00, 0x0000 }
};

/* Function prototypes for stuff we define externally: */
#include “AnimCurs.h”

/* Function prototypes for our static stuff: */
void acStartW (cursType type, int delay); /* start either kind of watch 
*/
void copy16 (int *src, Bits16 *dst);/* copy 16x16 bit image */
void or16 (int *src, Bits16 *dst); /* OR a 16x16 bit image */
void hideGrain (void);    /* hide current grain in hourglass */
void showGrain (void);    /* show current grain in hourglass */
Boolean coinFlip (void);  /* produce a pseudo-random boolean */
void stealGrain (void); /* remove a grain from top section */
void dropGrain (void);    /* get a grain moving */
void moveGrain (int dh, int dv);/* move a grain in transit */
void nextHour (void);/* compute next cursor: hourglass */
void nextWatch (void);    /* watch */
void nextWatch2 (void); /* 2-handed watch */
void doNextFrame (void);  /* compute next frame and show it */

/* acStartHG () -- Initialize the hourglass cursor, with the specified 
delay between animation frames.  This is an external routine. */
void acStartHG (delay)
 int delay; /* INPUT: pause between frames */
{theInfo.delay = delay; /* record delay in structure */
 theInfo.nextFrame = TickCount () + delay; /* figure when to animate 
next */
 theInfo.type = hgType; /* remember the type: hourglass */
 theInfo.u.hg.grainRow = -1; /* make a grain drop in dropGrain () */

 /*Initialize cursor data, mask and hotspot (altho dropGrain does data, 
too) */
 copy16 (hourData, & (theInfo.curs.data));   
 copy16 (hourMask, & (theInfo.curs.mask));
 theInfo.curs.hotSpot.v = 8;/* stick hotspot  */
 theInfo.curs.hotSpot.h = 8;/*  in middle */

 dropGrain ();   /* start first grain dropping */
}/* end of acStartHG () */

/* acStartW1 () -- Just like acStartHG, but with a one-handed watch. 
This is an external routine.
*/
void acStartW1 (delay)
 int delay; /* INPUT: pause between frames */
{acStartW (w1Type, delay);
}/* end of acStartW1 () */

/* acStartW2 () -- Just like acStartHG, but with a two-handed watch. 
This is an external routine.
*/
void acStartW2 (delay)
 int delay; /* INPUT: pause between frames */
{acStartW (w2Type, delay);
}/* end of acStartW2 () */

/* acStartW () -- Start a one- or two-handed watch. */
static void acStartW (type, delay)
 cursType type;  /* INPUT: w1Type or w2Type */
 int delay; /* INPUT: pause between frames */
{theInfo.delay = delay;   /* record delay in structure */
 theInfo.nextFrame = TickCount () + delay; /* figure when to animate 
next */
 theInfo.type = type;/* remember the type */

 if (type == w1Type) /* init different types: */
 theInfo.u.w1.wFrame = 0; /* one-handed: set to zero */
 else
 { theInfo.u.w2.mFrame = 0; /* two-handed: set minute */
 theInfo.u.w2.hFrame = 0; } /*  and hour frame to zero */

 /*Initialize the cursor data, mask and hotspot: */
 copy16 (watchMinutes [0], & (theInfo.curs.data));
 copy16 (watchMask, & (theInfo.curs.mask));
 theInfo.curs.hotSpot.v = 8;/* stick hotspot  */
 theInfo.curs.hotSpot.h = 8;/*  in middle */
}/* end of acStartW () */

/* copy16 () -- Copy an array of 16 ints into a Bits16 structure (the 
data or mask of a cursor. */
void copy16 (src, bits)
 register int *src;/* INPUT: source data */
 Bits16 *bits;   /* OUTPUT: where to stuff it */
{register int *dst = (int *) bits; /* coerce to a handier data type */
 int i; /* FORTRAN-ish loop counter */

 for (i = 0; i <= 15; i++) *dst++ = *src++; /* copy 16 words */
}/* end of copy16 () */

/* or16 () -- Just like copy16(), but we OR, not COPY. */
void or16 (src, bits)
 register int *src;/* INPUT: source data */
 Bits16 *bits;   /* OUTPUT: where to stuff it */
{register int *dst = (int *) bits; /* coerce to a handier data type */
 int i; /* FORTRAN-ish loop counter */

 for (i = 0; i <= 15; i++) *dst++ |= *src++; /* OR 16words */
}/* end of or16 () */

/* hideGrain () -- Hide pixel where the current grain is. */
static void hideGrain ()
{theInfo.curs.data [theInfo.u.hg.grainRow] &=
 (~ theInfo.u.hg.grainBit);
}

/* showGrain () -- Show the pixel where current grain is. */
static void showGrain ()
{theInfo.curs.data [theInfo.u.hg.grainRow] |=
 theInfo.u.hg.grainBit;
}

/* coinFlip () -- Return a pseudo-random boolean value.  We use shift-register 
system detailed in Knuth, among other places. */
static Boolean coinFlip ()
{register Boolean result;

 if (! theInfo.u.hg.coin) /* zero? */
 theInfo.u.hg.coin = 1;   /* avoid demon state */
 result = (theInfo.u.hg.coin < 0);/* note if high bit set */

 theInfo.u.hg.coin <<= 1; /* shift old value over 1 bit  */
 if (result)/*  and if top bit was ‘1’  */
 theInfo.u.hg.coin ^= 0xc5; /*  then futz with low bits */

 return (result);
}/* end of coinFlip () */

/* stealGrain -- Grab a grain of sand from the top chamber of the hourglass. 
We want to percolate a white pixel up from the starting bit position. 
*/
static void stealGrain ()
{register int v = 6; /* start at row 6, tip of top half */
 register int hBit = 0x0100;/* start at the middle */
 register Boolean done = false;  /* haven’t finished percolating yet 
*/
 register int aboveWord;  /* row of sand grains above us */
 register Boolean leftOK, rightOK; /* are there bits to steal above? 
*/

 while (! done)
 { --v; /* assume we can move up a row */
 aboveWord = theInfo.curs.data [v];/* get that row from the cursor image 
*/

 /*Decide which direction to steal from -- if there’s a grain right above 
us, we’ll take that.  Otherwise, we have to choose between the ones diagonally 
up from us. */
 if ((aboveWord & hBit) == 0) /* have a bit above us? */
 { leftOK = (0 != (aboveWord & (hBit << 1))); /* have someone above on 
left? */
 rightOK = (0 != (aboveWord & (hBit >> 1))); /* someone above on right? 
*/

 /*Branch, depending on which way(s) we can go: */
 if (leftOK && rightOK)   /* both available? */
 { if (coinFlip ()) hBit <<= 1;  /* yes: flip a coin  */
 else hBit >>= 1;/*  to decide */
 }
 else if (leftOK) hBit <<= 1; /* just left: take it */
 else if (rightOK) hBit >>= 1;/* just right: take it */
 else { ++v; done = true; } /* neither: back down */
 } /* end of no bit above us */

 if (v <= 1) done = true; /* if we hit top row, we have to stop */
 } /* end of while-not-done */

 theInfo.curs.data [v] &= (~ hBit);/* snuff this bit */
}/* end of stealGrain () */

/* dropGrain () -- Get next grain of sand to fall.  The “moving” flag 
is false. We get one grain of sand from the top chamber.  If the bottom 
chamber is filled, we reinit the cursor to a full top chamber.  Either 
way, we flagthat a grain is moving, and draw it.
*/
static void dropGrain ()
{stealGrain ();  /* pull a grain from the top chamber */

 /*If the pile in the bottom chamber has filled it, the most recent grain 
dropped didn’t get very far. */
 if (theInfo.u.hg.grainRow < 9)  /* are we piled too high? */
 copy16 (hourData, & (theInfo.curs.data));   /* yes: redraw all */

 theInfo.u.hg.grainRow = 8; /* set row number of new grain */
 theInfo.u.hg.grainBit = 0x0100;   /* set bit in row */
 theInfo.u.hg.grainMoving = true;  /* we’re cooking with gas now */
 showGrain ();   /* show the grain */
}/* end of dropGrain () */

/* moveGrain () -- Move the current grain by a given delta.  Note that 
a positive “dh” is a right shift. */
static void moveGrain (dh, dv)
 int dh, dv;/* INPUT: amount to move by */
{hideGrain ();   /* hide where it is now */

 theInfo.u.hg.grainRow += dv; /* update vertical position */
 if (dh > 0)/* update horizontal position */
 theInfo.u.hg.grainBit >>= dh;
 else theInfo.u.hg.grainBit <<= -dh;

 showGrain ();   /* show where it is now */
}/* end of moveGrain () */

/* nextHour () -- Advance the hourglass by one frame. */
static void nextHour ()
{register int v, hBit;/* coordinate and bit pos of grain */
 register int nextWord;   /* word of grains below us */
 register Boolean leftOK, rightOK; /* flags for OK directions to fall 
*/

 if (! theInfo.u.hg.grainMoving)   /* grain hit bottom last time? */
 dropGrain ();   /* yes: get a new one */

 v = theInfo.u.hg.grainRow; /* grab position and bit just  */
 hBit = theInfo.u.hg.grainBit;/*  for easier typing & efficiency */

 nextWord = theInfo.curs.data [v+1]; /* get word below this one */
 if ((nextWord & hBit) == 0)/* slot below us free? */
 { moveGrain (0, 1); /* yes: just move down one */
 return;/* and that’s all we need */
 }

 leftOK = (0 == (nextWord & (hBit << 1))); /* have nobody below on left? 
*/
 rightOK = (0 == (nextWord & (hBit >> 1))); /* nobody below on right? 
*/

 /*Branch, depending on which way(s) we can go: */
 if (leftOK && rightOK)   /* can fall left or right? */
 { if (coinFlip ())/* yes: randomly choose: */
 moveGrain (1, 1); /*  • fall to the right */
 else moveGrain (-1, 1);  /*  • fall to the left */
 }
 else if (leftOK) moveGrain (-1, 1); /* left only: do it */
 else if (rightOK) moveGrain (1, 1); /* right only: do it */
 else theInfo.u.hg.grainMoving = false; /* can’t move: stop; reset next 
time */
}/* end of nextHour () */

/* nextWatch -- Compute the next frame of one-handed watch animation. 
*/
static void nextWatch ()
{++ theInfo.u.w1.wFrame;  /* bump frame ahead by 1 */
 if ((theInfo.u.w1.wFrame) >= 12)/* outside of range 0 11? */
 theInfo.u.w1.wFrame = 0; /* yes: wrap around */

 copy16 (watchMinutes [theInfo.u.w1.wFrame],
 & (theInfo.curs.data));
}/* end of nextWatch () */

/* nextWatch2 -- Compute the next frame of two-handed watch animation. 
*/
static void nextWatch2 ()
{++ theInfo.u.w2.mFrame;  /* bump MINUTE frame ahead by 1 */
 if ((theInfo.u.w2.mFrame) >= 12)/* outside of range 0 11? */
 theInfo.u.w2.mFrame = 0; /* yes: wrap around */

 copy16 (watchMinutes [theInfo.u.w2.mFrame],
 & (theInfo.curs.data));

 if (theInfo.u.w2.mFrame == 0)/* MINUTE frame just hit 12 o’clock? */
 { ++ theInfo.u.w2.hFrame;/* yes: bump HOUR frame ahead by 1 */
 if ((theInfo.u.w2.hFrame) >= 8) /* outside of range 0 7? */
 theInfo.u.w2.hFrame = 0; /* yes: wrap around */
 }

 /*Add hour-hand image into minute-hand. */
 or16 (watchHours [theInfo.u.w2.hFrame],
 & (theInfo.curs.data));
}/* end of nextWatch () */

/* doNextFrame -- Compute next frame, dispatching on type of cursor. 
*/
static void doNextFrame ()
{switch (theInfo.type)
 { case hgType:  nextHour (); break;
 case w1Type:  nextWatch ();break;
 case w2Type:  nextWatch2 (); break;
 default: break;
 } /* end of switch on cursor type */
}/* end of doNextFrame () */

/* acNext-Idle-time animation.  This is an external routine.*/
void acNext ()
{if (TickCount () < theInfo.nextFrame) /* time to animate yet? */
 return;/* nope: return */

 theInfo.nextFrame = TickCount () + theInfo.delay; /* reset wake-up call 
*/
 doNextFrame (); /* draw next frame internally */
 SetCursor (& (theInfo.curs));/* and display it */
}/* end of acNext () */

/* acDelay -- Set delay, in ticks, between frames.  This is an external 
routine.
*/
void acDelay (delay)
 int delay; /* INPUT: new delay */
{theInfo.delay = delay;
 theInfo.nextFrame = TickCount () + delay; /* figure when to animate 
next */
}/* end of acDelay () */
Listing: main.c

/* Animated Cursor demonstration main program.

Copyright © 1989 by Michael S. Morton, all rights reserved.
 Written February ’89 for MacTutor.
*/

#include “AnimCurs.h”/* define functions in package */

/* Internal prototypes: */
void main (void);
void makeMenus (void);
void doMenu (long result);

int theDelay = 4;/* delay between animation frames, tix */

enum    /* items in our sole menu */
{mnWatch = 1, mnWatch2, mnHourG, mnUnused1,
 mnFaster, mnSlower, mnTop, mnUnused2, mnQuit };

void main ()
{EventRecord evtRec; /* info from GetNextEvent () */
 int inWhat;/* from FindWindow (): where was click? */
 WindowPtrtheWin;/* unused -- just for FindWindow () */
 long menuResult;/* from MenuKey () or MenuSelect () */

 /*Usual initializations: perhaps more than we need here. */
 InitGraf (&thePort);/* initialize QuickDraw */
 InitFonts ();   /* init the Font Manager */
 FlushEvents (everyEvent, 0);/* ignore pending events */
 InitWindows (); /* init the Window Manager */
 InitMenus ();   /* init the Menu Manager */
 TEInit (); /* init TextEdit */
 InitDialogs (0L); /* init Dialog Mgr; no restart proc */
 InitCursor ();  /* show standard arrow cursor */

 makeMenus ();   /* set up one cheap little menu */
 acStartW1 (theDelay);  /* initialize to a one-handed watch */

 /*Main loop: at idle time, update the cursor.  Check for menu commands 
via the mouse or keyboard. */
 while (1)
 { acNext ();    /* idle time: animate the cursor */
 SystemTask ();  /* can’t hurt, altho we don’t do DAs */

 if (GetNextEvent (everyEvent, & evtRec))    /* try for an event */
 { if (evtRec.what == mouseDown)   /* click? */
 { inWhat = FindWindow (evtRec.where, &theWin); /* look up where it hit 
*/
 if (inWhat == inMenuBar) /* menu click? */
 doMenu (MenuSelect(& (evtRec.where))); /* track & process menu hit */
 else SysBeep (2); /* can’t handle clicks elsewhere */
 } /* end of handling mouseDown */

 else if (evtRec.what = keyDown)   /* keypress?  */
 doMenu (MenuKey((char) evtRec.message)); /* don’t require cmdKey */
 } /* end of handling one event */

 } /* end of infinite loop */
}/* end of main () */

/* Make menu in-line.  (Resources?  This is just a demo driver ) */
void makeMenus ()
{MenuHandle theMenu; /* our sole menu */

 theMenu = NewMenu (1, “\pMenu”);
 AppendMenu (theMenu, “\pWatch/W;Two-handed watch/2;Hourglass/H;(-”);
 AppendMenu (theMenu, “\pFaster/F;Slower/S;Top speed/T;(-”);
 AppendMenu (theMenu, “\pQuit/Q;(-”);
 AppendMenu (theMenu, “\pAnimated Cursor Demo;written in LightspeedC”);
 AppendMenu (theMenu, “\pCopyright © 1989;Michael S. Morton;for MacTutor”);
 InsertMenu (theMenu, 0); /* put it in the menu bar */
 DrawMenuBar (); /* show our handiwork */
}/* end of makeMenus () */

void doMenu (result)
 long result;    /* INPUT: result from MenuSelect/Key */
{int command = LoWord (result);  /* extract item number */

 switch (command)
 { case mnWatch: acStartW1 (theDelay); break;
 case mnWatch2:  acStartW2 (theDelay); break;
 case mnHourG:   acStartHG (theDelay); break;

 /*Note that we can’t let the delay go down to zero for “Faster”. */
 case mnFaster:  if (theDelay>1) --theDelay; acDelay (theDelay); break;
 case mnSlower:  ++theDelay;  acDelay (theDelay); break;
 case mnTop:theDelay = 1; acDelay (theDelay); break;

 case mnQuit:    ExitToShell (); break;
 default: break; /* ignore unrecognized items */
 } /* end of switch on command */

 HiliteMenu (0);
}/* end of doMenu () */

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

OmniOutliner Pro 5.4.1 - Pro version of...
OmniOutliner Pro is a flexible program for creating, collecting, and organizing information. Give your creativity a kick start by using an application that's actually designed to help you think. It's... Read more
EarthDesk 7.3 - $24.99
EarthDesk replaces your static desktop picture with a rendered image of Earth showing correct sun, moon, and city illumination. With an Internet connection, EarthDesk displays near-real-time global... Read more
Monosnap 3.5.3 - Versatile screenshot ut...
Monosnap lets you capture screenshots, share files, and record video and .gifs! Features Capture Capture full screen, just part of the screen, or a selected window Make your crop area pixel... Read more
Monosnap 3.5.3 - Versatile screenshot ut...
Monosnap lets you capture screenshots, share files, and record video and .gifs! Features Capture Capture full screen, just part of the screen, or a selected window Make your crop area pixel... Read more
Spotify 1.0.93.244 - Stream music, creat...
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
Evernote 7.6 - Create searchable notes a...
Evernote allows you to easily capture information in any environment using whatever device or platform you find most convenient, and makes this information accessible and searchable at anytime, from... Read more
Final Cut Pro X 10.4.4 - Professional vi...
Final Cut Pro X is a professional video editing solution. Completely redesigned from the ground up, Final Cut Pro adds extraordinary speed, quality, and flexibility to every part of the post-... Read more
Compressor 4.4.2 - Adds power and flexib...
Compressor adds power and flexibility to Final Cut Pro X export. Customize output settings, work faster with distributed encoding, and tap into a comprehensive set of delivery features. Features... Read more
Motion 5.4.2 - Create and customize Fina...
Motion is designed for video editors, Motion 5 lets you customize Final Cut Pro titles, transitions, and effects. Or create your own dazzling animations in 2D or 3D space, with real-time feedback as... Read more
Thunderbird 60.3.1 - Email client from M...
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

Slots Panther Vegas offers a social gamb...
New era of Online gambling Want to try your luck in online social gambling? More and more people are into online casinos as a risk-free amazing way to experience the excitement of a big game. Online casinos and slots machines are gaining popularity... | Read more »
3 features we think you'll love in...
Well known classic RPG “Shin Megami Tensei” franchise originally created by Atlus, can now be played throughout iOS and Android. Created by Sega, “Shin Megami Tensei” has spawned a mobile-centric installment in the shape of “Shin Megami Tensei:... | Read more »
These are the top 3 games for iPhone and...
The end of the week has rolled around again, which means it's time for us to look forward to the games you're going to be playing over the next seven days. We've got the return of a mobile gaming legend next week, as well as a couple of other... | Read more »
Time for you to pick which of these top...
Oh look, Thursday is upon us once more. And we all know what that means! You guessed it, it's time for you to vote for which of these five games you think deserves to win our game of the week award. And have we got a selection for y'all this week... | Read more »
Dragalia Lost - High Midgardsormr Prep G...
It might not seem like there's a ton to do between events in Dragalia Lost, but there is one high level piece of content that can keep you occupied for a long time. Defeating High Midgardsormr is currently the game's most difficult non-event... | Read more »
Get your friends, these are the top 5 be...
You can't be a lone wolf all the time, especially if you want to show off your gaming prowess. And that's where this list comes in - we're running down what we think are the top 5 multiplayer games for iPhone. There might be some controversial... | Read more »
SpitKiss is the worthy winner of last we...
It's been a rough and tumble battle this week, with all of the games managing to get a few hits in where it counts, but after checking with the independent adjudicators at ringside, we can now reveal that gloriously gross smooching sim SpitKiss has... | Read more »
The best games for iPhone - The definiti...
Hi there, and welcome to our ever-increasing list of the very best games for iPhone. We're going to be updating this regularly with new content, so make sure you check back often, because you're not going to want to miss out on even one of the... | Read more »
Dragalia Lost Guide - What You Need To K...
Another raid has come and gone in Dragalia Lost, but that doesn’t mean there’s not still lots to do. In fact, the game’s next event, A Wish to the Winds, has already been announced and will be coming to the game this Wednesday. Although details are... | Read more »
The top 5 best games like Star Wars: Gal...
One of the things we like to do here at 148Apps is broaden your horizons. Maybe you're a fan of Star Wars: Galaxy of Heroes and you're looking for something that's going to scratch similar itches? Well that's where we come, and more specifically... | Read more »

Price Scanner via MacPrices.net

Save on a new MacBook with these early Black...
B&H Photo has posted early Black Friday sale prices on Apple MacBooks, including up to $300 off MSRP on 15″ MacBook Pros, $100 off new 13″ MacBook Airs, and more. Most of these deals expire... Read more
T-Mobile Black Friday deal: Free iPhone Xr wi...
T-Mobile is offering the 64GB iPhone Xr for free as part of their Black Friday 2018 sale. Two new lines are required, as well as an eligible trade-in (iPhone 6s models or newer). $20.84 is applied to... Read more
Save up to $157 on a 10.5″ iPad Pro with thes...
Apple’s newest authorized reseller, Jet, has 10.5″ iPad Pros on sale for up to $157 off MSRP as part of their Black Friday week sale. Shipping is free. Note that some sale prices may be restricted to... Read more
US Cellular offers free iPhone Xr for new lin...
US Cellular is offering the 64GB iPhone Xr for free as part of their Black Friday 2018 sale. A new line is required, but there is no trade in requirement. Any of the iPhone Xr colors qualify. The... Read more
Roundup of Black Friday Week 2018 Sales &...
At MacPrices.net, we give you the most accurate Mac and Apple prices on the web. Choose one of our price trackers at the top of the page to see all the current sale prices on Apple’s products from... Read more
Details of Amazon’s 2018 Black Friday week di...
Amazon’s recent agreement with Apple has allowed the online store to add most of Apple’s most popular products to its inventory, including new 2018 iPad Pros, Mac minis, Apple Watch Series 4, and... Read more
Get A Job With Apple, The No. 3 ‘World’s Best...
FEATURE: 11.16.18- If you are a fan of Apple, Inc. and an avid user of any one of its vast array of tech gadgets, why not take it a step further and work for the company behind those products you... Read more
Sprint offers $100 discounts on Apple Watch S...
Sprint is offering customers $100 discounts on the purchase of a cellular Apple Watch Series 4 or Apple Watch Series 3. Their discount reduces the cost of a Series 4 watch to $399 (40mm) or $429 (... Read more
New 2018 11″ 64GB & 256GB iPad Pros in st...
MacMall has the new 2018 11″ 64GB and 256GB iPad Pros in stock today for $50 off Apple’s prices. They’re currently the lowest prices available for these new iPad Pros. – 11″ 64GB Space Gray WiFi iPad... Read more
New Mac minis in stock and available today at...
Apple Authorized Reseller Adorama has the new 2018 Mac minis in stock today today sales tax free for residents outside of NY & NJ. Shipping is also free. – 3.6GHz Quad-Core mini: $799 – 3.0GHz 6... Read more

Jobs Board

Best Buy *Apple* Computing Master - Best Bu...
**658102BR** **Job Title:** Best Buy Apple Computing Master **Job Category:** Sales **Location Number:** 000395-Pensacola-Store **Job Description:** **What does a Read more
*Apple* Mobile Master - Best Buy (United Sta...
**658022BR** **Job Title:** Apple Mobile Master **Job Category:** Store Associates **Location Number:** 000793-Dothan-Store **Job Description:** **What does a Best Read more
Geek Squad *Apple* Master Consultation Agen...
**657784BR** **Job Title:** Geek Squad Apple Master Consultation Agent **Job Category:** Services/Installation/Repair **Location Number:** 000597-Erie-Store **Job Read more
Best Buy *Apple* Computing Master - Best Bu...
**655276BR** **Job Title:** Best Buy Apple Computing Master **Job Category:** Sales **Location Number:** 000387-Randall Road-Store **Job Description:** **What does a Read more
Omni-Channel Associate - *Apple* Blossom Ma...
Omni-Channel Associate - Apple Blossom Mall Location:Winchester, VA, United States- Apple Blossom Mall 1850 Apple Blossom Dr Job ID:1074107 Date:November 12, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.