TweetFollow Us on Twitter

Kolorize
Volume Number:7
Issue Number:6
Column Tag:C Workshop

Related Info: Color Quickdraw

Kolorize Your B&W Application

By Kirk Chase, Anaheim, CA

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

Introduction

The introduction of the Mac II brought color to release the user from the shackles of boring black and white displays. Now the user could use color to hilight, to draw, and to entertain. His spreadsheets could now show that he was in the “red”; his text could be hilighted in yellow; and his desktop could be blue as the sky.

What color brought to the developer was headaches. Palettes, color tables, and PixMaps were new structures to be learned and manipulated. Color images brought a tremendous increase in file and application sizes. Toolbox calls separated between color and non-color interfaces and had to be dealt with. Calibration of color between monitors and other output devices was, and still is, a great issue. And add to this the problem/feature of allowing the user to set the number of colors of the screen on the fly, and developers have their hands full. To deal with this problem, some developers have published a color and non-color version of their product rather than try to deal with the issues at the same time.

Dealing with color for most applications is not a great problem. Most applications do not need “animating palettes” or “32-bit Color QuickDraw”. Most applications need just a smidgen of color to liven up their displays (and sales) and to remove the stain of being “non-color” in the Mac world. Most applications are not paint or drawing programs. In fact, some applications require no user-interface at all and run “quietly” in the background.

Still, it would be nice to have a little color. For those who remain in the black & white world of programming, you may be asking yourself, “Is there something between the mouse of B&W coding and the elephant of color coding?” There is. You don’t have to eat the whole elephant at once. There is a middle ground to be found. It adds minimal code to your application, but it is not without its limitations.

The Macintosh Has ALWAYS Had Color

The word “classic” has been used to name the newest low-cost, low-end Macintosh computer line. The original “classic” QuickDraw has always had color ability. Within the Grafport are two fields, fgColor and bkColor, that controls the foreground color and background color through the toolbox calls ForeColor() and BackColor(), respectively. Also defined are eight colors (black, white, red, green, blue, cyan, magenta, and yellow).

The foreground color is initially set to black and the background color is initially set to white. By setting these colors before doing your drawing, you will get color drawing on all Macintoshes; the pen’s characteristics including pattern and mode work as they always do.

Drawback or Feature?

One thing to remember while drawing using the classic QuickDraw color model is the different monitor modes you will be in. The first instance is the black and white monitor; in this instance, all colors, except white, are drawn in black. This means that you should have white as either the background or foreground color; otherwise on B&W monitors you will have black on black drawing (great for displaying top secret information, but terrible otherwise).

A similar problem exists with color/monochrome monitors set to shallow color depths. For example, on my color monitor set at four colors (less than the eight colors of QuickDraw), green and blue appeared black; magenta and red were the same color; yellow appeared white, and cyan remained the same. In grayscale, the same problem existed with minor color variations due to the interpretation of color luminosity.

On top of this, there are a number of applications that change the color look-up table that describes the various RGB percentages which in turn change the color’s intensity. Also, different monitors have different values for colors. What this all means is that you can not depend on being able to distinguish, say, black from blue and yellow from white all the time.

I suppose you could check for the depth of the screen and values of the current colors. But this would mean going into all the things that you didn’t want to go into in the first place; you might as well use Color QuickDraw and its associated Toolbox managers. A better way to go is to do your drawing with black and white monitors in mind. This means keeping white as either the foreground or background colors when using the other colors. Then, you should not depend on any color other than black and white being present; you should give consideration to the fact that black and white might be the only colors seen.

For example, let’s consider we are drawing a pair of dice for a game. We make the die green, the dots blue, the die’s outline black, and the dots’ outlines red. Regardless of whether you think this color combination is great, in black and white, it looks like a black blob. So you change the dots’ outlines to white so you can distinguish between the die and the dots. You may still have a problem because there may not be enough white outline to quickly distinguish the dots on a B&W monitor. You need to leave enough “white” space between colors to look okay in B&W. Another problem is the “colorful” screen that is chock full of colors. Neat, but in B&W it looks like a black hole.

These are the basics to classic Quickdraw. You only have eight colors. Make white either the foreground or background color. Plan for black and white displays.

Kolorize

Now that you’ve got the basics down of ol’ classic QuickDraw. There are a few things that you can do to step beyond this. I will talk about three things. The first is getting more colors than the standard eight. The second involves colorizing areas of the screen such as text. And the third involves colorizing controls. All these routines are found in the source listing Kolorize.c and .h.

More Colors

When you are on a black and white Mac, the only colors you get are black and white. Yet the desktop is gray and the scroll bars have a light-gray page region. Okay, they are not true colors but dithering patterns to make them appear to be a certain color (mainly a shade of gray).

Well, you can do the same thing with colors. The routine, PaintMixedRect(), takes a rectangle and a palette of four colors and paints a multi-color rectangle on the screen. If done correctly you can get gray using black and white, light green using green and yellow, turquoise using green and blue, brown using green and red, and many other colors using the standard colors.

PaintMixedRect() creates this illusion of many colors by using an array of four dithering patterns, oqdMask4[]. Each bit in each pattern is unique within the four patterns. If you were to stack the patterns on top of each other, combining them, you would get a solid, black pattern, and no bit would be used twice.

To paint a pattern, you pass an array of four colors and the rectangle to PaintMixedRect(). This routine sets the pen transfer mode to patOr. Then PaintMixedRect() loops through the four colors painting the rectangle using the i-th color and the i-th mask pattern. The first pass paints one quarter of the rectangle in the first color and then loops back to do the rest in the other colors and patterns. The reason the pen mode is set to patOr is so we don’t erase any of the pixels we previously drew.

The dithering pattern used has been created to put up a gray pattern if you pass black/white/black/white. If you pass black/white combinations in other orders you can get different patterns such as vertical stripes (black/black/white/white) or horizontal stripes (black/white/white/black). My pattern was hard coded, but you could create a different set of dithering patterns.

Colorizing a Rectangle

The routine Kolorize() turns all the black pixels in a rectangle to a single color. It does this by setting the forecolor to the color you pass in and then performing a CopyMask() call using the same rectangle as the mask for CopyMask(). What this does is re-paint that rectangle in the color you specify. By using the same rectangle as the mask, you assure that only the original, black pixels are redrawn and the original, white pixels are left alone.

Another routine, KolorizeMix(), takes Kolorize() and PaintMixRect() and combines them. It uses the dithering pattern to draw only portions of the black pixels in one of the colors you pass and then again for other colors and dithering patterns.

KolorizeMix() is a little trickier than Kolorize() and PaintMixedRect(). KolorizeMix() needs a couple of offscreen ports to do its job. Since the dithering, mask patterns may clear some bits, we need a copy of the original area, copyPort, we are working on and a work area, offPort. These port and bitmap manipulation routines are fairly standard and you can get the source for them almost anywhere.

