TweetFollow Us on Twitter

Color Animation II
Volume Number:10
Issue Number:4
Column Tag:Getting Started

Related Info: Color Quickdraw Quickdraw

Finally - Color Animation!!!

Flying color bits around flicker-free

By Dave Mark, MacTech Magazine Regular Contributing Author

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

A while ago, we got into bitmap animation using BitMapper. BitMapper was based on QuickDraw’s BitMap data structure. Since BitMaps are always 1 pixel deep, BitMapper was limited to black and white animation. This month, we’ll colorize BitMapper, taking advantage of Color QuickDraw’s PixMap data structure.

PixMaps and GWorlds

The PixMap is much more complex than the BitMap. With BitMap animation, all you had to do was fill out the relatively simple BitMap structure, create a GrafPort, then connect the two via a call to SetPortBits(). Once that’s done, you are ready to copy the BitMap from port to port via a call to CopyBits(). If you need a little refresher, check back to the BitMapper column (September, ‘93).

On the other hand, PixMaps are complicated beasties. Pop open your copy of Inside Macintosh, Volume V (or THINK Reference, if you prefer) and look up the PixMap data structure. To create a PixMap by hand, you’d have to initialize all of those fields. Notice the pmTable field, listed as a handle to a color table (also known as a color lookup table, or CLUT). In addition to the PixMap fields, you’ve also got to create and initialize a ColorTable structure. Look it up.

This stuff is non-trivial. Fortunately, the Toolbox offers a high-level set of functions that make the creation of off-screen PixMaps relatively simple. These off-screen PixMaps are known as GWorlds. Off-screen simply means that you are creating something that is not drawn in a window on the screen. GWorlds are created in memory and typically drawn to a window via a call to CopyBits(), just as we did with BitMaps in BitMapper.


This month’s program is called PixMapper. PixMapper creates a window the size of the main screen and fills it in with a randomly generated sequence of colored squares. Next, PixMapper loads a PICT resource and uses a series of GWorlds to smoothly animate the PICT over the colored background.

As usual, we’ll create the program this month, then go over the program details in next month’s column.

Creating the PixMapper Resources

Start by creating a folder named PixMapper inside your Development folder. Fire up ResEdit and create a file named PixMapper.Π.rsrc inside your PixMapper folder.

Now create an ALRT resource (along with a corresponding DITL resource) for our error alert. The ALRT resource should have a Top: of 40, a Left: of 30, a Height: of 116, and a Width: of 292. Be sure to set the DITL ID: to 128.

Next, create a DITL with an id of 128. Use the specifications in Figure 2 to create the OK button and the specifications in Figure 3 to create the error alert’s static text item.

Figure 2. Specifications for the error alert’s OK button.

Figure 3. Specifications for the error alert’s static text item.

Next, create an MBAR resource with an id of 128. The MBAR should list four MENU ids: 128, 129, 130 and 131. Create four MENU resources according to the specifications in Figure 4. Be sure to include a separator line as the second item in the File menu. Also, be sure to mark the appropriate items in the Colors menu with a check mark (). Use the popup menu in the Mark: field to do this.

Figure 4. The four MENU resources.

Finally, go into the scrapbook (or your favorite graphics application) and use Copy and Paste to create a PICT resource in the resource file. Be sure that the PICT has a resource id of 128. When choosing your PICT resource, here’s a couple of things to keep in mind. First of all, smaller is probably better. A smaller picture takes up less memory and contains less pixels to copy around in memory. Something around the size of a color icon is probably a good size to start with.

Next, you might want to create a picture that is non-rectangular or that has a hole in it, then use the lasso tool to select only the pixels in the picture (and not the background). Though a rectangular picture will work just fine, a non-rectangular picture (like an X or an O shape) produces much more impressive results.

Creating the PixMapper Project

Save your changes and quit ResEdit. Launch THINK C and create a new project named PixMapper.Π in the PixMapper folder. Add MacTraps to the project. Next, create a new source code window, save it as PixMapper.c and add it to the project.

Type in the following source code:

/* 1 */
#include <QDOffscreen.h>
#include <Picker.h>
#include <GestaltEqu.h>

#define kMBARResID 128
#define kSleep   0L
#define kMoveToFront (WindowPtr)-1L
#define kEmptyString "\p"
#define kEmptyTitlekEmptyString
#define kVisible true
#define kNoGoAwayfalse
#define kNilRefCon (long)nil
#define kErrorAlertID128
#define kNilFilterProc    nil

