TweetFollow Us on Twitter

Color 2
Volume Number:10
Issue Number:11
Column Tag:Getting Started

Related Info: Color Quickdraw Menu Manager Gestalt Manager

Working With Color, Part 2

By Dave Mark, MacTech Magazine Regular Contributing Author

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

Before we get into this month’s column, I’d like to take a second to talk about some changes that are coming down the ’pike. Every month, I’m faced with a perplexing challenge. How can I present a decent sized program in my column, and still have room to walk through the source code? The current solution is to split the column over two issues. The first month I present the program’s resources and source code and the second month I actually walk through the source code, essentially giving you the source code twice.

Unfortunately, there’s no easy way to simplify this process. If I just present the source code as a single block, there’s no room for commentary and if I just present the source code with comments mixed in it makes it extremely difficult to type in the code. Not a good situation!

Fortunately, the powers-that-be came up with a pretty cool idea (which I’m sure you’ll read about elsewhere in the magazine over the next few months). They are putting together a small framework, called Sprocket, designed to showcase new Mac technologies. Sprocket will start off with same pretty basic capabilities, then grow as time goes on. It will be written entirely in C++ and will be made available to every MacTech subscriber.

This makes life infinitely easier for us column writers! Instead of presenting a single, monolithic application every two months, I’ll be able to focus on a few new classes, which can be folded into the framework and, more importantly, which can be presented and completely discussed, all in a single column.

The biggest implication this has for you is a change from C to C++. If this is a bad thing, now’s the time to get it off your chest. Send all bitter, sarcastic complaints to Scott Boyd, at one of the myriad addresses found on page 2 of this magazine.

I’m really looking forward to getting into this new framework and polishing my C++ skills. I think this is a great idea and hope you do too...

Back to ColorTutor

All that said and done, let’s get back to last month’s program, ColorTutor. To recap last month’s description, ColorTutor is a rewrite of the Mac Primer, Volume II program of the same name. ColorTutor is a hands-on color blending environment. You specify the foreground and background colors and patterns, then select a Color Quickdraw drawing mode. ColorTutor uses CopyBits() to mix the foreground and background colors. Figure 1 shows a sample.

Figure 1. The ColorTutor window.

ColorTutor first copies the Background image to the lower-right rectangle, then copies the Source image on top of the Background using the current Mode and OpColor. As we dig through the code, we’ll look at the parts of Color Quickdraw that make ColorTutor possible.

Exploring the ColorTutor Source Code

ColorTutor starts off with a pair of #includes. <Picker.h> contains the definitions we’ll need to use the Mac’s built-in color picker, while <GestaltEqu.h> contains what we’ll need to call Gestalt().


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

Here’s the usual cast of constants...

#define kBaseResID 128
#define kErrorALRTid 128
#define kNullFilterProc NULL
#define kMoveToFront (WindowPtr)-1L
#define kNotNormalMenu    -1
#define kSleep   60L

#define mApple   kBaseResID
#define iAbout   1

#define mFile    kBaseResID+1
#define iQuit    1

#define mColorsPopup kBaseResID+3
#define iBlackPattern1
#define iGrayPattern 2
#define iColorRamp 4
#define iGrayRamp5
#define iSingleColor 6

#define mModePopup kBaseResID+4

We’ve sure got a lot of globals. Short of adding pass-through parameters to a bunch of routines, I couldn’t think of any way to get rid of them. Any ideas?

gDone is the flag that tells us when to drop out of the main event loop. gSrcRect, gBackRect, gDestRect, and gOpColorRect mark the boundaries of the four color rectangles in the ColorTutor window. gSrcMenuRect, gBackMenuRect, and gModeMenuRect mark the outline of the three popup menus. As you read through the code, remember that ‘Src’ refers to the source color, ‘Back’ refers to the background color, and ‘Op’ refers to the op-color (you’ll find out what the opcolor is about later in the column).

‘Dest’ and ‘Mode’ both refer to the lower-right corner of the ColorTutor window. ‘Dest’ refers to the lower-right color rectangle which is used to mix the source and background colors. ‘Mode’ refers to the popup menu below the ‘Dest’ rectangle and specifies the color drawing mode used to mix the source and background colors.


/* 2 */
Boolean gDone;

Rect    gSrcRect, gBackRect, gDestRect, gSrcMenuRect, 
 gBackMenuRect, gModeMenuRect, gOpColorRect;

The next set of globals mirror the current settings of the three popup menus. gSrcPattern is set to either iBlackPattern or iGrayPattern, and gSrcType is one of iColorRamp, iGrayRamp, or iSingleColor. These choices correspond directly to the menu in Figure 2. gBackPattern and gBackType follow the exact same rules, since the Background menu was built from the same MENU resource.

Figure 2. The popup menu that goes along with the Source and Background menus.

