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

Luminar 1.0.2 - Powerful, adaptive, conf...
Luminar is the new full-featured image editor that adapts to the way you edit photos. Over 300 essential tools to fix, edit, and enhance your photos with comfort. The future of photo editing is here... Read more
Slack 2.3.3 - Collaborative communicatio...
Slack is a collaborative communication app that simplifies real-time messaging, archiving, and search for modern working teams. Version 2.3.3: Fixed window zoom jumping back-and-forth OS X 10.9... Read more
WhatRoute 2.0.10 - Geographically trace...
WhatRoute is designed to find the names of all the routers an IP packet passes through on its way from your Mac to a destination host. It also measures the round-trip time from your Mac to the router... Read more
Luminar 1.0.2 - Powerful, adaptive, conf...
Luminar is the new full-featured image editor that adapts to the way you edit photos. Over 300 essential tools to fix, edit, and enhance your photos with comfort. The future of photo editing is here... Read more
WhatRoute 2.0.10 - Geographically trace...
WhatRoute is designed to find the names of all the routers an IP packet passes through on its way from your Mac to a destination host. It also measures the round-trip time from your Mac to the router... Read more
Slack 2.3.3 - Collaborative communicatio...
Slack is a collaborative communication app that simplifies real-time messaging, archiving, and search for modern working teams. Version 2.3.3: Fixed window zoom jumping back-and-forth OS X 10.9... Read more
Lens Blur 1.4.3 - True out-of-focus boke...
Lens Blur transforms your existing photo into true SLR-quality out-of-focus bokeh effect! Everyone needs a gorgeous personalized background for a social profile, blog, Web/UI design, presentation, or... Read more
CleanMyMac 3.6.0 - $39.95
CleanMyMac makes space for the things you love. Sporting a range of ingenious new features, CleanMyMac lets you safely and intelligently scan and clean your entire system, delete large, unused files... Read more
DEVONthink Pro 2.9.8 - Knowledge base, i...
DEVONthink Pro is your essential assistant for today's world, where almost everything is digital. From shopping receipts to important research papers, your life often fills your hard drive in the... Read more
MacFamilyTree 8.1 - Create and explore y...
MacFamilyTree gives genealogy a facelift: modern, interactive, convenient and fast. Explore your family tree and your family history in a way generations of chroniclers before you would have loved.... Read more

Latest Forum Discussions

See All