#define kSquareSize16

#define kForegroundPICT   128
#define kIgnored nil
#define kUseMaxDepth 0
#define kNoFlags (GWorldFlags)0

#define mApple   128
#define iAbout   1

#define mFile    129
#define iRedraw  1
#define iQuit    3

#define mColors  131
#define iUseRGB  1
#define iUseHSV  2
#define iRed4
#define iGreen   5
#define iBlue    6
#define iHue4
#define iSaturation5
#define iBrightness6

/*  Globals  */

Boolean gDone;
Boolean gIsRGB = true, gRandomReds = true, 
 gRandomGreens = true, gRandomBlues = true;
Boolean gRandomHue = true, gRandomSaturation = true, gRandomBrightness 
= true;
WindowPtr gMainWindow;
short   gXBump = 1, gYBump = 1; // <--Try changing these numbers
GWorldPtr gPictWorld, gSaveWorld, gSaveMixWorld;
PixMapHandlegPixMapSave, gPixMapSaveMix, gPixMapPict;
Rect    gSavedFloaterRect, gPictWorldRect, gWorldRect;
short   gGlobalHue;

/*  Functions  */

void    ToolboxInit( void );
void    MenuBarInit( void );
Boolean HasGWorlds( void );
void    WindowInit( void );
void    PaintWindow( void );
void    RandomForeColor( void );
void    GWorldInit( void );
GWorldPtr MakeGWorld( Rect *boundsPtr );
void    EventLoop( void );
void    DoEvent( EventRecord *eventPtr );
void    HandleMouseDown( EventRecord *eventPtr );
void    HandleMenuChoice( long menuChoice );
void    HandleAppleChoice( short item );
void    HandleFileChoice( short item );
void    HandleColorsChoice( short item );
void    MainLoop( void );
void    DrawFirstFloater( void );
void    MoveFloater( void );
void    CalcNewFloaterPosition( void );
void    DoError( Str255 errorString );

/****************** main ***************************/
void  main( void )
 if ( ! HasGWorlds() )
 DoError( "\pDeep GWorlds not supported by this machine!" );


/****************** ToolboxInit *********************/

void  ToolboxInit( void )
 InitGraf( &thePort );
 InitDialogs( NULL );

/****************** MenuBarInit ***********************/

void  MenuBarInit( void )
 Handle menuBar;
 MenuHandle menu;
 menuBar = GetNewMBar( kMBARResID );
 SetMenuBar( menuBar );

 menu = GetMHandle( mApple );
 AddResMenu( menu, 'DRVR' );

/****************** HasGWorlds *****************/

Boolean HasGWorlds( void )
 long   feature;
 OSErr  err;
 err = Gestalt( gestaltQuickdrawFeatures, &feature );
 if ( err != noErr )
 DoError( "\pError calling Gestalt!" );
 if ( feature & 0x0004 )
 return true;
 return false;

/****************** WindowInit ***********************/

void  WindowInit( void )
 Rect   r;
 r = screenBits.bounds; += GetMBarHeight();
 gMainWindow = NewCWindow( nil, &r, kEmptyTitle,
 kVisible, plainDBox, kMoveToFront,
 kNoGoAway, kNilRefCon );

 SetPort( gMainWindow );

/****************** PaintWindow ***********************/