gCopyMode is one of the Color Quickdraw copy modes and mirrors the Mode menu shown in Figure 3. gCopyMode is set in the routine UpdateModeMenu().

Figure 3. The Mode popup menu.


/* 3 */
short gSrcPattern, gBackPattern, gCopyMode, gSrcType, gBackType;

gSrcColor, gBackColor, and gOpColor are the colors displayed in the source, background, and op-color rectangles in the ColorTutor window. The source and background colors only come into play when the Single Color... item is checked in their respective popup menus. The OpColor is always a single color and comes into play when you use certain Color Quickdraw copying modes.


/* 4 */
RGBColorgSrcColor, gBackColor, gOpColor;

Finally, gSrcMenu, gBackMenu, and gModeMenu are handles to their respective menus.


/* 5 */
MenuHandlegSrcMenu, gBackMenu, gModeMenu;

Here are all the function prototypes...


/* 6 */
Functions
void    ToolboxInit( void );
void    MenuBarInit( void );
void    CreateWindow( void );
void    SetUpGlobals( void );
void    EventLoop( void );
void    DoEvent( EventRecord *eventPtr );
void    HandleMouseDown( EventRecord *eventPtr );
void    HandleMenuChoice( long menuChoice );
void    HandleAppleChoice( short item );
void    HandleFileChoice( short item );
void    DoUpdate( WindowPtr window );
void    DrawContents( WindowPtr window );
void    DrawColorRamp( Rect *rPtr );
void    DrawGrayRamp( Rect *rPtr );
void    DrawLabel( Rect *boundsPtr, Str255 s );
void    DoContent( WindowPtr window, Point globalPoint );
void    UpdateSrcMenu( void );
void    UpdateBackMenu( void );
void    UpdateModeMenu( void );
void    DoSrcChoice( short item );
void    DoBackChoice( short item );
void    DoModeChoice( short item );
short   DoPopup( MenuHandle menu, Rect *boundsPtr );
Boolean PickColor( RGBColor *colorPtr );
Boolean HasColorQD( void );
void    DoError( Str255 errorString );

main() initializes the Toolbox, sets up the menu bar, then checks to see if this machine supports Color Quickdraw. It’s important to at least initialize the Toolbox before you check for Color Quickdraw, since we use the Toolbox to report an error if Color Quickdraw is not present.


/* 7 */
main
void  main( void )
{
 ToolboxInit();
 MenuBarInit();
 
 if ( ! HasColorQD() )
 DoError( "\pThis machine does not support Color QuickDraw!" );

Next, we’ll create the ColorTutor window, assign initial values to our globals, then drop into the main event loop.


/* 8 */
 CreateWindow();
 SetUpGlobals();
 
 EventLoop();
}

ToolboxInit() is pretty much the same as always. Notice the use of qd.thePort instead of just plain thePort. THINK C and C++ assume that when you refer to a quickdraw global (like thePort) you are referring to the corresponding quickdraw global that gets allocated as part of each application’s memory zone. MPW and CodeWarrior both require the “qd.” syntax, turning “thePort” into “qd.thePort”. Since THINK C can handle either form, I’ve gone back to the “qd.” form so all my code compiles in either environment.


/* 9 */
ToolboxInit
void  ToolboxInit( void )
{
 InitGraf( &qd.thePort );
 InitFonts();
 InitWindows();
 InitMenus();
 TEInit();
 InitDialogs( 0L );
 InitCursor();
}

MenuBarInit() sets up the menu bar. Notice that it doesn’t set up the popup menus, which are not displayed in the menubar.