KolorizeMix() first makes a copy of the area we wish to colorize. Then it enters a loop. First, it copies the copy onto the offscreen area. Second, with the i-th dithering mask and proper pen mode, it clears out all bits that are not in the i-th color. Finally, it sets the foreground color to the i-th color and does a CopyBits() call to transfer the bits to the screen; CopyBits() automatically does the colorizing for you!

Color in Control

With Kolorize(), you should be able to colorize any rectangular area--including controls. KolorizeCDEF() does just this for the standard button, checkbox, and radio control. Simply pass in the control handle, the control type, and the button and indicator color.

KolorizeCDEF() will first colorize the whole control in the button color using the control’s rectangle. Then depending on the type of control it is and whether the button and indicator colors are different, this routine will then kolorize the inside “x” of the checkbox or the “•” of the radio button.

Controls are different than normal areas on the screen. They are active, and respond to mouse clicks by hilighting themselves. The standard controls know nothing of your colorizing attempts. They simply draw and hilight the controls in black and white on a black and white screen. Therefore you need to re-colorize them in your screen update routine and after the control receives a mouse click. When the control is tracking the mouse (on a mouse click in a control), the control automatically is drawn/hilighted in black until the mouse button is released and you re-colorize. I do not find this “reverting to black” so terrible; it gives additional information on color screens that a mouse down was detected in a control and tracking is being done.

Conclusion

Kolorize.c and the techniques given in this article will allow anyone to add color to there interface. If you simply need a few colors, classic QuickDraw provides eight for you, and this article explains how to “squeeze” out a few more without too much extra work. Possible future enhancements would be differing dithering masks-perhaps eight instead of four, colorizing scroll bars or other control types, extending color tracking to controls, drawing TextEdit’s hilight in color, and there are a number of other directions you could take.

Remember, color using classic QuickDraw is very rudimentary. There are severe limitations such as the “any color on white or white on any color” problem and the “white space” problem. In no way am I suggesting you never use Color QuickDraw. Color QuickDraw provides a much richer environment for working with color. But, if your application is not “color intensive”, you can add that little bit of color without too many hassles with good, ol’ QuickDraw.

Listing:  OQDKolorize.h

/************************************/
/* OQDKolorize.h
 Prototypes for Offscreen.c */
/************************************/

extern Ptr NewBitMap(BitMap *bm, Rect *r);
extern void DisposBitMap(BitMap *bm);
extern GrafPtr NewOffScreen(Rect *theBounds);
extern void DisposOffScreen(GrafPtr offPort);
extern void KolorizeMix(Rect *theRect, int *pallete);
extern void Kolorize(Rect *theRect, int theColor);
extern void KolorizeCDEF(ControlHandle theControl, int type,
 int buttonColor, int indicatorColor);
extern void PaintMixedRect(Rect *theRect, int *pallete);
Listing:  OQDKolorize.c

/**************************
OQDKolorize.c
created by Kirk Chase 3/29/91
***************************/
#include "OQDKolorize.h"

#define NIL 0L

#pragma mark Information
/************************************/
/* routines:
 • Ptr NewBitMap(BitMap *bm, Rect *r);
 • void DisposBitMap(BitMap *bm);
 • GrafPtr NewOffScreen(Rect *theBounds);
 • void DisposOffScreen(GrafPtr offPort);
 • void KolorizeMix(Rect *theRect,int *pallete);
 • void Kolorize(Rect *theRect, int theColor);
 • void KolorizeCDEF(ControlHandle theControl, int type,
 int buttonColor, int indicatorColor);
 • void void PaintMixedRect(Rect *theRect, int *pallete);
 */
/************************************/

/************************************/
/* OQDKolorize Variables */
Pattern oqdMask4[4] = 
 { 0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00,
 0x00, 0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00, 0xAA,
 0x00, 0x55, 0x00, 0x55, 0x00, 0x55, 0x00, 0x55,
 0x55, 0x00, 0x55, 0x00, 0x55, 0x00, 0x55, 0x00 };
/************************************/

/************************************/
/* Routines */
/************************************/

Ptr NewBitMap(bm, r)
BitMap *bm;
Rect *r;
/************************************/
/* Ptr NewBitMap()
 creates a bitmap */
/************************************/
{ /* NewBitMap() */
bm->rowBytes = ((r->right - r->left + 15) / 16) * 2;
bm->bounds = *r;
 /*  see note below */
bm->baseAddr = NewPtr(bm->rowBytes * (long) (r->right - r->left));
if (MemError() != noErr) return (0L);
else return (bm->baseAddr);
} /* NewBitMap() */

void DisposBitMap(bm)
BitMap *bm;
/************************************/
/* void DisposBitMap()
 disposes of a bitmap */
/************************************/
{ /* DisposBitMap() */
DisposPtr(bm->baseAddr);
SetRect(&bm->bounds,0,0,0,0);
bm->rowBytes=0;
bm->baseAddr=0L;
} /* DisposBitMap() */

GrafPtr NewOffScreen(theBounds)
Rect *theBounds;
/************************************/
/* GrafPtr NewOffScreen()
 creates an offscreen grafport */
/************************************/
{ /* NewOffScreen() */
GrafPtr oldPort, offPort;

/* allocate port memory */
offPort = (GrafPtr) NewPtr(sizeof(GrafPort));
if (MemError() != noErr)
 return (0L);

/* open port and set port variables */
GetPort(&oldPort);
OpenPort(offPort);
offPort->portRect = *theBounds;

/* create bitmap to store port's bits */
if (NewBitMap(&(offPort->portBits), theBounds) == (0L)) {
 ClosePort(offPort);
 SetPort(oldPort);
 DisposPtr((Ptr) offPort);
 return(0L);
 }

/* create necessary regions */
RectRgn(offPort->clipRgn, theBounds);
RectRgn(offPort->visRgn, theBounds);

/* clear bits to white */
EraseRect(theBounds);

/* reset back to original port */
SetPort(oldPort);

/* return offscreen port */
return(offPort);
} /* NewOffScreen() */

void DisposOffScreen(offPort)
GrafPtr offPort;
/************************************/
/* void DisposOffScreen()
 destroys an offscreen grafport */
/************************************/
{ /* DisposOffScreen() */
ClosePort(offPort);
DisposBitMap(&(offPort->portBits));
DisposPtr((Ptr) offPort);
} /* DisposOffScreen() */

void KolorizeMix(theRect, pallete)
Rect *theRect;
int *pallete;
/************************************/
/* void KolorizeMix(theRect, pallete)
 given a rectangle and pallete of  
 4 OQD colors, colorize rectangle */