void  PaintWindow( void )
 Rect   r;
 short  row, col, numRows, numCols;
 SetPort( gMainWindow );
 r = gMainWindow->portRect;
 numCols = (r.right - r.left) / kSquareSize;
 if ( numCols != numCols/kSquareSize*kSquareSize )
 numRows = (r.bottom - / kSquareSize;
 if ( numRows != numRows/kSquareSize*kSquareSize )
 GetDateTime( (unsigned long *)(&randSeed) );
 gGlobalHue = Random();
 for ( row=0; row<numRows; row++ )
 for ( col=0; col<numCols; col++ )
 { = row * kSquareSize;
 r.bottom = + kSquareSize;
 r.left = col * kSquareSize;
 r.right = r.left + kSquareSize;
 PaintRect( &r );

 ForeColor( blackColor );
 BackColor( whiteColor );

/****************** RandomForeColor ***********************/

void  RandomForeColor( void )
 RGBColor color;
 HSVColor hsvColor;
 if ( gIsRGB )
 if ( gRandomReds ) = Random();
 else = 0;
 if ( gRandomGreens ) = Random();
 else = 0;
 if ( gRandomBlues ) = Random();
 else = 0;
 RGBForeColor( &color );
 if ( gRandomHue )
 hsvColor.hue = Random();
 hsvColor.hue = gGlobalHue;
 if ( gRandomSaturation )
 hsvColor.saturation = Random();
 hsvColor.saturation = 65535;
 if ( gRandomBrightness )
 hsvColor.value = Random();
 hsvColor.value = 65535;
 HSV2RGB( &hsvColor, &color );
 RGBForeColor( &color );
/****************** GWorldInit ***********************/

void  GWorldInit( void )
 pic = GetPicture( kForegroundPICT );

 if ( pic == nil )
 DoError( "\pError loading PICT..." );

// Call HNoPurge() if your PICT is purgeable
 gPictWorldRect = (**pic).picFrame;
 OffsetRect( &gPictWorldRect, -gPictWorldRect.left, );
 gWorldRect = gPictWorldRect;
 gWorldRect.bottom += 2;
 gWorldRect.right += 2;
 gPictWorld = MakeGWorld( &gPictWorldRect );
 gSaveWorld = MakeGWorld( &gWorldRect );
 gSaveMixWorld = MakeGWorld( &gWorldRect );
 gPixMapPict = GetGWorldPixMap( gPictWorld );
 gPixMapSave = GetGWorldPixMap( gSaveWorld );
 gPixMapSaveMix = GetGWorldPixMap( gSaveMixWorld );

// Lock pixels before you draw or read from PixMap.  Unlock when you 
are done.
//We're leaving the whole thing locked to avoid the hassle. In a real 
app, do it right.

 if ( ! LockPixels( gPixMapPict ) )
 DoError( "\pLockPixels failed..." );

 if ( ! LockPixels( gPixMapSave ) )
 DoError( "\pLockPixels failed..." );

 if ( ! LockPixels( gPixMapSaveMix ) )
 DoError( "\pLockPixels failed..." );
 SetGWorld( gPictWorld, kIgnored );
 DrawPicture( pic, &gPictWorldRect );

/*********************************** MakeGWorld */

GWorldPtr MakeGWorld( Rect *boundsPtr )
 QDErr  err;
 err = NewGWorld( &newGWorld, kUseMaxDepth,
 boundsPtr, kIgnored, kIgnored, noNewDevice );

// In the real world, call DisposeGWorld() when you are done with the 
 if ( err != noErr )
 DoError( "\pMy call to NewGWorld died!  Bye..." );
 return( newGWorld );

/************************************* EventLoop */

void  EventLoop( void )
 gDone = false;
 while ( gDone == false )
 if ( WaitNextEvent( everyEvent, &event, kSleep, NULL ) )
 DoEvent( &event );

/************************************* DoEvent */
void  DoEvent( EventRecord *eventPtr )
 char theChar;
 switch ( eventPtr->what )
 case mouseDown: 
 HandleMouseDown( eventPtr );
 case keyDown:
 case autoKey:
 theChar = eventPtr->message & charCodeMask;
 if ( (eventPtr->modifiers & cmdKey) != 0 ) 
 HandleMenuChoice( MenuKey( theChar ) );
 case updateEvt:
 BeginUpdate( (WindowPtr)(eventPtr->message) );
 EndUpdate( (WindowPtr)(eventPtr->message) );

/************************************* HandleMouseDown */

void  HandleMouseDown( EventRecord *eventPtr )
 short  thePart;
 long   menuChoice;
 thePart = FindWindow( eventPtr->where, &window );
 switch ( thePart )
 case inMenuBar:
 menuChoice = MenuSelect( eventPtr->where );
 HandleMenuChoice( menuChoice );
 case inSysWindow : 
 SystemClick( eventPtr, window );

/************************************* HandleMenuChoice */

void  HandleMenuChoice( long menuChoice )
 short  menu;
 short  item;
 if ( menuChoice != 0 )
 menu = HiWord( menuChoice );
 item = LoWord( menuChoice );
 switch ( menu )
 case mApple:
 HandleAppleChoice( item );
 case mFile:
 HandleFileChoice( item );
 case mColors:
 HandleColorsChoice( item );
 HiliteMenu( 0 );

/************************************* HandleAppleChoice */

void  HandleAppleChoice( short item )
 MenuHandle appleMenu;
 Str255 accName;
 short  accNumber;
 switch ( item )
 case iAbout:
 SysBeep( 20 );
 appleMenu = GetMHandle( mApple );
 GetItem( appleMenu, item, accName );
 accNumber = OpenDeskAcc( accName );

/************************************* HandleFileChoice */

void  HandleFileChoice( short item )
 switch ( item )
 case iRedraw:
 case iQuit:
 gDone = true;

/************************************* HandleColorsChoice */

void  HandleColorsChoice( short item )
 MenuHandle menu;
 menu = GetMenu( mColors );
 if ( item == iUseRGB )
 gIsRGB = true;
 SetItem( menu, iRed, "\pRandom Reds" );
 SetItem( menu, iGreen, "\pRandom Greens" );
 SetItem( menu, iBlue, "\pRandom Blues" );
 CheckItem( menu, iUseRGB, true );
 CheckItem( menu, iUseHSV, false );
 CheckItem( menu, iRed, gRandomReds );
 CheckItem( menu, iGreen, gRandomGreens );
 CheckItem( menu, iBlue, gRandomBlues );
 else if ( item == iUseHSV )
 gIsRGB = false;
 SetItem( menu, iHue, "\pRandom Hue" );
 SetItem( menu, iSaturation, "\pRandom Saturation" );
 SetItem( menu, iBrightness, "\pRandom Brightness" );
 CheckItem( menu, iUseRGB, false );
 CheckItem( menu, iUseHSV, true );
 CheckItem( menu, iHue, gRandomHue );
 CheckItem( menu, iSaturation, gRandomSaturation );
 CheckItem( menu, iBrightness, gRandomBrightness );
 else if ( gIsRGB )
 switch ( item )
 case iRed:
 gRandomReds = !gRandomReds;
 CheckItem( menu, iRed, gRandomReds );
 case iGreen:
 gRandomGreens = ! gRandomGreens;
 CheckItem( menu, iGreen, gRandomGreens );
 case iBlue:
 gRandomBlues = ! gRandomBlues;
 CheckItem( menu, iBlue, gRandomBlues );
 switch ( item )
 case iHue:
 gRandomHue = !gRandomHue;
 CheckItem( menu, iHue, gRandomHue );
 case iSaturation:
 gRandomSaturation = ! gRandomSaturation;
 CheckItem( menu, iSaturation, gRandomSaturation );
 case iBrightness:
 gRandomBrightness = ! gRandomBrightness;
 CheckItem( menu, iBrightness, gRandomBrightness );

/****************** DrawFirstFloater *********************/

void  DrawFirstFloater( void )
 CopyBits( &(gMainWindow->portBits), 
 (BitMap *)(*gPixMapSave),
 &gWorldRect, &gWorldRect, srcCopy, nil );
 gSavedFloaterRect = gPictWorldRect;
 OffsetRect( &gSavedFloaterRect, 1, 1 );

 CopyBits( (BitMap *)(*gPixMapPict), 
 &gPictWorldRect, &gSavedFloaterRect, transparent, nil );

/****************** MoveFloater *********************/

void  MoveFloater( void )
 Rect   r;
 RgnHandlenewRgn, savedRgn, oldClip;

 CopyBits( (BitMap *)(*gPixMapSave), 
 (BitMap *)(*gPixMapSaveMix),
 &gWorldRect, &gWorldRect, srcCopy, nil );
 r = gPictWorldRect;
 OffsetRect( &r, gXBump + 1, gYBump + 1 );
 CopyBits( (BitMap *)(*gPixMapPict), 
 (BitMap *)(*gPixMapSaveMix),
 &gPictWorldRect, &r, transparent, nil );
 r = gSavedFloaterRect;
 InsetRect( &r, -1, -1 );
 CopyBits( (BitMap *)(*gPixMapSaveMix), 
 &gWorldRect, &r, srcCopy, nil );
 OffsetRect( &gSavedFloaterRect, gXBump, gYBump );
 r = gSavedFloaterRect;
 InsetRect( &r, -1, -1 );
 CopyBits( &(gMainWindow->portBits), 
 (BitMap *)(*gPixMapSaveMix),
 &r, &gWorldRect, srcCopy, nil );
 r = gWorldRect;
 OffsetRect( &r, -gXBump, -gYBump );
 CopyBits( (BitMap *)(*gPixMapSave), 
 (BitMap *)(*gPixMapSaveMix),
 &gWorldRect, &r, srcCopy, nil );
 CopyBits( (BitMap *)(*gPixMapSaveMix), 
 (BitMap *)(*gPixMapSave),
 &gWorldRect, &gWorldRect, srcCopy, nil );

/*********************************** CalcNewFloaterPosition */

void  CalcNewFloaterPosition( void )
 Rect r;
 r = gSavedFloaterRect;
 OffsetRect( &r, gXBump, gYBump );
 if ( (r.left < gMainWindow->portRect.left) ||
  ( r.right > gMainWindow->portRect.right ) )
 gXBump *= -1;
 if ( ( < gMainWindow-> ||
  ( r.bottom > gMainWindow->portRect.bottom ) )
 gYBump *= -1;

/***************** DoError ********************/

void  DoError( Str255 errorString )
 ParamText( errorString, kEmptyString, kEmptyString,
 kEmptyString );
 StopAlert( kErrorAlertID, kNilFilterProc );

Running PixMapper

As soon as you run PixMapper, the menu bar, featuring the •, File, Edit, and Colors menus, will appear. Next, a window will appear, filling the entire main screen. PixMapper will fill the window with colored squares. Finally, PixMapper will animate the PICT, starting in the upper left corner moving towards the lower right corner. Every time the PICT hits the edge of the window, the PICT will bounce off and continue in the opposite direction.

Figure 5. PixMapper in action.

The speed of your PICT will depend on the speed of your machine and the size of the PICT. The important thing to notice is that the PICT animates smoothly with absolutely no flicker. If there is any hesitation, it is most likely due to the system taking time to do some housekeeping chore.

Try selecting Redraw from the File menu. PixMapper will redraw the window and start the animation over again.

Next, go to the Colors menu and play with all the different menu settings. PixMapper lets you play with both the RGB and HSV color models. RGB lets you set a colors red, green, and blue values. If you uncheck Random Reds for example, the screen will be redrawn with a red value of 0 (all greens and blues). If Random Reds is checked, the red component of the color is a random value from 0 to 65535.

If you select HSV Colors, you’ll be able to work with hue, saturation, and brightness rather than red, green, and blue. Unlike the RGB menu items, if you uncheck Random Hues, a color’s hues component is set to 65535 instead of 0. Play around with these settings.

Till Next Month

Next month, we’ll walk through the PixMapper source code. In the meantime, pop open Inside Macintosh and read about GWorlds and PixMaps. See you next month...


Community Search:
MacTech Search:

Software Updates via MacUpdate

Latest Forum Discussions

See All

Pack a magnifying glass and practice you...
Somehow it has already been a year since Torchlight: Infinite launched, and XD Games is celebrating by blending in what sounds like a truly fantastic new update. Fans of Cthulhu rejoice, as Whispering Mist brings some horror elements, and tests... | Read more »
Summon your guild and prepare for war in...
Netmarble is making some pretty big moves with their latest update for Seven Knights Idle Adventure, with a bunch of interesting additions. Two new heroes enter the battle, there are events and bosses abound, and perhaps most interesting, a huge... | Read more »
Make the passage of time your plaything...
While some of us are still waiting for a chance to get our hands on Ash Prime - yes, don’t remind me I could currently buy him this month I’m barely hanging on - Digital Extremes has announced its next anticipated Prime Form for Warframe. Starting... | Read more »
If you can find it and fit through the d...
The holy trinity of amazing company names have come together, to release their equally amazing and adorable mobile game, Hamster Inn. Published by HyperBeard Games, and co-developed by Mum Not Proud and Little Sasquatch Studios, it's time to... | Read more »
Amikin Survival opens for pre-orders on...
Join me on the wonderful trip down the inspiration rabbit hole; much as Palworld seemingly “borrowed” many aspects from the hit Pokemon franchise, it is time for the heavily armed animal survival to also spawn some illegitimate children as Helio... | Read more »
PUBG Mobile teams up with global phenome...
Since launching in 2019, SpyxFamily has exploded to damn near catastrophic popularity, so it was only a matter of time before a mobile game snapped up a collaboration. Enter PUBG Mobile. Until May 12th, players will be able to collect a host of... | Read more »
Embark into the frozen tundra of certain...
Chucklefish, developers of hit action-adventure sandbox game Starbound and owner of one of the cutest logos in gaming, has released their roguelike deck-builder Wildfrost. Created alongside developers Gaziter and Deadpan Games, Wildfrost will... | Read more »
MoreFun Studios has announced Season 4,...
Tension has escalated in the ever-volatile world of Arena Breakout, as your old pal Randall Fisher and bosses Fred and Perrero continue to lob insults and explosives at each other, bringing us to a new phase of warfare. Season 4, Into The Fog of... | Read more »
Top Mobile Game Discounts
Every day, we pick out a curated list of the best mobile discounts on the App Store and post them here. This list won't be comprehensive, but it every game on it is recommended. Feel free to check out the coverage we did on them in the links below... | Read more »
Marvel Future Fight celebrates nine year...
Announced alongside an advertising image I can only assume was aimed squarely at myself with the prominent Deadpool and Odin featured on it, Netmarble has revealed their celebrations for the 9th anniversary of Marvel Future Fight. The Countdown... | Read more »

Price Scanner via

Every model of Apple’s 13-inch M3 MacBook Air...
Best Buy has Apple 13″ MacBook Airs with M3 CPUs in stock and on sale today for $100 off MSRP. Prices start at $999. Their prices are the lowest currently available for new 13″ M3 MacBook Airs among... Read more
Sunday Sale: Apple iPad Magic Keyboards for 1...
Walmart has Apple Magic Keyboards for 12.9″ iPad Pros, in Black, on sale for $150 off MSRP on their online store. Sale price for online orders only, in-store price may vary. Order online and choose... Read more
Apple Watch Ultra 2 now available at Apple fo...
Apple has, for the first time, begun offering Certified Refurbished Apple Watch Ultra 2 models in their online store for $679, or $120 off MSRP. Each Watch includes Apple’s standard one-year warranty... Read more
AT&T has the iPhone 14 on sale for only $...
AT&T has the 128GB Apple iPhone 14 available for only $5.99 per month for new and existing customers when you activate unlimited service and use AT&T’s 36 month installment plan. The fine... Read more
Amazon is offering a $100 discount on every M...
Amazon is offering a $100 instant discount on each configuration of Apple’s new 13″ M3 MacBook Air, in Midnight, this weekend. These are the lowest prices currently available for new 13″ M3 MacBook... Read more
You can save $300-$480 on a 14-inch M3 Pro/Ma...
Apple has 14″ M3 Pro and M3 Max MacBook Pros in stock today and available, Certified Refurbished, starting at $1699 and ranging up to $480 off MSRP. Each model features a new outer case, shipping is... Read more
24-inch M1 iMacs available at Apple starting...
Apple has clearance M1 iMacs available in their Certified Refurbished store starting at $1049 and ranging up to $300 off original MSRP. Each iMac is in like-new condition and comes with Apple’s... Read more
Walmart continues to offer $699 13-inch M1 Ma...
Walmart continues to offer new Apple 13″ M1 MacBook Airs (8GB RAM, 256GB SSD) online for $699, $300 off original MSRP, in Space Gray, Silver, and Gold colors. These are new MacBook for sale by... Read more
B&H has 13-inch M2 MacBook Airs with 16GB...
B&H Photo has 13″ MacBook Airs with M2 CPUs, 16GB of memory, and 256GB of storage in stock and on sale for $1099, $100 off Apple’s MSRP for this configuration. Free 1-2 day delivery is available... Read more
14-inch M3 MacBook Pro with 16GB of RAM avail...
Apple has the 14″ M3 MacBook Pro with 16GB of RAM and 1TB of storage, Certified Refurbished, available for $300 off MSRP. Each MacBook Pro features a new outer case, shipping is free, and an Apple 1-... Read more

Jobs Board

*Apple* Systems Administrator - JAMF - Activ...
…**Public Trust/Other Required:** None **Job Family:** Systems Administration **Skills:** Apple Platforms,Computer Servers,Jamf Pro **Experience:** 3 + years of Read more
IT Systems Engineer ( *Apple* Platforms) - S...
IT Systems Engineer ( Apple Platforms) at SpaceX Hawthorne, CA SpaceX was founded under the belief that a future where humanity is out exploring the stars is Read more
Nurse Anesthetist - *Apple* Hill Surgery Ce...
Nurse Anesthetist - Apple Hill Surgery Center Location: WellSpan Medical Group, York, PA Schedule: Full Time Sign-On Bonus Eligible Remote/Hybrid Regular Apply Now Read more
Housekeeper, *Apple* Valley Village - Cassi...
Apple Valley Village Health Care Center, a senior care campus, is hiring a Part-Time Housekeeper to join our team! We will train you for this position! In this role, Read more
Sublease Associate Optometrist- *Apple* Val...
Sublease Associate Optometrist- Apple Valley, CA- Target Optical Date: Apr 20, 2024 Brand: Target Optical Location: Apple Valley, CA, US, 92307 **Requisition Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.