/* 10 */
MenuBarInit
void  MenuBarInit( void )
{
 Handle menuBar;
 MenuHandle menu;
 
 menuBar = GetNewMBar( kBaseResID );
 
 if ( menuBar == NULL )
 DoError( "\pCouldn't load the MBAR resource..." );
 
 SetMenuBar( menuBar );

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

CreateWindow() creates a new, Color Quickdraw window based on a WIND resource.


/* 11 */
CreateWindow
void  CreateWindow( void )
{
 WindowPtrwindow;

 window = GetNewCWindow( kBaseResID, NULL, kMoveToFront );

The call to GetNewControl() uses the CNTL resource template to build the OpColor push-button control and add it to the window.


/* 12 */
 GetNewControl( kBaseResID, window );

Finally, the window is made the current port and the port’s font is set to Chicago, which is the system font. This is to make sure that the popup menu label is drawn in 12-point Chicago.


/* 13 */
 SetPort( window );
 TextFont( systemFont );
}

SetUpGlobals() starts off by setting up the four color rectangles and the label rectangles for the three popup menus.


/* 14 */
SetUpGlobals
void  SetUpGlobals( void )
{
 SetRect( &gSrcRect, 15, 6, 95, 86 );
 SetRect( &gBackRect, 125, 6, 205, 86 );
 SetRect( &gDestRect, 125, 122, 205, 202 );
 SetRect( &gOpColorRect, 15, 122, 95, 202 );
 
 SetRect( &gSrcMenuRect, 7, 90, 103, 108 );
 SetRect( &gBackMenuRect, 117, 90, 213, 108 );
 SetRect( &gModeMenuRect, 117, 206, 213, 224 );

One way to get rid of these globals is to create a set of rectangle resources, each of which describes a different rectangle. You might create a ‘rect’ resource type, 8 bytes in length (4 shorts). Then, instead of using a global, you’d read and write the corresponding ‘rect’ resource. Even though the globals have a higher overhead, we’re talking about a pretty small amount of stack space and I find the resource approach a little cumbersome.

Next, we set default values for our various globals.


/* 15 */
 gSrcPattern = iBlackPattern;
 gBackPattern = iBlackPattern;
 
 gCopyMode = srcCopy;
 
 gSrcColor.red = 65535;
 gSrcColor.green = gSrcColor.blue = 0;
 gSrcType = iSingleColor;
 
 gBackColor.blue = 65535;
 gBackColor.red = gBackColor.green = 0;
 gBackType = iSingleColor;

Here, we create a grey RGBColor (all values are halfway between 0 and 65535) and pass it to OpColor(). OpColor() first checks to make sure the current port is a CGrafPort. If so (and in our case it is), OpColor() sets the rgbOpColor field of the grafvars struct (in the CGrafPort) to the specified color. Take a minute to look at these structures. In Inside Macintosh: Imaging, Inside Macintosh: Volume V, or in THINK Reference, take a look at the CGrafPort structure. The fourth field is a Handle called grafVars. This is actually a handle to a GrafVars structure.

Now look up GrafVars. The first field, rgbOpColor, contains an RGBColor used with the addPin, subPin, and blend color transfer modes. addPin replaces the destination pixel with the sum of the source and destination pixel colors, up to a maximum of the colors specified by the opColor. With the opcolor as specified below, the red, green, and blue values in the lower-right rectangle of the ColorTutor window will never exceed 32767. With addPin, the maximum color is always white (65535,65535,65535).


/* 16 */
 gOpColor.green = 32767;
 gOpColor.red = 32767;
 gOpColor.blue = 32767;
 OpColor( &gOpColor );

subPin replaces the destination pixel with the difference between the source and destination, where the opColor provides a minimum value for the ultimate red, green, and blue fields. With subPin, the minimum color is always black (0,0,0).

Finally, the blend mode uses a weighting formula to blend the source and destination colors:


/* 17 */
dest = (source * weight / 65535) + (dest * (1-(weight/65535)));

This calculation is made once each for red, green, and blue, using the respective opColor field as the weight.

None of the other transfer modes take advantage of a port’s opColor.

Next, we’ll set up MenuInfo structures for the three popup menus. Each menu is added to the application’s menu list by passing its handle to InsertMenu(). The constant kNotNormalMenu (which is -1L) tells the Menu Manager not to add these menus to the menu bar.


/* 18 */
 gSrcMenu = GetMenu( mColorsPopup );
 InsertMenu( gSrcMenu, kNotNormalMenu );
 
 gBackMenu = GetMenu( mColorsPopup );
 InsertMenu( gBackMenu, kNotNormalMenu );
 
 gModeMenu = GetMenu( mModePopup );
 InsertMenu( gModeMenu, kNotNormalMenu );
}

Blah, blah, blah... EventLoop()... blah, blah.


/* 19 */
EventLoop
void  EventLoop( void )
{
 EventRecordevent;
 
 gDone = false;
 while ( gDone == false )
 {
 if ( WaitNextEvent( everyEvent, &event, kSleep, NULL ) )
 DoEvent( &event );
 }
}

DoEvent() does its normal thing, passing mouseDowns to HandleMouseDown() and updates to DoUpdate().


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

Nothing unusual here. Clicks in the ColorTutor window are handled by DoContent(). Since we only have one window, the call to SelectWindow() will never be made. Oh, well, force of habit...


/* 21 */
HandleMouseDown
void  HandleMouseDown( EventRecord *eventPtr )
{
 WindowPtrwindow;
 short  thePart;
 long   menuChoice;
 
 thePart = FindWindow( eventPtr->where, &window );
 
 switch ( thePart )
 {
 case inMenuBar:
 menuChoice = MenuSelect( eventPtr->where );
 HandleMenuChoice( menuChoice );
 break;
 case inSysWindow : 
 SystemClick( eventPtr, window );
 break;
 case inContent:
 if ( window != FrontWindow() )
 SelectWindow( window );
 else
 DoContent( window, eventPtr->where );
 break;
 case inDrag : 
 DragWindow( window, eventPtr->where, &qd.screenBits.bounds );
 break;
 }
}

HandleMenuChoice(), HandleAppleChoice(), and HandleFileChoice() deserve a column all to themselves, eh?


/* 22 */
HandleMenuChoice
void  HandleMenuChoice( long menuChoice )
{
 short  menu;
 short  item;
 
 if ( menuChoice != 0 )
 {
 menu = HiWord( menuChoice );
 item = LoWord( menuChoice );
 
 switch ( menu )
 {
 case mApple:
 HandleAppleChoice( item );
 break;
 case mFile:
 HandleFileChoice( item );
 break;
 }
 HiliteMenu( 0 );
 }
}

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

HandleFileChoice
void  HandleFileChoice( short item )
{
 switch ( item )
 {
 case iQuit:
 gDone = true;
 break;
 }
}

DoUpdate() handles any update events with calls to DrawContents() to draw everything but the OpColor... push button, which is drawn by calling DrawControls().


/* 23 */
DoUpdate
void  DoUpdate( WindowPtr window )
{
 BeginUpdate( window );
 
 DrawContents( window );
 DrawControls( window );
 
 EndUpdate( window );
}

DrawContents() starts by setting up a true black RGBColor.


/* 24 */
DrawContents
void  DrawContents( WindowPtr window )
{
 RGBColor rgbBlack;
 Rect   source, dest;
 
 rgbBlack.red = rgbBlack.green = rgbBlack.blue = 0;

Next, the CGrafPort’s pattern is set to black or gray, depending on the value of gSrcPattern, which mirrors the setting of the Source popup menu. Here’s another place I could have gotten rid of some globals. Instead of checking the value of a global, I could have checked the appropriate menu item to see if it was checked. Again, I find the global-based method to be less cumbersome, though there are some who, even as we speak, are reaching for their direct lines to the Thought Police in their desparate quest for interface cleanliness. Sigh.


/* 25 */
 if ( gSrcPattern == iBlackPattern )
 PenPat( &qd.black );
 else
 PenPat( &qd.gray );

Next, we’ll draw either a color ramp, a gray ramp, or a solid color in the source rectangle. If you don’t know what a ramp is, check out the source rectangle in Figure 1.


/* 26 */
 if ( gSrcType == iColorRamp )
 DrawColorRamp( &gSrcRect );
 else if ( gSrcType == iGrayRamp )
 DrawGrayRamp( &gSrcRect );
 else
 {
 RGBForeColor( &gSrcColor );
 PaintRect( &gSrcRect );
 }

Now we’ll repeat this process for the background rectangle.


/* 27 */
 if ( gBackPattern == iBlackPattern )
 PenPat( &qd.black );
 else
 PenPat( &qd.gray );
 
 if ( gBackType == iColorRamp )
 DrawColorRamp( &gBackRect );
 else if ( gBackType == iGrayRamp )
 DrawGrayRamp( &gBackRect );
 else
 {
 RGBForeColor( &gBackColor );
 PaintRect( &gBackRect );
 }

Next, we’ll restore the pen pattern to solid black, paint the opColor rectangle, then set the ForeColor() back to black.


/* 28 */
 PenPat( &qd.black );
 
 RGBForeColor( &gOpColor );
 PaintRect( &gOpColorRect );
 
 RGBForeColor( &rgbBlack );

Next, we’ll draw the three popup menu labels, then the frames around the four color rectangles, then return the pen to normal.


/* 29 */
 DrawLabel( &gSrcMenuRect, "\pSource" );
 DrawLabel( &gBackMenuRect, "\pBackground" );
 DrawLabel( &gModeMenuRect, "\pMode" );
 
 PenSize( 2, 2 );
 FrameRect( &gSrcRect );
 FrameRect( &gBackRect );
 FrameRect( &gDestRect );
 FrameRect( &gOpColorRect );
 
 PenNormal();

Now we’ll set up the source and destination rectangles. We inset them to avoid copying the frames. Notice that we first copy the Background rectangle to the Dest (lower-right) rectangle. Once we do that, we’ll copy the Source rectangle on top of that.


/* 30 */
 source = gBackRect;
 InsetRect( &source, 2, 2 );
 
 dest = gDestRect;
 InsetRect( &dest, 2, 2 );

Here’s our call to CopyBits(). Since this first call is just intended to get the background pixels down to the lower-right rectangle, we’ll use the srcCopy transfer mode.


/* 31 */
 CopyBits( (BitMap *)&(((CGrafPtr)window)->portPixMap),
   (BitMap *)&(((CGrafPtr)window)->portPixMap),
   &source, &dest, srcCopy, NULL );

Now we’ll copy the Source rectangle down to the lower-right rectangle, overwriting what we just copied with the previous call to CopyBits(). The results will change, depending on the transfer mode in gCopyMode. The transfer modes are described in Inside Macintosh: Volume V, Inside Macintosh: Imaging, and in THINK Reference, but I think the best description by far is in IM: Imaging. If you plan on working with color to any great extent, pick up IM: Imaging and check out IM: Advanced Imaging (not for most folks).


/* 32 */
 source = gSrcRect;
 InsetRect( &source, 2, 2 );
 
 CopyBits( (BitMap *)&(((CGrafPtr)window)->portPixMap),
 (BitMap *)&(((CGrafPtr)window)->portPixMap),
 &source, &dest, gCopyMode, NULL );
}

The color ramp stuff is kind of interesting. Instead of using the red, green, blue color model, we depend on the hue, saturation, and brightness model. We vary the hue from 0 to 65535 with the resolution determined by width, in pixels, of the specified rectangle.


/* 33 */
DrawColorRamp
void  DrawColorRamp( Rect *rPtr )
{
 long   numColors, i;
 HSVColor hsvColor;
 RGBColor rgbColor;
 Rect   r;
 
 r = *rPtr;

We inset the rectangle by 2 pixels so we don’t draw on the rectangle’s frame. Interestingly, hue is hue, saturation is saturation, but for some reason, brightness is represented by the field named value. Hmmm... Oh, well. As you can see, our color ramp will consist of bright, saturated colors. Try rewriting the code to ramp on saturation or brightness instead.


/* 34 */
 InsetRect( &r, 2, 2 );
 numColors = ( rPtr->right - rPtr->left - 2 ) / 2;
 hsvColor.value = hsvColor.saturation = 65535;

Here’s the ramping loop. HSV2RGB() converts an HSV color to an RGB color, which produces something we can pass to RGBForeColor(). Why isn’t there an HSVForeColor() routine? I don’t know, but I wish there were.


/* 35 */
 for ( i = 0; i < numColors; i++ )
 {
 hsvColor.hue = i * 65535 / numColors;
 HSV2RGB( &hsvColor, &rgbColor );
 RGBForeColor( &rgbColor );

Each time through the loop, we draw a 1 pixel wide rectangle, then shrink the rectangle in preparation for the next pass through the loop.


/* 36 */
 FrameRect( &r );
 InsetRect( &r, 1, 1 );
 }
}

DrawGrayRamp() does essentially the same thing, but stays within the RGB model.


/* 37 */
DrawGrayRamp
void  DrawGrayRamp( Rect *rPtr )
{
 long   numColors, i;
 RGBColor rgbColor;
 Rect   r;
 
 r = *rPtr;
 InsetRect( &r, 2, 2 );
 numColors = ( rPtr->right - rPtr->left - 2 ) / 2;

In this case, we run red from 0 to 65535, with a step resolution based on the width 
of the rectangle. We then copy the red value into both green and blue, producing progressively 
lighter shades of gray.

 for ( i = 0; i < numColors; i++ )
 {
 rgbColor.red = i * 65535 / numColors;
 rgbColor.green = rgbColor.red;
 rgbColor.blue = rgbColor.red;
 
 RGBForeColor( &rgbColor );
 
 FrameRect( &r );
 InsetRect( &r, 1, 1 );
 }
}

In real life, this routine shouldn’t be necessary. We really should be using the popup menu CDEF that’s been around for several years. The problem is, ResEdit has a bug in it that makes the CDEF very difficult to set up properly. I’m not sure if the problem lies with ResEdit or with the CDEF, but just to avoid the problem, here’s the old way of doing popups. What this really needs is that nifty down-pointing triangles that you usually see in popups, but I ran out of time. Aside from spending the money for Resorcerer (a good investment, IMHO), does anyone have a workaround that brings the popup CDEF under control (sorry!!) in ResEdit?


/* 38 */
DrawLabel
void  DrawLabel( Rect *boundsPtr, Str255 s )
{
 Rect r;
 int    size;
!co1deexampleend

This code basically draws a poor imitation of a popup menu label, using StringWidth() 
to calculate the proper centering position in the label.

/* 39 */
 r = *boundsPtr;
 r.bottom -= 1;
 r.right -= 1;
 FrameRect( &r );
 
 MoveTo( r.left + 1, r.bottom );
 LineTo( r.right, r.bottom );
 LineTo( r.right, r.top + 1 );
 
 size = boundsPtr->right - boundsPtr->left - StringWidth(s);
 MoveTo( boundsPtr->left + size / 2, boundsPtr->bottom - 6);
 
 DrawString( s );
}

When we get a click in the content region of the window, DoContent() takes a global mouse position and converts it to the local coordinate system. I probably should have added a SetPort() call to make sure that window was the current window before I called GlobalToLocal(). Since there’s only one window, this won’t cause any harm here, but be sure to add the SetPort() if you reuse this code.


/* 40 */
DoContent
void  DoContent( WindowPtr window, Point globalPoint )
{
 int    choice;
 ControlHandle control;
 RGBColor rgbColor;
 Point  p;
 
 p = globalPoint;
 GlobalToLocal( &p );

If the click was in a control, we’ll call TrackControl() to track the mouse till the button is released.


/* 41 */
 if ( FindControl( p, window, &control ) )
 {
 if ( TrackControl( control, p, NULL ) )
 {

If the mouse was released inside the control, we know it was in the OpColor... push-button. We’ll call PickColor() to put up the standard Mac color picker.


/* 42 */
 rgbColor = gOpColor;
 
 if ( PickColor( &rgbColor ) )
 {

If the user clicked the OK button to pick a new opColor, we’ll force an update and set the new opColor.


/* 43 */
 gOpColor = rgbColor;
 
 InvalRect( &gOpColorRect );
 InvalRect( &gDestRect );
 
 OpColor( &gOpColor );
 }
 }
 }

If the click was in the source menu, we’ll update the check marks, then call DoPopup() to popup the menu. If an item is chosen from the menu, we’ll pass the item to DoSrcChoice(), then force an update.


/* 44 */
 else if ( PtInRect( p, &gSrcMenuRect ) )
 {
 UpdateSrcMenu();
 
 choice = DoPopup( gSrcMenu, &gSrcMenuRect );
 
 if ( choice > 0 )
 {
 DoSrcChoice( choice );
 
 InvalRect( &gSrcRect );
 InvalRect( &gDestRect );
 }
 }

If the click was in the background or mode menus, we’ll follow the same plan, with calls to DoBackChoice() or DoModeChoice() as a result.


/* 45 */
 else if ( PtInRect( p, &gBackMenuRect ) )
 {
 UpdateBackMenu();
 
 choice = DoPopup( gBackMenu, &gBackMenuRect );
 
 if ( choice > 0 )
 {
 DoBackChoice( choice );
 
 InvalRect( &gBackRect );
 InvalRect( &gDestRect );
 }
 }
 else if ( PtInRect( p, &gModeMenuRect ) )
 {
 UpdateModeMenu();
 
 choice = DoPopup( gModeMenu, &gModeMenuRect );
 
 if ( choice > 0 )
 {
 DoModeChoice( choice );
 
 InvalRect( &gDestRect );
 }
 }
}

UpdateSrcMenu() starts by unchecking all its items.


/* 46 */
UpdateSrcMenu
void  UpdateSrcMenu( void )
{
 int    i;
 
 for ( i = 1; i <= 6; i++ )
 CheckItem( gSrcMenu, i, false );

Next, it uses globals to decide which items should be checked.


/* 47 */
 if ( gSrcPattern == iBlackPattern )
 CheckItem( gSrcMenu, iBlackPattern, true );
 else
 CheckItem( gSrcMenu, iGrayPattern, true );
 
 if ( gSrcType == iColorRamp )
 CheckItem( gSrcMenu, iColorRamp, true );
 else if ( gSrcType == iGrayRamp )
 CheckItem( gSrcMenu, iGrayRamp, true );
 else if ( gSrcType == iSingleColor )
 CheckItem( gSrcMenu, iSingleColor, true );
}

UpdateBackMenu() does the same thing as UpdateSrcMenu().


/* 48 */
UpdateBackMenu
void  UpdateBackMenu( void )
{
 int    i;
 
 for ( i = 1; i <= 6; i++ )
 CheckItem( gBackMenu, i, false );
 
 if ( gBackPattern == iBlackPattern )
 CheckItem( gBackMenu, iBlackPattern, true );
 else
 CheckItem( gBackMenu, iGrayPattern, true );
 
 if ( gBackType == iColorRamp )
 CheckItem( gBackMenu, iColorRamp, true );
 else if ( gBackType == iGrayRamp )
 CheckItem( gBackMenu, iGrayRamp, true );
 else if ( gBackType == iSingleColor )
 CheckItem( gBackMenu, iSingleColor, true );
}

UpdateModeMenu() starts off the same way, by unchecking the mode menu.


/* 49 */
UpdateModeMenu
void  UpdateModeMenu( void )
{
 int    i;
 
 for ( i = 1; i <= 17; i++ )
 CheckItem( gModeMenu, i, false );

To understand this next chunk of code, take a look at the definition of the transfer modes in <Quickdraw.h>. The first 8 transfer modes are defined by an enum as 0 through 7 and correspond to items 1 through 8 in the Mode menu. The next 8 transfer modes are enum’ed as 32 through 39.


/* 50 */
 if ( ( gCopyMode >= 0 ) && ( gCopyMode <= 7 ) )
 CheckItem( gModeMenu, gCopyMode + 1, true );
 else
 CheckItem( gModeMenu, gCopyMode - 22, true );
}

DoSrcChoice() and DoBackChoice() use their choices to update their globals. If Single Color... is selected, PickColor() is called to select a new color.


/* 51 */
DoSrcChoice
void  DoSrcChoice( short item )
{
 RGBColor rgbColor;
 
 switch ( item )
 {
 case iBlackPattern:
 case iGrayPattern:
 gSrcPattern = item;
 break;
 case iColorRamp:
 case iGrayRamp:
 gSrcType = item;
 break;
 case iSingleColor:
 gSrcType = iSingleColor;
 rgbColor = gSrcColor;
 
 if ( PickColor( &rgbColor ) )
 gSrcColor = rgbColor;
 break;
 }
}

DoBackChoice
void  DoBackChoice( short item )
{
 RGBColor rgbColor;
 
 switch ( item )
 {
 case iBlackPattern:
 case iGrayPattern:
 gBackPattern = item;
 break;
 case iColorRamp:
 case iGrayRamp:
 gBackType = item;
 break;
 case iSingleColor:
 gBackType = iSingleColor;
 rgbColor = gBackColor;
 
 if ( PickColor( &rgbColor ) )
 gBackColor = rgbColor;
 break;
 }
}

DoModeChoice() uses its selection to update gCopyMode.


/* 52 */
DoModeChoice
void  DoModeChoice( short item )
{
 if ( ( item >= 1 ) && ( item <= 8 ) )
 gCopyMode = item - 1;
 else
 gCopyMode = item + 22;
}

DoPopup() calls PopUpMenuSelect() to implement a popup menu.


/* 53 */
DoPopup
short DoPopup( MenuHandle menu, Rect *boundsPtr )
{
 Point  corner;
 long theChoice = 0L;
 
 corner.h = boundsPtr->left;
 corner.v = boundsPtr->bottom;
 
 LocalToGlobal( &corner );
 
 InvertRect( boundsPtr );
 
 theChoice = PopUpMenuSelect( menu, corner.v - 1, corner.h + 1, 0);
 
 InvertRect( boundsPtr );
 
 return( LoWord( theChoice ) );
}

PickColor() is just a wrapper for GetColor(). It sets up a Point with coordinates (-1, -1), which tells the Color Quickdraw routine GetColor() to center the Color Picker on the main screen.


/* 54 */
PickColor
Boolean PickColor( RGBColor *colorPtr )
{
 Point  where;
 
 where.h = -1;
 where.v = -1;
 
 return( GetColor( where, "\pChoose a color...", colorPtr,
 colorPtr ) );
}

HasColorQD() calls Gestalt() to see if Color Quickdraw is installed on this machine. If the third byte of the returned long is positive, Color Quickdraw is installed.


/* 55 */
HasColorQD
Boolean HasColorQD( void )
{
 unsigned char version[ 4 ];
 OSErr  err;
 
 err = Gestalt( gestaltQuickdrawVersion, (long *)version );
 
 if ( version[ 2 ] > 0 )
 return( true );
 else
 return( false );
}

DoError() is our standard error handling routine.


/* 56 */
DoError
void  DoError( Str255 errorString )
{
 ParamText( errorString, "\p", "\p", "\p" );
 
 StopAlert( kErrorALRTid, kNullFilterProc );
 
 ExitToShell();
}

Till Next Month

Try experimenting with the code. I especially like messing with different color and grayscale ramps. Try writing a program that blends two offscreen pixmaps on screen using different drawing modes. Try modifying ColorTutor so, as the cursor passes over a pixel, the RGB and HSV values are displayed. Change ColorTutor so it uses the popup CDEF instead of the old-style popups.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Tips and tricks to get a higher score in...
Snow Roll is a devilish endless runner very much in the vein of Flappy Bird. It revels in its dastardly level of difficulty, and doesn’t really care how angry you get at it as it knows you’ll keep coming back for more. [Read more] | Read more »
How to win big in Slots Deluxe
Cheating while gambling is illegal and morally wrong, and in some parts of the world it leads to men with names like Vinnie "Six Knuckles" Manchenzo beating you to a pulp in a dark alley. [Read more] | Read more »
How to take over the world in Dictator 2
Running a country isn't easy - especially when you're a dictator who wants to take over the world and crush everyone in your path while you do it. [Read more] | Read more »
Tips and tricks to get a higher score in...
Tank.iois - you guessed it! - another multiplayer arena battler likeAgar.io and Slither.io. It does differentiate itself by putting you in a tiny tank though, so it's not exactly the same. To help you get that all-important high score, we've got a... | Read more »
How to unlock characters in One Tap Tenn...
As the title suggests, One Tap Tennis requires only a single tap to play its particular brand of tennis, and rewards you with a ton of unlockable characters if you perform well. Fortunately for you, we at 148Apps have got a few tips and tricks to... | Read more »
Grab it now: Game Craft’s Legend of War...
The real time strategy game is now available for you to sink your teeth into, through the App Store and Google Play. Combining elements of skill, strategy and empire building, Legend of War is a real gamers’ game. [Read more] | Read more »
Skateboard Party 3 ft. Greg Lutzka (Gam...
Skateboard Party 3 ft. Greg Lutzka 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: Skateboard Party is back! This third edition of the popular sports franchise features professional skater... | Read more »
Cubious (Games)
Cubious 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: Cubious – How smart are you? How high is your IQube? Solve the impossible puzzles to find out, and help a lost little cube find his... | Read more »
Goat Simulator Waste of Space (Games)
Goat Simulator Waste of Space 1.1 Device: iOS Universal Category: Games Price: $4.99, Version: 1.1 (iTunes) Description: ** IMPORTANT - SUPPORTED DEVICESiPhone 4S, iPad 2, iPod Touch 5 or better.** | Read more »
Wildfulness - Unwind in nature and calm...
Wildfulness - Unwind in nature and calm your mind with nature sounds and illustrations 1.0 Device: iOS Universal Category: Healthcare & Fitness Price: $1.99, Version: 1.0 (iTunes) Description: Spending time in nature helps you to... | Read more »

Price Scanner via MacPrices.net

Enterprise Workers Pick Technology Over Perks...
New Adobe study shows surprising attitudes about office jobs and where the future of work is heading. Adobe has released survey findings revealing that a surprising 70 percent of U.S. office workers... Read more
Goal Zero and OtterBox Partner to Expand iPh...
Goal Zero, specialists in portable power, have announced a partnership with OtterBox, brand smartphone case protection, to offer the Slide and Slide Plus Batteries as modules compatible with the new... Read more
15-inch Retina MacBook Pros on sale for up to...
B&H Photo has 15″ Retina MacBook Pros on sale for up to $210 off MSRP. Shipping is free, and B&H charges NY tax only: - 15″ 2.2GHz Retina MacBook Pro: $1799 $200 off MSRP - 15″ 2.5GHz Retina... Read more
Clearance 2015 13-inch MacBook Airs available...
B&H Photo has clearance 2015 13″ MacBook Airs available for $250 off original MSRP. Shipping is free, and B&H charges NY sales tax only: - 13″ 1.6GHz/4GB/128GB MacBook Air (MJVE2LL/A): $799... Read more
Apple refurbished Apple TVs available for up...
Apple has Certified Refurbished 32GB and 64GB Apple TVs available for up to $30 off the cost of new models. Apple’s standard one-year warranty is included with each model, and shipping is free: -... Read more
21-inch iMacs on sale for up to $120 off MSRP
B&H Photo has 21″ iMacs on sale for up to $120 off MSRP including free shipping plus NY sales tax only: - 21″ 3.1GHz iMac 4K: $1379.99 $120 off MSRP - 21″ 2.8GHz iMac: $1189 $110 off MSRP - 21″ 1... Read more
Kanex Introduces GoPower USB-C Rechargeable B...
Kanex has announced its GoPower USB-C portable battery for the USB-C MacBook, featuring the new industry standard connector and cable used for connectivity and power. Providing users with a new... Read more
Convertible and Detachable Devices Winning Ov...
According to the latest figures published by International Data Corporation (IDC), Western European shipments of ultraslim convertibles and detachables posted positive growth (44.7%) to account for... Read more
New MacBook Pros And Will MacBook Air Be Upgr...
With my mid-2013 13-inch MacBook Air closing on its third anniversary come November, I’m in system upgrade mode. Actually the Haswell CPU equipped Air is still doing a fine job, but my good wife is... 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, and... Read more

Jobs Board

*Apple* Project Engineer - Smart Source Inc...
SmartSource is in need of an Apple Project Engineer for a 12 month contract opportunity in Pittsburg, PA. Role: Apple Project Engineer Location: Pittsburg, PA Read more
Automotive Sales Consultant - Apple Ford Linc...
…you. The best candidates are smart, technologically savvy and are customer focused. Apple Ford Lincoln Apple Valley is different, because: $30,000 annual salary Read more
Service Assistant - *Apple* Chevrolet *App...
Apple Automotive is one of the fastest growing dealer...and it shows. Consider making the switch to the Apple Automotive Group today! At Apple Automotive, we Read more
Editor, *Apple* News - APPLE (United States...
Job Summary The Apple News team is looking for a passionate and knowledgeable editor with experience covering entertainment/pop culture and experience running social Read more
*Apple* Nissan Service Technicians - Apple A...
Apple Automotive is one of the fastest growing dealer...and it shows. Consider making the switch to the Apple Automotive Group today! At Apple Automotive , Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.