/************************************/
{
GrafPtr offScreen, oldPort, copyPort;
int i;
PenState oldPen;

/* save old values */
GetPenState(&oldPen);
GetPort(&oldPort);

/* create offscreen ports for kolorizing */
offScreen = NewOffScreen(theRect);
if (offScreen == NIL) return;
copyPort = NewOffScreen(theRect);
if (copyPort == NIL) return;

SetPort(offScreen); /* do work on offscreen */

/* Copy only significant bits (black pixels)
 by using the same bits we wish to copy
 as the mask to the copyPort to work with later */
CopyMask(&(oldPort->portBits), &(oldPort->portBits), &(copyPort->portBits),
 theRect, theRect, theRect);

EraseRect(theRect);
/* Set Proper Pen Mode to clear bits */
for (i=0; i<4; i++) { /* loop through colors/masks */
 CopyMask(&(copyPort->portBits), &(copyPort->portBits), &(offScreen->portBits),
 theRect, theRect, theRect); /* place original copy in off screen */
 
 PenMode(notPatBic);  /* paint with ith pattern */
 PenPat(&(oqdMask4[i]));
 PaintRect(theRect);
 
 PenMode(patCopy);
 ForeColor(pallete[i]); /* kolorize with ith color */
 CopyBits (&(offScreen->portBits),&(oldPort->portBits), theRect,theRect, 
srcOr, 0L);
 ForeColor(blackColor);
 }

/* reset old values */  
SetPort(oldPort);
ForeColor(blackColor);
SetPenState(&oldPen);

/* dispose of memory */
DisposOffScreen(offScreen);
DisposOffScreen(copyPort);
} /* KolorizeMix() */

void Kolorize(theRect, theColor)
Rect *theRect;
int theColor;
/************************************/
/* void Kolorize()
 given a rectangle and an OQDcolor  
 colorize a rectangle */
/************************************/
{
/* set forecolor to color selected */
ForeColor(theColor);

/* kolorize */
CopyMask(&(thePort->portBits), &(thePort->portBits), &(thePort->portBits), 
theRect, theRect, theRect);
ForeColor(blackColor); /* reset */
} /* Kolorize() */

void KolorizeCDEF(theControl, type, buttonColor, indicatorColor)
ControlHandle theControl;
int type;
int buttonColor, indicatorColor;
/************************************/
/* void KolorizeCDEF()
 given a standard control (button,
 radio, or checkbox determined by
 proc type in type parameter) this
 will colorize the button and the
 indicator */
/************************************/
{
Rect tempRect;
PenState oldPen;

/* get old values and set up normal pen */
GetPenState(&oldPen);
PenNormal();

/* colorize whole control with button color */
ForeColor(buttonColor);
CopyMask(&(thePort->portBits), &(thePort->portBits), &(thePort->portBits), 

 &(**theControl).contrlRect,
 &(**theControl).contrlRect,
 &(**theControl).contrlRect);
ForeColor(blackColor);

/* if indicator color is the same
 as the button color, or it's a button
 or it's not set, then we're done */
if ((buttonColor == indicatorColor) 
 || (!type)
 || (!GetCtlValue(theControl))) { /* simple colorizing */
 SetPenState(&oldPen);
 return;
 }

/* not done, need to draw indicator */
/* get initial indicator rect */
tempRect = (**theControl).contrlRect;
tempRect.bottom = tempRect.bottom - ((tempRect.bottom - tempRect.top 
- 12) / 2);
tempRect.top = tempRect.bottom - 12;
tempRect.left +=2;
tempRect.right = tempRect.left + 12;

ForeColor(indicatorColor);
/* colorize checkbox or radio button */
if (type == checkBoxProc) {
 InsetRect(&tempRect, 1, 1);
 MoveTo(tempRect.left, tempRect.top);
 LineTo(tempRect.right, tempRect.bottom);
 MoveTo(tempRect.left , tempRect.bottom);
 LineTo(tempRect.right, tempRect.top - 1);
 }
else if (type == radioButProc) {
 InsetRect(&tempRect, 3, 3);
 PaintOval(&tempRect);
 }

/* reset old values */
SetPenState(&oldPen);
ForeColor(blackColor);
} /* KolorizeCDEF() */

void PaintMixedRect(theRect, pallete)
Rect *theRect;
int *pallete;
/************************************/
/* void PaintMixedRect()
 given a rectangle and a pallete of
 4 OQD colors, it paints a mixed
 rectangle to give the illusion
 of another color */
/************************************/
{
int i;
PenState oldPen;

/* get old states and set up pen */
GetPenState(&oldPen);
PenNormal();
PenMode(patOr);

/* paint ith pattern with ith color */
for (i=0; i<4; i++) {
 PenPat(&(oqdMask4[i]));
 ForeColor(pallete[i]);
 PaintRect(theRect);
 }

/* reset old values */
ForeColor(blackColor);
SetPenState(&oldPen);
} /* PaintMixedRect() */
Listing:  HandleTheMenus

/****************************************
File: HandleTheMenus
Function: Create and Handle any menus.
****************************************/
#define TRUE 1
#define FALSE 0

#define AppleMenuID 1001
#define FileMenuID 1002
 #define QuitItem 1
#define MixedMenuID 1003
 #define ThreeOneItem 1
 #define TwoTwoItem 2
 #define TwoOneOne 3
 #define OneOneOneOneItem 4
 #define MixColorItem 6

MenuHandle AppleMenu, FileMenu, MixedMenu;
int checkmark = 1;

/* External routines that are called */
extern int checkmark;
extern WindowPtr MyWindow;
extern void   D_Mixed_Colors();

void InitMyMenus(void);
void HandleMenu(char *doneFlag, short   theMenu, short   theItem);

void InitMyMenus()
/* InitMyMenus() gets the menu resources
 and creates the menu bar */
{
ClearMenuBar();
 
/* Apple menu */
AppleMenu = GetMenu(AppleMenuID);
InsertMenu (AppleMenu,0);
AddResMenu(AppleMenu,'DRVR');
 
/* File menu */
FileMenu = GetMenu(FileMenuID);
InsertMenu (FileMenu,0);
 
/* Mixed menu */
MixedMenu = GetMenu(MixedMenuID);
InsertMenu (MixedMenu,0);

DrawMenuBar();
}

void HandleMenu(doneFlag,theMenu,theItem)
char     *doneFlag; 
short   theMenu,theItem;
{
GrafPtr SavePort;
Str255 DAName;
short DNA;

switch (theMenu) {
 case AppleMenuID:
 GetPort(&SavePort);
 GetItem(AppleMenu, theItem, &DAName);
 DNA = OpenDeskAcc(DAName);
 SetPort(SavePort);
 break;

 case FileMenuID:
 if (theItem == QuitItem)
 *doneFlag = TRUE;
 break;
 
 case MixedMenuID:
 switch (theItem) {
 case ThreeOneItem:
 case TwoTwoItem:
 case TwoOneOne:
 case OneOneOneOneItem:
 CheckItem(MixedMenu, checkmark, 0);
 checkmark = theItem;
 CheckItem(MixedMenu, checkmark, 1);
 SetPort(MyWindow);
 InvalRect(&(MyWindow->portRect));
 break;
 case MixColorItem:
 D_Mixed_Colors();
 break;
 }
 break;
 }
 
HiliteMenu(0);
}
Listing: Mixed_Colors.c