Amateur Surgeon 4 Guide: Become the worl...
It's time to wield your trusty pizza cutter again, as Amateur Surgeon has returned with a whole fresh set of challenges (and some old, familiar ones, too). Starting anew isn't easy, especially when all you have at your disposal is a lighter, the... | Read more »
Le Parker: Sous Chef Extraordinaire (Ga...
Le Parker: Sous Chef Extraordinaire 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: | Read more »
Telltale Games really is working on a Gu...
Telltale Games' next episodic adventure is indeed Guardians of the Galaxy. A document tied to the voice actors strike suggested that the project was in the work, but now we have direct confirmation following an announcement at the Game Awards that... | Read more »
Amateur Surgeon returns to iOS and Andro...
Amateur Surgeon and its two sequels disappeared from the App Store some time and it was sad days for all. But now, just in time for the holidays, the Adult Swim favorite makes its joyous return in the shape of Amateur Surgeon 4, a remake with... | Read more »
The best board games on mobile
Sometimes you need to ditch all of the high speed, high action games in favor of something a little more traditional. If you don't feel like parting ways from your mobile device, though, there are still plenty of ways to get that old-school fix.... | Read more »
The best Facebook Messenger Instant Game...
Facebook's new Instant Games is now here, meaning you can play games with your friends directly via Facebook. It's a fun new way to connect with friends, of course, but it's also proving to be a solid gaming experience in its own right, with a... | Read more »
You can now play game's on Facebook...
Facebook launched its new Instant Games platform in an exciting new attempt to engage its user base. As a result, you can now play a number of different games directly through Facebook Messenger. All of these games run with HTML5, meaning you play... | Read more »
Apollo Justice Ace Attorney (Games)
Apollo Justice Ace Attorney 1.00.00 Device: iOS Universal Category: Games Price: $.99, Version: 1.00.00 (iTunes) Description: Court Is Back In Session Star as rookie defense attorney, Apollo Justice, as he visits crime scenes,... | Read more »
KORG iWAVESTATION (Music)
KORG iWAVESTATION 1.0 Device: iOS Universal Category: Music Price: $19.99, Version: 1.0 (iTunes) Description: A revolutionary new world of sound.The Wave Sequence Synthesizer for iPad - KORG iWAVESTATION | Read more »
Don't Grind Guide: Tips for becomin...
Don’t Grind is a surprising, derpy little one touch game with fun hand-drawn graphics. The goal is simple -- get the high score without being chopped to bits. That can be tough when you’re not used to the game, and that’s compounded by the fact... | Read more »

Price Scanner via MacPrices.net

Parallels Toolbox 1.3 for Mac Offers 25 Singl...
Parallels has launched Parallels Toolbox 1.3 for Mac, an upgrade that adds five new utilities to the stand-alone application which was released in August and is available exclusively online at http... Read more
OWC Mercury Elite Pro Dual mini Ultra-Portabl...
OWC has introduced the new OWC Mercury Elite Pro Dual mini, a powerful yet ultra-portable dual-drive RAID solution. The new Mercury Elite Pro Dual mini packs phenomenal performance into a small... Read more
Clearance 13-inch Retina MacBook Pros availab...
B&H Photo has clearance 2015 13″ Retina Apple MacBook Pros available for up to $200 off original MSRP. Shipping is free, and B&H charges NY tax only: - 13″ 2.7GHz/128GB Retina MacBook Pro: $... Read more
Roundup of 2016 13-inch 2.0GHz MacBook Pro sa...
B&H has the non-Touch Bar 13″ MacBook Pros in stock today for $50-$100 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 13″ 2.0GHz MacBook Pro Space Gray (MLL42LL/A): $1449 $... Read more
New 13-inch 2.0GHz Space Gray MacBook Pro in...
Adorama has the new 13″ 2.0GHz Space Gray MacBook Pro (non-Touch Bar, MLL42LL/A) in stock for $1499 including a free 3-year AppleCare Protection Plan. Shipping is free, and Adorama charges sales tax... Read more
Finnair Adopts iOS Enterprise iPad Apps from...
Finnair and IBM have announced a first-of-its-kind agreement to utilize iOS enterprise apps from IBM to support the airline’s overall digital transformation. Finnair is focused on Asia-Europe traffic... Read more
Tech21 Launches Evo Go iPhone 7 Case Availabl...
Tech21 has announced the launch of the Evo Go case for Apple iPhone 7 and iPhone 7 Plus, exclusively at T-Mobile. Available online and at participating T-Mobile stores nationwide, Evo Go cases start... Read more
Apple Turns (RED) with More Ways to Join the...
In recognition of World AIDS Day, Apple is offering more ways than ever for customers to join (RED) in its mission to create an AIDS-free generation. Apple is the worlds largest corporate contributor... Read more
Deals on new 15-inch Touch Bar MacBook Pros,...
B&H Photo has new 2016 Apple 15″ Touch Bar MacBook Pro models in stock today with some available for $50 off MSRP, each including free shipping plus NY sales tax only: - 15″ 2.7GHz Touch Bar... Read more
12-inch Retina MacBooks on sale for up to $10...
12-inch Retina MacBooks remain on sale at B&H Photo with models available for up to $100 off MSRP. Shipping is free, and B&H charges NY sales tax only. B&H will also include a free copy... Read more

Jobs Board

*Apple* Retail - Multiple Positions- White P...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Automotive Detailer - *Apple* Used Autos -...
We are currently conductinginterviews and will be accepting applications for a part-time detailer. Apple Used Autos is a great place to work andstart a career. We Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
US- *Apple* Store Leader Program - Apple (Un...
…Summary Learn and grow as you explore the art of leadership at the Apple Store. You'll master our retail business inside and out through training, hands-on Read more
*Apple* & PC Desktop Support Technician...
Apple & PC Desktop Support Technician job in Dallas TX Introduction: We have immediate job openings for several Desktop Support Technicians with one of our most Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.