/* *******************************
File: Mixed_Colors.c
 Handles color selection dialog
******************************* */

static pascal char MyFilter(DialogPtr theDialog
 ,EventRecord *theEvent,short *itemHit);

#define TRUE   1
#define FALSE  0
#define NIL 0L

#define  I_OK   1
#define  I_Cancel   2
#define  Item1stColor   3
#define  Item2ndColor   4
#define  Item3rdColor   5
#define  Item4thColor   6

extern int colorSelection[4];
extern WindowPtr MyWindow;

static char   ExitDialog; 

int oqdColors[9] = {0, 33, 30, 205, 341, 409, 273, 137, 69};

static int OQDIndex2Color(theIndex)
int theIndex;
/* convert menu selection to color */
{
return(oqdColors[theIndex]);
}

static int OQDColor2Index(theColor)
int theColor;
/* convert color to menu selection */
{
int i;

for (i=0; i<9; i++)
 if (oqdColors[i] == theColor) return(i);

return(0);
}

static pascal char  MyFilter (theDialog, theEvent, itemHit)
/* filter for drawing bold button */
DialogPtr   theDialog; 
EventRecord   *theEvent;
short  *itemHit; 
{
Rect    tempRect;
short    DType;
Handle    DItem;
PenState oldPen;

if (theEvent->what == updateEvt) { /* draw bold button */
 GetDItem(theDialog,I_OK, &DType, &DItem, &tempRect);
 GetPenState(&oldPen);
 PenSize(3, 3);
 InsetRect(&tempRect, -4, -4);
 FrameRoundRect(&tempRect, 16, 16); 
 SetPenState(&oldPen);
 }
return (FALSE);
} 
 
void   D_Mixed_Colors()
/* allows selection of colors for mixing */
{
DialogPtr    GetSelection;
Rect    tempRect;
short    DType;
Handle    DItem;
ControlHandle    CItem;
short    itemHit;

/* place dialog */
GetSelection = GetNewDialog(2, NIL, (WindowPtr)-1);
tempRect.top = GetSelection->portRect.top;
tempRect.left = GetSelection->portRect.left;
tempRect.bottom = GetSelection->portRect.bottom;
tempRect.right = GetSelection->portRect.right;
tempRect.top = ((screenBits.bounds.bottom - screenBits.bounds.top) - 
(tempRect.bottom - tempRect.top)) / 2;
tempRect.left = ((screenBits.bounds.right - screenBits.bounds.left) - 
(tempRect.right - tempRect.left)) / 2;
MoveWindow(GetSelection, tempRect.left, tempRect.top, TRUE);

/* set Pop-Up menus to color, uses Chris Faigle's PopUp CDEF */
GetDItem(GetSelection,Item1stColor, &DType,(Handle) &CItem, &tempRect);
SetCtlValue (CItem, OQDColor2Index(colorSelection[0]));
SetDItem(GetSelection,Item1stColor, DType,(Handle) CItem, &tempRect);

GetDItem(GetSelection,Item2ndColor, &DType,(Handle) &CItem, &tempRect);
SetCtlValue (CItem, OQDColor2Index(colorSelection[1]));
SetDItem(GetSelection,Item2ndColor, DType,(Handle) CItem, &tempRect);

GetDItem(GetSelection,Item3rdColor, &DType,(Handle) &CItem, &tempRect);
SetCtlValue (CItem, OQDColor2Index(colorSelection[2]));
SetDItem(GetSelection,Item3rdColor, DType,(Handle) CItem, &tempRect);

GetDItem(GetSelection,Item4thColor, &DType,(Handle) &CItem, &tempRect);
SetCtlValue (CItem, OQDColor2Index(colorSelection[3]));
SetDItem(GetSelection,Item4thColor, DType,(Handle) CItem, &tempRect);

ShowWindow(GetSelection);
SelectWindow(GetSelection);
SetPort(GetSelection);
  
ExitDialog = FALSE; 
 
do { /* dialog loop */
 ModalDialog(&MyFilter, &itemHit);
  
 if (itemHit == I_OK ) { /* get colors and quit */
 GetDItem(GetSelection,Item1stColor, &DType,(Handle) &CItem, &tempRect);
 colorSelection[0] = OQDIndex2Color(GetCtlValue(CItem));
 GetDItem(GetSelection,Item2ndColor, &DType,(Handle) &CItem, &tempRect);
 colorSelection[1] = OQDIndex2Color(GetCtlValue(CItem));
 GetDItem(GetSelection,Item3rdColor, &DType,(Handle) &CItem, &tempRect);
 colorSelection[2] = OQDIndex2Color(GetCtlValue(CItem));
 GetDItem(GetSelection,Item4thColor, &DType,(Handle) &CItem, &tempRect);
 colorSelection[3] = OQDIndex2Color(GetCtlValue(CItem));
 ExitDialog =TRUE;
 }
 
 if (itemHit == I_Cancel)
 ExitDialog =TRUE;
} while (ExitDialog == FALSE);
 
DisposDialog(GetSelection); 
SetPort(MyWindow);
InvalRect(&(MyWindow->portRect));
}
Listing: OQD_Test.h

/****************************************
File: OQD_Test.h
Function: Header for OQD_Test window.
History: 10/3/90 Original by Prototyper.  
****************************************/

extern  void  Init_OQD_Test(void);
extern  void  Close_OQD_Test(WindowPtr  whichWindow);
extern  void  Open_OQD_Test(void);
extern  void  UpDate_OQD_Test(WindowPtr  whichWindow);
extern  void  Do_OQD_Test(EventRecord  *myEvent);
Listing: OQD_Test.c

/*******************************
File: OQD_Test.c
Function: Handle OQD_Test window
*******************************/
#include "OQD_Test.h"
#include "OQDKolorize.h"
#include "String.h"

#define      TRUE   1
#define      FALSE  0
#define      NIL    0

static void  ClearRadioGroup(void);
static  void  DoCheckbox(ControlHandle theControl);
 
 /* *********************************** */
extern int checkmark;
extern int colorSelection[4];

/* Control IDs */
#define ButtonID 28
#define CheckboxID 30
#define Radio1ID 29
#define Radio2ID 31

WindowPtr MyWindow;
static ControlHandle theButton;
static ControlHandle theCheckbox;
static ControlHandle theRadio[3];
 
void  Init_OQD_Test()
/* initialize OQD_Test window */
{
MyWindow = NIL;
}

void  Close_OQD_Test(whichWindow)
/* dispose of OQD_Test window */
WindowPtr  whichWindow;
{
  
if ((MyWindow != NIL) && 
 ((MyWindow == whichWindow) || (whichWindow == (WindowPtr)-1))) {
 DisposeWindow(MyWindow); 
 MyWindow = NIL; 
 } 
}

void DrawTheRect(theRect, theColor)
Rect *theRect;
int theColor;
/* draws & frames rectangle with color */
{
FrameRect(theRect);
InsetRect(theRect, 1, 1);
ForeColor(theColor);
PaintRect(theRect);
ForeColor(blackColor);
}
void  UpDate_OQD_Test(whichWindow)
WindowPtr  whichWindow;
/* update window */
{
WindowPtr   SavePort;
Str255   sTemp;
Rect tempRect;
int pallete[4];
 
if ((MyWindow != NIL)  &&  (MyWindow == whichWindow)) {
 GetPort(&SavePort);
 SetPort(MyWindow);
 
 /* Draw solid color rectangles */
 SetRect(&tempRect, 20,40,80,100);
 DrawTheRect(&tempRect, blackColor);
 SetRect(&tempRect, 100,40,160,100);
 DrawTheRect(&tempRect, whiteColor);
 SetRect(&tempRect, 260,40,320,100);
 DrawTheRect(&tempRect, greenColor);
 SetRect(&tempRect, 180,40,240,100);
 DrawTheRect(&tempRect, redColor);
 SetRect(&tempRect, 260,140,320,200);
 DrawTheRect(&tempRect, yellowColor);
 SetRect(&tempRect, 180,140,240,200);
 DrawTheRect(&tempRect, magentaColor);
 SetRect(&tempRect, 100,140,160,200);
 DrawTheRect(&tempRect, cyanColor);
 SetRect(&tempRect, 20,140,80,200);
 DrawTheRect(&tempRect, blueColor);
 
 /* Draw Mixed rectangle according to percentages */
 SetRect(&tempRect, 360,100,420,160);
 FrameRect(&tempRect);
 InsetRect(&tempRect, 1, 1);
 switch (checkmark) {
 case 1: /* 75-25-0-0% of colorSelection */
 pallete[0] = pallete[1] = pallete[2] = colorSelection[0];
 pallete[3] = colorSelection[1];
 break;
 case 2: /* 50-50-0-0% of colorSelection */
 pallete[0] = pallete[1] = colorSelection[0];
 pallete[2] = pallete[3] = colorSelection[1];
 break;
 case 3: /* 50-25-25-0% of colorSelection */
 pallete[0] = pallete[1] = colorSelection[0];
 pallete[2] = colorSelection[1];
 pallete[3] = colorSelection[2];
 break;
 case 4: /* 25-25-25-25% of colorSelection */
 pallete[0] = colorSelection[0];
 pallete[1] = colorSelection[1];
 pallete[2] = colorSelection[2];
 pallete[3] = colorSelection[3];
 break;
 }
 PaintMixedRect(&tempRect, pallete);
 
 TextFont(systemFont);
 /* Draw titles */
 SetRect(&tempRect, 20,20,80,40);
 strcpy((char *)&sTemp,"\pBlack");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 100,20,160,40);
 strcpy((char *)&sTemp,"\pWhite");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 180,20,240,40);
 strcpy((char *)&sTemp,"\pRed");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 20,120,80,140);
 strcpy((char *)&sTemp,"\pBlue");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 260,20,320,40);
 strcpy((char *)&sTemp,"\pGreen");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 100,120,160,140);
 strcpy((char *)&sTemp,"\pCyan");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 180,120,240,140);
 strcpy((char *)&sTemp,"\pMagenta");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 260,120,320,140);
 strcpy((char *)&sTemp,"\pYellow");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 
 SetRect(&tempRect, 360,80,420,100);
 strcpy((char *)&sTemp,"\pMixed");
 TextBox(&sTemp[1], sTemp[0], &tempRect, teJustLeft);
 KolorizeMix(&tempRect, pallete);
 TextFont(applFont);
 
 DrawControls(MyWindow);
 
 KolorizeCDEF(theButton, pushButProc, cyanColor, cyanColor);
 
 if (GetCtlValue(theRadio[0]))
 KolorizeCDEF(theRadio[0], radioButProc, cyanColor, redColor);
 else
 KolorizeCDEF(theRadio[0], radioButProc, magentaColor, redColor);
 
 if (GetCtlValue(theRadio[1]))
 KolorizeCDEF(theRadio[1], radioButProc, cyanColor, redColor);
 else
 KolorizeCDEF(theRadio[1], radioButProc, magentaColor, redColor);
 
 KolorizeCDEF(theCheckbox, checkBoxProc, greenColor, redColor);
 SetPort(SavePort);
 }
}

void Open_OQD_Test(void)
/* open OQD_Test window */
{
Rect tempRect;

if (MyWindow == NIL) {
 MyWindow = GetNewWindow(1,NIL, (WindowPtr)-1);
 tempRect = MyWindow->portRect;
 tempRect.top = ((screenBits.bounds.bottom - screenBits.bounds.top) 
 - (tempRect.bottom - tempRect.top)) / 2 + 20;
 tempRect.left = ((screenBits.bounds.right - screenBits.bounds.left) 

 - (tempRect.right - tempRect.left)) / 2;
 
 MoveWindow(MyWindow, tempRect.left, tempRect.top, TRUE);
 SetPort(MyWindow);
 
 /* Make buttons */
 theButton = GetNewControl(ButtonID,MyWindow);
 theCheckbox = GetNewControl(CheckboxID,MyWindow);
 theRadio[0] = GetNewControl (Radio1ID, MyWindow);
 theRadio[1] = GetNewControl (Radio2ID, MyWindow);
 
 ShowWindow(MyWindow);
 SelectWindow(MyWindow);
 UpDate_OQD_Test(MyWindow);
 }
else
 SelectWindow(MyWindow);
}

static  void  DoCheckbox(theControl)
ControlHandle theControl;
/* handle setting and kolorizing push and radio buttons */
{
short theValue;

if (theControl == theCheckbox) { /* pushbutton */
 theValue = GetCtlValue(theControl);
 theValue = (theValue + 1) & 1;
 SetCtlValue(theControl, theValue);
 }
else { /* radio buttons */
 SetCtlValue(theRadio[0],0);
 SetCtlValue(theRadio[1],0);
 SetCtlValue(theControl, 1);
 }
}

void  Do_OQD_Test(myEvent)
/* handle mouse downs in controls */
EventRecord *myEvent;
{
short code;
WindowPtr whichWindow;
Point myPt;
ControlHandle theControl;

if (MyWindow != NIL) { /* make sure our window */
 code = FindWindow(myEvent->where, &whichWindow);
 
 /* see if mouse down */
 if ((myEvent->what == mouseDown)  &&  (MyWindow == whichWindow)) {
 myPt = myEvent->where;
 GlobalToLocal(&myPt);
 }
 
 /* see if control */
 if ((MyWindow == whichWindow) &&  (code == inContent)) {
 code = FindControl(myPt, whichWindow, &theControl);
 if (code != 0) 
 code = TrackControl(theControl,myPt, NIL);
 if (code == inButton) /* only 1 button - Kolorize */
 KolorizeCDEF(theButton, pushButProc, cyanColor, cyanColor);
 if (code == inCheckBox) /* handle pushbutton and radios */
 DoCheckbox(theControl);
 KolorizeCDEF(theButton, pushButProc, cyanColor, cyanColor);
 
 /* Kolorize radios and checkbox */
 if (GetCtlValue(theRadio[0]))
 KolorizeCDEF(theRadio[0], radioButProc, cyanColor, redColor);
 else
 KolorizeCDEF(theRadio[0], radioButProc, magentaColor, redColor);
 
 if (GetCtlValue(theRadio[1]))
 KolorizeCDEF(theRadio[1], radioButProc, cyanColor, redColor);
 else
 KolorizeCDEF(theRadio[1], radioButProc, magentaColor, redColor);
 
 KolorizeCDEF(theCheckbox, checkBoxProc, greenColor, redColor);
 }
 }
}
 Listing: OQD.c

/************************************
Program name:  OQD.c
Function:  Demos Old QuickDraw Color Tricks. 
************************************/

#include "OQD_Test.h"

#define      TRUE   1
#define      FALSE  0
#define      NIL    0

/* initial color selection */
int colorSelection[4] = { whiteColor, blackColor, whiteColor, blackColor};

/* external functions */
extern void InitMyMenus(void);
extern void HandleMenu(char *doneFlag, short theMenu, short theItem);

void main(void);

void main()
{
char doneFlag, ch;
short code, theMenu, theItem, chCode;
long mResult;
WindowPtr whichWindow;
EventRecord myEvent;
Rect tempRect;
GrafPtr SavePort;

/* initialize everything */
InitGraf(&thePort);
InitFonts();
FlushEvents(everyEvent,0);
InitWindows();
InitMenus();
TEInit();
InitDialogs(NIL);
InitCursor();
 
/* initialize my own stuff */
doneFlag = FALSE;
InitMyMenus();
Init_OQD_Test();
Open_OQD_Test();
 
do {
 SystemTask();
 
 if (GetNextEvent(everyEvent, &myEvent)) {
 code = FindWindow(myEvent.where, &whichWindow);   
 
 switch (myEvent.what) {
 case mouseDown:
 if (code == inMenuBar) {
 mResult = MenuSelect(myEvent.where);
 theMenu = HiWord(mResult);
 theItem = LoWord(mResult);
 HandleMenu(&doneFlag,theMenu,theItem);
 }
 
  if ((code == inDrag)&&(whichWindow != NIL)) {
 tempRect = screenBits.bounds;
 SetRect(&tempRect, tempRect.left + 10, tempRect.top + 25, tempRect.right 
- 10, tempRect.bottom - 10);
 DragWindow(whichWindow, myEvent.where, &tempRect);
 }
  
 if (code == inContent) {
 if (whichWindow != FrontWindow()) {
 SelectWindow(whichWindow);
 }
 else {
 SetPort(whichWindow);
 Do_OQD_Test (&myEvent);
 }
 }
 
 if (code == inSysWindow) {
 SystemClick(&myEvent, whichWindow);
 }
 
 break;
 
 case keyDown: 
 case autoKey: 
 ch = myEvent.message &  charCodeMask;
 if (myEvent.modifiers & cmdKey) {
 mResult = MenuKey(ch);
 theMenu = HiWord(mResult);
 theItem = LoWord(mResult);
 if (theMenu != 0) 
 HandleMenu(&doneFlag, theMenu, theItem); 
 }
 break;
 
 case updateEvt:
 whichWindow = (WindowPtr)myEvent.message;
 GetPort(&SavePort);
 BeginUpdate(whichWindow);
 SetPort(whichWindow);
 UpDate_OQD_Test(whichWindow);
 EndUpdate(whichWindow);
 SetPort(SavePort);
 break;
 
 case activateEvt:
 if ((whichWindow != NIL) && (myEvent.modifiers & activeFlag)) { 
 SelectWindow(whichWindow);
 }
 break;
 }
 
 }
 } while (doneFlag ==  FALSE);
}
Listing:  OQD.r

resource 'WIND' (1, "OQD Test") {
 {91, 66, 378, 511},
 noGrowDocProc,
 invisible,
 noGoAway,
 0x1,
 "OQD Test"
};

resource 'CNTL' (28, "Button") {
 {220, 20, 240, 100},
 0,
 16,
 1,
 0,
 pushButProc,
 28,
 "Button"
};

resource 'CNTL' (30, "Checkbox") {
 {220, 240, 235, 320},
 0,
 16,
 1,
 0,
 checkBoxProc,
 30,
 "Checkbox"
};

resource 'CNTL' (29, "Radio") {
 {220, 140, 235, 220},
 1,
 16,
 1,
 0,
 radioButProc,
 29,
 "Radio "
};

resource 'CNTL' (31, "Radio") {
 {240, 140, 255, 220},
 0,
 16,
 1,
 0,
 radioButProc,
 31,
 "Radio "
};

resource 'CNTL' (128, "Color:") {
 {20, 20, 40, 170},
 5,
 visible,
 8,
 1,
 81,
 51,
 "1st Color:"
};

resource 'CNTL' (129) {
 {50, 20, 70, 170},
 5,
 visible,
 8,
 1,
 81,
 52,
 "2nd Color:"
};

resource 'CNTL' (130) {
 {80, 20, 100, 170},
 8,
 visible,
 8,
 1,
 81,
 53,
 "3rd Color:"
};

resource 'CNTL' (131) {
 {110, 20, 130, 170},
 8,
 visible,
 8,
 1,
 81,
 54,
 "4th Color:"
};

resource 'MENU' (1001, "Std Menu - \0x14") {
 1001,
 textMenuProc,
 allEnabled,
 enabled,
 apple,
 { /* array: 0 elements */
 }
};

resource 'MENU' (1002, "Std Menu - File") {
 1002,
 textMenuProc,
 allEnabled,
 enabled,
 "File",
 { /* array: 1 elements */
 /* [1] */
 "Quit", noIcon, "Q", noMark, plain
 }
};

resource 'MENU' (1003, "Std Menu - Mixed") {
 1003,
 textMenuProc,
 0x7FFFFFEF,
 enabled,
 "Mixed",
 { /* array: 6 elements */
 /* [1] */
 "75-25%", noIcon, noKey, check, plain,
 /* [2] */
 "50-50%", noIcon, noKey, noMark, plain,
 /* [3] */
 "50-25-25%", noIcon, noKey, noMark, plain,
 /* [4] */
 "25-25-25-25%", noIcon, noKey, noMark, plain,
 /* [5] */
 "-", noIcon, noKey, noMark, plain,
 /* [6] */
 "Colors Mixed ", noIcon, noKey, noMark, plain
 }
};

resource 'MENU' (51, "Popup - Popup") {
 51,
 textMenuProc,
 allEnabled,
 enabled,
 "Color",
 { /* array: 8 elements */
 /* [1] */
 "Black", noIcon, noKey, noMark, plain,
 /* [2] */
 "White", noIcon, noKey, noMark, plain,
 /* [3] */
 "Red", noIcon, noKey, noMark, plain,
 /* [4] */
 "Green", noIcon, noKey, noMark, plain,
 /* [5] */
 "Blue", noIcon, noKey, noMark, plain,
 /* [6] */
 "Cyan", noIcon, noKey, noMark, plain,
 /* [7] */
 "Magenta", noIcon, noKey, noMark, plain,
 /* [8] */
 "Yellow", noIcon, noKey, noMark, plain
 }
};

resource 'MENU' (52, "Popup - Popup") {
 52,
 textMenuProc,
 allEnabled,
 enabled,
 "Popup",
 { /* array: 8 elements */
 /* [1] */
 "Black", noIcon, noKey, noMark, plain,
 /* [2] */
 "White", noIcon, noKey, noMark, plain,
 /* [3] */
 "Red", noIcon, noKey, noMark, plain,
 /* [4] */
 "Green", noIcon, noKey, noMark, plain,
 /* [5] */
 "Blue", noIcon, noKey, noMark, plain,
 /* [6] */
 "Cyan", noIcon, noKey, noMark, plain,
 /* [7] */
 "Magenta", noIcon, noKey, noMark, plain,
 /* [8] */
 "Yellow", noIcon, noKey, noMark, plain
 }
};

resource 'MENU' (53, "Popup - Popup") {
 53,
 textMenuProc,
 allEnabled,
 enabled,
 "Popup",
 { /* array: 8 elements */
 /* [1] */
 "Black", noIcon, noKey, noMark, plain,
 /* [2] */
 "White", noIcon, noKey, noMark, plain,
 /* [3] */
 "Red", noIcon, noKey, noMark, plain,
 /* [4] */
 "Green", noIcon, noKey, noMark, plain,
 /* [5] */
 "Blue", noIcon, noKey, noMark, plain,
 /* [6] */
 "Cyan", noIcon, noKey, noMark, plain,
 /* [7] */
 "Magenta", noIcon, noKey, noMark, plain,
 /* [8] */
 "Yellow", noIcon, noKey, noMark, plain
 }
};

resource 'MENU' (54, "Popup - Popup") {
 54,
 textMenuProc,
 allEnabled,
 enabled,
 "Popup",
 { /* array: 8 elements */
 /* [1] */
 "Black", noIcon, noKey, noMark, plain,
 /* [2] */
 "White", noIcon, noKey, noMark, plain,
 /* [3] */
 "Red", noIcon, noKey, noMark, plain,
 /* [4] */
 "Green", noIcon, noKey, noMark, plain,
 /* [5] */
 "Blue", noIcon, noKey, noMark, plain,
 /* [6] */
 "Cyan", noIcon, noKey, noMark, plain,
 /* [7] */
 "Magenta", noIcon, noKey, noMark, plain,
 /* [8] */
 "Yellow", noIcon, noKey, noMark, plain
 }
};

resource 'DLOG' (2, "Mixed Colors") {
 {139, 144, 321, 496},
 dBoxProc,
 invisible,
 noGoAway,
 0x2,
 2,
 "Mixed Colors"
};

resource 'DITL' (2, "Mixed Colors") {
 { /* array DITLarray: 6 elements */
 /* [1] */
 {140, 240, 166, 317},
 Button {
 enabled,
 "OK"
 },
 /* [2] */
 {20, 240, 46, 317},
 Button {
 enabled,
 "Cancel"
 },
 /* [3] */
 {20, 30, 40, 180},
 Control {
 enabled,
 128
 },
 /* [4] */
 {60, 30, 80, 180},
 Control {
 enabled,
 129
 },
 /* [5] */
 {100, 30, 120, 180},
 Control {
 enabled,
 130
 },
 /* [6] */
 {140, 30, 160, 180},
 Control {
 enabled,
 131
 }
 }
};

From Nov 91 Letters:

BitMap Error

Kirk Chase

MacTutor

I would like to point out an error in some code published in MacTutor, November 1990 ("Special Effect") and June 1991 ("Kolorize Your B&W Application"). Basically the code in question is the offscreen bitmap allocation function used in both articles. The offending line in the procedure NewBitMap is

bm->baseAddr=NewPtr(bm->rowBytes *(long (r->right - r->left));

This assumes a height the same size as the width. Correct it to the following:

bm->baseAddr=NewPtr(bm->rowBytes *(long (r->bottom - r->top));

Thanks to Randy Frank for pointing this out.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

OmniPlan Pro 3.6 - Professional-grade pr...
With OmniPlan Pro, you can create logical, manageable project plans with Gantt charts, schedules, summaries, milestones, and critical paths. Break down the tasks needed to make your project a success... Read more
Little Snitch 3.7.1 - Alerts you about o...
Little Snitch gives you control over your private outgoing data. Track background activity As soon as your computer connects to the Internet, applications often have permission to send any... Read more
iMazing 2.1.3 - Complete iOS device mana...
iMazing (was DiskAid) is the ultimate iOS device manager with capabilities far beyond what iTunes offers. With iMazing and your iOS device (iPhone, iPad, or iPod), you can: Copy music to and from... Read more
AppDelete 4.3.1 - $7.99
AppDelete is an uninstaller that will remove not only applications but also widgets, preference panes, plugins, and screensavers along with their associated files. Without AppDelete these associated... Read more
FileZilla 3.23.0.2 - Fast and reliable F...
FileZilla (ported from Windows) is a fast and reliable FTP client and server with lots of useful features and an intuitive interface. Version 3.23.0.2: Bug Fixes and Minor Changes Speed up icon... Read more
PDFpen 8.3 - $74.95
PDFpen allows users to easily edit PDF's. Add text, images and signatures. Fill out PDF forms. Merge or split PDF documents. Reorder and delete pages. Even correct text and edit graphics! Features... Read more
TunnelBear 3.0.8 - Subscription-based pr...
TunnelBear is a subscription-based virtual private network (VPN) service and companion app, enabling you to browse the internet privately and securely. Features Browse privately - Secure your data... Read more
Safari Technology Preview 10.1 - The new...
Safari Technology Preview contains the most recent additions and improvements to WebKit and the latest advances in Safari web technologies. And once installed, you will receive notifications of... Read more
Ableton Live 9.7.1 - Record music using...
Ableton Live lets you create and record music on your Mac. Use digital instruments, pre-recorded sounds, and sampled loops to arrange, produce, and perform your music like never before. Ableton Live... Read more
BetterTouchTool 1.963 - Customize Multi-...
BetterTouchTool adds many new, fully customizable gestures to the Magic Mouse, Multi-Touch MacBook trackpad, and Magic Trackpad. These gestures are customizable: Magic Mouse: Pinch in / out (zoom... Read more

Latest Forum Discussions

See All

Bully: Anniversary Edition (Games)
Bully: Anniversary Edition 1.03.1 Device: iOS Universal Category: Games Price: $6.99, Version: 1.03.1 (iTunes) Description: *** PLEASE NOTE: This game is officially supported on the following devices: iPhone 5 and newer, iPod Touch... | Read more »
PINE GROVE (Games)
PINE GROVE 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: A pine grove where there are no footsteps of people due to continuous missing cases. The case is still unsolved and nothing has... | Read more »
Niantic teases new Pokémon announcement...
After rumors started swirling yesterday, it turns out there is an official Pokémon GO update on its way. We’ll find out what’s in store for us and our growing Pokémon collections tomorrow during the Starbucks event, but Niantic will be revealing... | Read more »
3 reasons why Nicki Minaj: The Empire is...
Nicki Minaj is as business-savvy as she is musically talented and she’s proved that by launching her own game. Designed by Glu, purveyors of other fine celebrity games like cult favorite Kim Kardashian: Hollywood, Nicki Minaj: The Empire launched... | Read more »
Clash of Clans is getting its own animat...
Riding on its unending wave of fame and success, Clash of Clans is getting an animated web series based on its Clash-A-Rama animated shorts.As opposed to the current shorts' 60 second run time, the new and improved Clash-A-Rama will be comprised of... | Read more »
Leaks hint at Pokémon GO and Starbucks C...
Leaked images from a hub for Starbucks employees suggests that a big Pokémon GO event with the coffee giant could begin this very week. The images appeared on Reddit and hint at some exciting new things to come for Niantic's smash hit game. | Read more »
Silent Depth Submarine Simulation (Game...
Silent Depth Submarine Simulation 1.0 Device: iOS Universal Category: Games Price: $7.99, Version: 1.0 (iTunes) Description: | Read more »
Enneas Saga lets you lead your own demon...
Defend the land of Enneas Continent from the forces of evil in the new fantasy MMORPG from Lyto Mobi: Enneas Saga. Can’t wait? No problem. It’s available to download now on Android devices. | Read more »
Great zombie games in the spirit of Dead...
Dead Rising 4 arrives tomorrow, giving enthusiasts a fresh chance to take selfies with zombies and get up to other ridiculous end-of-the-world shenanigans. To really get into the spirit of things, we've gone and gathered the best zombie games that... | Read more »
Amateur Surgeon 4 Guide: Advanced tips a...
Amateur Surgeon 4 is still tackling the competition at the top of the App Store charts, so if you haven't tried it out yet, you should probably do that right away. If you've been at it for a while, though, perhaps you're ready to start expanding... | Read more »

Price Scanner via MacPrices.net

Holiday sale: 12-inch Retina MacBook for $100...
B&H has 12″ Retina MacBooks on sale for $100 off MSRP as part of their Holiday sale. Shipping is free, and B&H charges NY sales tax only: - 12″ 1.1GHz Space Gray Retina MacBook: $1199 $100... Read more
Apple refurbished 13-inch MacBook Airs availa...
Apple has Certified Refurbished 13″ MacBook Airs available starting at $849. An Apple one-year warranty is included with each MacBook, and shipping is free: - 13″ 1.6GHz/8GB/128GB MacBook Air: $849 $... Read more
Apple refurbished iMacs available for up to $...
Apple has Certified Refurbished 2015 21″ & 27″ iMacs available for up to $350 off MSRP. Apple’s one-year warranty is standard, and shipping is free. The following models are available: - 21″ 3.... Read more
Apple’s Education discount saves up to $300 o...
Purchase a new Mac or iPad using Apple’s Education Store and take up to $300 off MSRP. All teachers, students, and staff of any educational institution qualify for the discount. Shipping is free: -... Read more
Back in stock: Apple refurbished Mac minis fr...
Apple has Certified Refurbished Mac minis available starting at $419. Apple’s one-year warranty is included with each mini, and shipping is free: - 1.4GHz Mac mini: $419 $80 off MSRP - 2.6GHz Mac... Read more
Twenty-Five Years Of Apple Laptops – A person...
Among many other things, the often tumultuous 16th year of the new century marked the 25th anniversary of Apple laptop computers, not counting the optimistically named 16-pound Mac Portable of 1989.... Read more
Landlordy iOS App Adds Support For Appliances...
Riga, Latvia based E-protect SIA is releasing major update (version 1.8) to its Landlordy app for managing rental business financials on the go. Landlordy is iPhone and iPad app designed for self-... Read more
Holiday sale, Apple iMacs for up to $200 off...
B&H Photo has 21″ and 27″ Apple iMacs on sale for up to $200 off MSRP including free shipping plus NY sales tax only: - 27″ 3.3GHz iMac 5K: $2099 $200 off MSRP - 27″ 3.2GHz/1TB Fusion iMac 5K: $... Read more
Holiday sale: Mac minis for $50 to $100 off M...
B&H Photo has Mac minis on sale for up to $100 off MSRP free shipping plus NY sales tax only: - 1.4GHz Mac mini: $449 $50 off MSRP - 2.6GHz Mac mini: $629 $70 off MSRP - 2.8GHz Mac mini: $899 $... Read more
Mac Pros on sale for up to $300 off MSRP, ref...
B&H Photo has Mac Pros on sale for up to $300 off MSRP. Shipping is free, and B&H charges sales tax in NY only: - 3.7GHz 4-core Mac Pro: $2799, $200 off MSRP - 3.5GHz 6-core Mac Pro: $3699, $... Read more

Jobs Board

*Apple* Retail - Multiple Positions- Philade...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* Retail - Multiple Positions- San Ant...
Job Description:SalesSpecialist - Retail Customer Service and SalesTransform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* Products Tester Needed - Apple (Unit...
…we therefore look forward to put out products to quality test for durability. Apple leads the digital music revolution with its iPods and iTunes online store, Read more
SW Engineer *Apple* TV Frameworks - Apple I...
The Apple TV team is looking for a software...create features that reflect the look and feel of Apple TV. Description: Were looking for someone who is Read more
Hardware Design Validation Engineer - *Apple...
The Apple Watch team is looking for a Hardware Design Validation Engineer. This person will be part of the Apple Watch hardware team with responsibilities for Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.