TweetFollow Us on Twitter

Convert Pict2Rgn
Volume Number:5
Issue Number:6
Column Tag:Assembly Lab

Related Info: Quickdraw Window Manager

Convert PICTs to Regions

By Ted Cohn, San Jose, CA

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

[Ted Cohn has been a long-time Mac enthusiast and used to be an Apple ][ hacker. He wrote a professional 6502 debugger for the Apple ][ called Bugbyter which Apple sold with its ProDOS assembly package. He graduated from UC Berkeley with a B.A. in Computer Science. Since then he has been working at Radius Inc., where he designed and wrote Tear-off Menus and a real-time magnifier for the Radius Two Page Display.]

Quickdraw Regions What’s This All About?

Have you ever used a region? If so, have you ever tried creating irregularly-shaped ones? A year ago I wanted to write a desk accessory that would require several strangely-shaped regions. Unfortunately, I found no simple way to create them with the routines Quickdraw provides. Creating a region in Quickdraw is procedural: You must call OpenRgn, draw lines, rectangles, ovals, etc., and then call CloseRgn to define a region’s boundary. This can be a tedious, almost unbearable process if you want to create bizarre regions by having to combine simple geometric shapes. My goal was to find a way to create regions in a non-procedural manner by drawing them with a standard paint program. Although Quickdraw does provide some useful functions like UnionRgn, DiffRgn, SectRgn and XorRgn, it does not provide a routine to convert a bitmap into a region - a routine I believe should be standard Quickdraw equipment.

The question arose: how do I turn a bitmap into a region? One could develop an algorithm to trace the edges of the bitmap and use Quickdraw to add each point individually to the region’s boundary, but that seemed a bit primitive. The only way to find an efficient algorithm was to first understand the region structure itself. And as many already know, Apple has never divulged the region’s structure - certainly cause for some fun detective work. I became sidetracked by this fascinating data structure.

The following explains the region format and my solution to the problem of region creation. Listed afterwards is MakeRgn, an assembly function to convert a bitmap into a Quickdraw region, and Pict2Rgn, an MPW tool which utilizes MakeRgn to convert ‘PICT’ resources to ‘RGN ’ resources.

Let There Be Light!

This is what Apple thinks we ought to know about regions:

rgnSize:  Integer;
rgnBBox:  Rect;
rgnData:  Mystery;

Inside Mac, page I-141, states, “A region can be concave or convex, can consist of one area or many disjoint areas, and can even have ‘holes’ in the middle.” A region specifies exactly which pixels lie inside and outside of a closed boundary. So, how does a region represent this boundary? Inside Mac describes only the header of the region structure, rgnSize and rgnBBox, which are not very interesting. RgnSize specifies the total number of bytes in the region data structure while rgnBBox contains the region’s bounding rectangle. This is the smallest rectangle that will completely enclose the region, that is, each edge of the rectangle will touch at least one point of the region’s boundary. It seems, however, that rgnData was left as an exercise to the developer - a complete mystery and a nagging curiosity.

Now let’s get technical. It turns out that the rgnData structure is not as complex as it might seem. A region is like a bitmap in that it is arranged into scanlines and is read from left to right, top to bottom. This makes sense since regions are used to “mask” bitmaps which are also read from left to right, top to bottom. But instead of containing pixel data, the region need only contain boundary information.

Figure 1a is a doughnut-shaped picture we would like to convert into a region. Let’s step through the conversion process. If we restrict ourselves to the horizontal dimension for the moment, we can isolate the boundary pixels of this bitmap by taking the exclusive-OR of itself with its right-shifted copy. Figure 1b is the result of this process. Notice that pixels which begin a horizontal line segment remain (pixel [5,0] for instance). The remaining pixels of each line segment are lost, but we gain an extra pixel at the end of the line segment. This additional pixel appears because of the XOR function and signifies the end of the segment. Therefore, in the horizontal dimension, two pixels are used to define the line segment.

Now we could use horizontal information alone to define the boundary, but we would have to store every scanline of the region. This would be extremely wasteful in cases where many contiguous lines are the same (as with large rectangular windows). Notice in Figure 1b that lines three and four are equal, lines six through eight are equal, and lines ten through eleven are equal.

Redundant information in the vertical dimension is eliminated by taking an additional XOR of the bitmap in Figure 1b, except, we take the XOR of the bitmap with its down-shifted copy. Each scanline is replaced by an XOR of itself with the previous line. Figure 1c shows the result of this second XOR. Notice that lines four, seven, eight and eleven are now blank. This means that only the first line of a run of equal lines is necessary to define them all.

The Quickdraw region is basically a list of the points (represented by black pixels) in Figure 1c. These points are called “inversion points.” Why? Well, if we were to read a scanline from left to right, they would essentially invert the state of being inside or outside of the region. Unfortunately, this definition is not completely accurate. There is a little more to inversion points than meets the eye. One must realize that no single line of inversion points (except for the first line) can reliably specify which pixels lie inside or outside of a particular line’s boundary. Because the region is not a random access data structure like a bitmap, it must be “played back,” line by line, starting from the top. The first line of inversion points defines the line segment(s) of the top line, but inversion points of successive lines do not directly inform us of the region’s boundary. Boundary information provided by inversion points trickles down each line as the region is processed. This boundary information comes in the form of horizontal “markings” which are set and cleared by inversion points. An inversion point on one line can cancel out a mark made by an inversion point from a previous line.

To illustrate, let’s unravel the boundary of the second line of Figure 1c. The line segment defined on the first line is assumed to be the same for the second line, so marks [5] and [10], which were set, carried through. The second line contains four inversion points: [3,1], [5,1], [10,1] and [12,1]. Inversion point [3,1] defines the new starting point of the line segment. Point [5,1] cancels mark [5] made by the previous inversion point [5,0] so the line segment will not end at point [5,1]. The line segment might also have ended at point [10,1] if it were not for the inversion point [10,1] telling us to cancel mark [10]. The line segment then ends at point [12,1]. For line three, only two marks carry through: [3] and [12]. The other two were canceled out.

During runtime, these marks are stored in the form of an internalized bitmapped line. The bitmapped line is modified from the inversion points that are read in and can be conveniently used to plot the bits of the region on the screen or mask a bitmap in CopyBits.

At this point, let me spell out the rgnData structure in detail. RgnData is a list of two or more scanlines. Each scanline begins with its vertical coordinate. (Every coordinate in the structure is a word in length.) Inversion points are then listed from left to right by entering their horizontal coordinates one after another. Note that there are always an even number of inversion points per scanline because the region is closed. An end mark, $7FFF, terminates the scanline. The remaining scanlines come one after another, each starting with its vertical coordinate. When there are no more scanlines remaining, a final end mark, $7FFF, terminates the rgnData structure. Figure 2 shows the entire Quickdraw region data corresponding to the inversion points of Figure 1c.

MakeRgn Joins the Quickdraw Family

Since it is desirable to draw a region with a paint program, we define the region in bitmap form such that all black pixels in a bitmap are logically included in the region and all white pixels are logically excluded. MakeRgn (Listing 1) follows the process outlined above in converting this bitmap to Quickdraw region format. MakeRgn first does a horizontal XOR with its righted shifted copy and then does a vertical XOR with its down-shifted copy. We could take the vertical XOR first; the order doesn’t matter. This produces a bitmap with inversion points whose coordinates are entered into the rgnData structure. MakeRgn will create and return the region handle, so don’t call NewRgn first. If MakeRgn is provided with an empty bitmap, it will return an empty region. It does not handle Memory Manager errors. If you are concerned about heap space, you can test to see if there exists a free block which is about one hundred bytes larger than your source bitmap. The rgnSize and rgnBBox fields will be calculated and filled in too. The coordinates of the rgnBBox will reflect the bitmap’s bounds rectangle and the location of the region within it.

Tools of the Trade

Pict2Rgn, an MPW Tool shown in Listing 2, lets one convert ‘PICT’ resources into ‘RGN ’ resources. Listing 3 is the make file associated with Pict2Rgn. To use it, place ‘PICT’ resources into a resource file and execute Pict2Rgn with that file name. It will convert each picture and add its corresponding ‘RGN ’ resource to that file with the same ID and name as the source ‘PICT’. The program does not check to see if the resource file already contains regions with the same ID’s, so make sure it is clear of ‘RGN ’ resources before converting pictures. Pict2Rgn demonstrates how to open a GrafPort and draw a picture into that port. Once drawn, the conversion to region format is done by calling MakeRgn with a pointer to the GrafPort’s bitmap.

A nice extension to this tool might be a Region Editor that would allow one to graphically manipulate regions and apply Quickdraw functions to them. Another would be a Control Editor to let one create interesting new controls for dialog boxes. The basic method outlined in Pict2Rgn should be helpful in writing your own utility or package to use MakeRgn.

A Tidbit: What a Drag

If you are interested in dragging outlines of regions, there is a faster way than calling FrameRgn continuously. First, make a copy of the region, then InsetRgn(theRgnCopy, 1, 1) and DiffRgn(theRgn, theRgnCopy, theRgn) to create a region outline. Then call PaintRgn(theRgn) to drag the region outline around. FrameRgn is slow because it performs this same process every time it is called.

Any Alternatives?

Not surprisingly, bitmaps can be used to represent boundaries too. Like our definition above, we can say that black pixels in a bitmap represent the interior of the boundary. Depending on the complexity of the boundary, a bitmap can be considerably smaller in size than its equivalent Quickdraw region. The region data in Figure 2 is 156 bytes long, whereas the bitmap in Figure 1 is only 30 bytes long! This is because each inversion point requires entire word of storage. If there is more than approximately one inversion point per word of pixel data, then it is more space efficient to use a bitmap to represent the region. Still, Quickdraw regions are perfect for use by the Window Manager because the regions manipulated are usually rectangular and generally large requiring at most several hundred bytes. (Imagine Quickdraw using entire bitmaps just for region manipulation!) Thus, the larger, less complex the region, the more space efficient it is compared to its bitmap equivalent. On an historical note, region data was originally compressed by Quickdraw. Regions were generally around one third the size they would be today, but region manipulation was slower because of the on-the-fly compression/decompression. Region compression was removed before shipping the 128K Mac. While I don’t prefer a larger region structure, I think Apple was wise in opting for speed in the windowing environment - especially now that we have megabyte systems instead of 128K Macs to contend with.

Region Wrap-up

I hope this utility helps promote the creation of regions for new controls and windows. While user interface standards are important, I think a little variation wouldn’t hurt. As to Apple’s changing the region format in the future, I have this to say: It is easier to design regions non-procedurally than procedurally. If the format changes, another routine can be easily created to convert a bitmap into a region. In the future, I hope Apple will add a similar conversion routine to its graphics repertoire. If you use MakeRgn, I would be most interested in hearing about it. My AppleLink address is D0959. Happy Macing!

Listing 1. MakeRgn assembly code.

;------------------------------------------------------------------
;MakeRgn.a
;
;Written by Ted Cohn, March 1987.
;Copyright 1988 By Ted Cohn.
;
;MakeRgn converts a bitmap image into a Quickdraw region.
;Black pixels are logically included in the resultant region whereas
;white pixels are not included.  No special conditions required
;of the bitmap - it may be arbitrarily complex.  Empty bitmap will
;simply yield an empty region. rgnBBox of resultant rgn may
;be smaller than initial bitmap bounds if image does not use
;full extent of the bitmap.  rgnBBox will be smallest rect
;enclosing the resultant region.
;
;Algorithm Summary:
;
;The idea behind the conversion is simple.  The key is in finding 
;inversion points of the picture which define the region.  A 
;source bitmap is first XOR’d with its right-shifted copy.  
;resultant bitmap is then XOR’d with its down-shifted copy.  
;produces a set of inversion points which define the region 
;boundary.  next step is to take these points within final 
;bitmap and convert them to Quickdraw region format.
;
;  FUNCTION  MakeRgn(srcMap: Bitmap): RgnHandle;
;
;Modification History:
;
;  25 Mar 87    New Today.
;  26 Mar 87    Ironed out those bugs!
;  30 Mar 87    Changed to a Pascal function.
;  28 Mar 88    Optimized and reduced code.
;------------------------------------------------------------------

 MACHINEMC68000
 
 INCLUDE‘Traps.a’
 INCLUDE‘QuickEqu.a’

ENDMARK EQU $7FFF; end of rgn/line mark [word].

; MakeRgn’s stack frame:

MRFrame RECORD {A6Link},DECR
dstRgn  DS.L1  ; output region [RgnHandle].
srcMap  DS.L1  ; source bitmap [Ptr].
Return  DS.L1  ; return address [Ptr].
A6Link  DS.L1  ; old A6 value [long].
srcRect DS.B8  ; temporary [Rect].
dstRect DS.B8  ; temporary [Rect].
rgnMap  DS.B14 ; temp bitmap [BitMap].
VarSize EQU *  ; size of local variables.
 ENDR

MakeRgn PROCEXPORT
 WITH MRFrame
 LINK A6,#VarSize; create local stack frame.
 MOVEM.LA1-A3/D0-D7,-(SP) ; save working registers.
 MOVE.L srcMap(A6),A3; load ptr to source bitmap.
 MOVEQ  #0,D0  ; clear for multiplying.
 MOVEQ  #0,D4  ; use D4 for faster clears.
 MOVE.W rowBytes(A3),D7 ; load srcMap rowBytes.
;
; Find number of lines in source bitmap.  The rgnMap will have
; the same number of lines plus one and two more rowbytes.
;
 MOVE.W bounds+bottom(A3),D0; load srcMap bottom.
 SUB.W  bounds+top(A3),D0 ; height = bottom-top.
 ADDQ.W #1,D0  ; height++.
 ADDQ.W #2,D7  ; rowBytes += 2.
;
; Fill in rgnMap rowBytes and baseAddr fields.  Allocate
; memory for the temporary rgnMap image buffer.
;
 MOVE.W D7,rgnMap+rowBytes(A6); store new rowBytes.
 MULU D7,D0 ; calculate bitmap size.
 _NewPtr ,clear  ; create rgnMap image buffer.
 MOVE.L A0,rgnMap+baseAddr(A6); store start of buffer.
;
; rgnMap’s bounds will be one pixel larger to the right and bottom.
;
 MOVE.L bounds+topLeft(A3),D0 ; get original bitmap bounds.
 MOVE.L bounds+botRight(A3),D1
 ADDQ.W #1,D1  ; right++.
 MOVE.L D0,rgnMap+bounds+topLeft(A6)
 MOVE.L D1,rgnMap+bounds+botRight(A6)
 ADDQ.W #1,rgnMap+bounds+bottom(A6)
;
; Now make right-shifted copy in rgnMap.
;
 ADDQ.W #1,D0  ; left++.
 MOVE.L D0,dstRect+topLeft(A6); dstRect is right-shifted one.
 MOVE.L D1,dstRect+botRight(A6)
 MOVE.L A3,-(SP) ; srcBits = srcMap.
 PEA  rgnMap(A6) ; dstBits = rgnMap.
 PEA  bounds(A3) ; srcRect = srcMap.bounds.
 PEA  dstRect(A6); dstRect.
 MOVE.W D4,-(SP) ; srcCopy mode.
 MOVE.L D4,-(SP) ; no maskRgn.
 _CopyBits
;
; XOR srcMap with right-shifted copy rgnMap & store in rgnMap.
;
 MOVE.L A3,-(SP) ; srcBits = srcMap.
 PEA  rgnMap(A6) ; dstBits = rgnMap.
 PEA  bounds(A3) ; srcRect = srcMap.bounds.
 PEA  bounds(A3) ; dstRect = srcMap.bounds.
 MOVE.W #srcXor,-(SP); srcXor mode.
 MOVE.L D4,-(SP) ; no maskRgn.
 _CopyBits
;
; XOR rgnMap with down-shifted copy of rgnMap.
;
 MOVE.L rgnMap+bounds+topLeft(A6),srcRect+topLeft(A6)
 MOVE.L rgnMap+bounds+botRight(A6),srcRect+botRight(A6)
 MOVE.L srcRect+topLeft(A6),dstRect+topLeft(A6)
 MOVE.L srcRect+botRight(A6),dstRect+botRight(A6)
 SUBQ.W #1,srcRect+bottom(A6)
 ADDQ.W #1,dstRect+top(A6)
 PEA  rgnMap(A6) ; srcBits = rgnMap.
 PEA  rgnMap(A6) ; dstBits = rgnMap.
 PEA  srcRect(A6); srcRect = top rectangle.
 PEA  dstRect(A6); dstRect = down-shift one.
 MOVE.W #srcXor,-(SP); srcCopy mode.
 MOVE.L D4,-(SP) ; no maskRgn.
 _CopyBits
;
; We’ve exposed the inversion points of the picture.  Time to
; count the number of rows and black pixels in the rgnMap to determine
; the size of the RgnHandle we will soon fill in.
;
 MOVE.L rgnMap+baseAddr(A6),A0; start at topLeft of bitmap.
 LSR.W  #1,D7  ; rowWords = rowBytes/2.
 SUBQ.W #1,D7  ; loop rowWords times.
 MOVE.W rgnMap+bounds+top(A6),D1 ; current Y coordinate.
 MOVE.W rgnMap+bounds+bottom(A6),A1; last Y coord. for end test.
 MOVEQ  #0,D5  ; row count = 0.
Count
 MOVE.W D7,D6  ; x loop on rowWords.
 MOVEQ  #0,D3  ; clear line flag.
@0
 MOVE.W (A0)+,D0 ; load next rgnMap word.
 BEQ.S  @2; skip blank words.
 TST.B  D3; is line flag already set?
 BNE.S  @1; yes --> skip.
 STD3 ; no --> set line flag.
 ADDQ.W #1,D5  ; row count++.
@1
 ADDQ.W #1,D4  ; add number of bits
 MOVE.W D0,D2  ; in rgnMap word to
 SUBQ.W #1,D2  ; total bit count.
 AND.W  D2,D0
 BNE.S  @1
@2
 DBRA D6,@0 ; loop if more words to read.
 ADDQ.W #1,D1  ; y++.
 CMP.W  D1,A1  ; y <= bottom?
 BGT.S  Count  ; yes --> loop.
;
; Determine size of new RgnHandle.
;
 TST.W  D5; was the rgnMap empty?
 BNE.S  BuildRgn ; no --> skip.
 SUBQ.W #4,SP  ; yes --> get new empty region.
 _NewRgn
 MOVE.L (SP)+,dstRgn(A6)  ; stuff result.
 BRA  Done; exit.
BuildRgn
;
; Calculate number of bytes to allocate for output region handle.
;
 MOVEQ  #12,D0 ; (12 for header & end mark.)
 ADD.W  D1,D1  ; (4*number of lines in map for
 ADD.W  D1,D1  ; each Y coordinate and
 ADD.W  D1,D0  ; end mark.)
 ADD.W  D4,D4  ; (2*number of inversion
 ADD.W  D4,D0  ; points in the entire map.)
 MOVE.W D0,D4  ; remember the region size.
 _NewHandle ,clear ; allocate a cleared RgnHandle.
 MOVE.L A0,dstRgn(A6); store handle in result.
;
; Translate rgnMap (containing inversion points) into Quickdraw Region
; format. We do not need to lock block because we will be making no
; trap calls which might rearrange the heap. DstRect will be used to
; help us find smallest enclosing rectangle for the region.
;
 MOVE.L (A0),A0  ; point to rgn data.
 MOVE.W D4,rgnSize(A0)  ; store region size.
 MOVE.L A0,A2  ; save ptr for the end.
 LEA  rgnData(A0),A0 ; offset ptr to rgnData.
 MOVE.L rgnMap+baseAddr(A6),A1; point to topLeft of bitmap.
 MOVE.W rgnMap+bounds+top(A6),D1 ; y = top.
 MOVE.W D1,dstRect+bottom(A6) ; initialize dstRect...
 MOVE.W rgnMap+bounds+left(A6),dstRect+right(A6)
 MOVE.L rgnMap+bounds+botRight(A6),dstRect+topLeft(A6)
;
; The line flag tells us if the scanline is not completely blank after
; reading whole line.  If not blank, we add end-of-line mark.
;
Translate
 MOVE.W D7,D6  ; load word count.
 MOVEQ  #0,D5  ; clear line flag.
 MOVE.W rgnMap+bounds+left(A6),D3  ; x = left edge.
@0
 MOVE.W (A1)+,D0 ; load srcMap word.
 BNE.S  @NotEmpty; only process non-zero words.
 ADD.W  #16,D3 ; skip zero words for speed.
 BRA.S  @4
@NotEmpty
 TST.B  D5; is line flag set?
 BNE.S  @1; yes --> skip.
 STD5 ; no --> set line flag.
 MOVE.W D1,(A0)+ ; store y coord. in structure.
 CMP.W  dstRect+top(A6),D1; now find the topmost
 BGE.S  @MaxBottom ; row of the region.
 MOVE.W D1,dstRect+top(A6); top = min(top,y).
@MaxBottom
 CMP.W  dstRect+bottom(A6),D1 ; now find the bottommost
 BLE.S  @1; row of the region.
 MOVE.W D1,dstRect+bottom(A6) ; bottom = max(bottom,y).
@1
 OR#$10,CCR ; set the X flag.
 ADDX.W D0,D0  ; shift in end-bit-marker.
@2
 BCC.S  @3; branch if MSB clear.
 MOVE.W D3,(A0)+ ; store x coord. in structure.
 CMP.W  dstRect+left(A6),D3 ; now find the leftmost
 BGE.S  @MaxRight; edge of the region.
 MOVE.W D3,dstRect+left(A6) ; left = min(left,x).
@MaxRight
 CMP.W  dstRect+right(A6),D3; now find the rightmost
 BLE.S  @3; edge of the region.
 MOVE.W D3,dstRect+right(A6); right = max(right,x).
@3
 ADDQ.W #1,D3  ; increment the x coordinate.
 ADD.W  D0,D0  ; shift msb bit into carry.
 BNE.S  @2; repeat if more one-bits.
@4
 DBRA D6,@0 ; loop on rowWords-1.
 TST.B  D5; empty line?
 BEQ.S  @5; yes -->
 MOVE.W #ENDMARK,(A0)+  ; no, store end-of-line mark.
@5
 ADDQ.W #1,D1  ; increment the y coordinate.
 CMP.W  rgnMap+bounds+bottom(A6),D1; loop if y <= bottom rgnMap.
 BLT.S  Translate
;
; We are finished entering information into the rgnData field.
; Mark the end of the region and fill in the rgnBBox field.
;
 MOVE.W #ENDMARK,(A0); store end-of-region mark.
 MOVE.L dstRect+topLeft(A6),rgnBBox+topLeft(A2)
 MOVE.L dstRect+botRight(A6),rgnBBox+botRight(A2)
Done    
 MOVE.L rgnMap+baseAddr(A6),A0; deallocate temporary bitmap.
 _DisposPtr
 MOVEM.L(SP)+,A1-A3/D0-D7 ; restore working registers.
 UNLK A6; unlink the stack frame.
 MOVE.L (SP)+,A0 ; load return address.
 ADDQ #4,SP ; pop parameter.
 JMP  (A0); return.
 ENDWITH
 ENDPROC
 END
Listing 2.  Pict2Rgn.

/*------------------------------------------------------------------
NAME
  Pict2Rgn -- convert PICT resources to Quickdraw region format.
SYNOPSIS
 Pict2Rgn [file] [-v]

 file = any resource file containing PICT resources
 -v= verbose flag
DESCRIPTION
  Converts PICT resources within a file to Quickdraw
  region format.  ID’s of the generated regions will be the
  same as the source PICT’s.  region resource type is ‘RGN ‘.
  Does not check to see if RGN resources are already there.
AUTHOR
  Written Ted Cohn, March 1988.
  Copyright Ted Cohn, 1988.
------------------------------------------------------------------*/

#include <types.h>
#include <stdio.h>
#include <resources.h>
#include <quickdraw.h>
#include <memory.h>

#define RgnType ‘RGN ‘

pascal RgnHandle MakeRgn(srcMap)
 BitMap *srcMap;
 extern;

main(argc, argv)
intargc;
char  *argv[];
{
 Rect   frame; /* picture frame */
 GrafPort gp;  /* offscreen GrafPort pictures are drawn */
 short  index; /* for-loop variable */
 short  refNum;  /* the resource file’s refNum */
 short  pictCount; 
 /* number of picts in resource file to convert */
 Handle pictHandle;/* handle to current picture */
 short  rowWords;/* #of words across picture’s bitmap */
 BitMap srcMap;  /* GrafPort’s bitmap */
 short  theID; /* resource ID from GetResInfo */
 ResTypetheType; /* resource TYPE from GetResInfo */
 RgnHandletheRgn;/* hdle region converted from picture */
 Str255 theName; /* resource NAME from GetResInfo */
 short  verbose; /* boolean signals to print more info */

 verbose = (argc>2); /*boolean more than 2 arguments given */

 /* Must initialize Quickdraw for the conversion process */
 InitGraf(&qd.thePort);
 /* if no argument supplied, then print info about tool */
 printf(“\n”);
 if (argc<2) {
 fprintf(stderr,”\nUsage:  Pict2Rgn <resource file>”);
 fprintf(stderr,”\n  -Converts all PICT resources to Quickdraw region 
format.”);
 fprintf(stderr,”\n  -ResType is ‘RGN ‘, ID’s correspond to PICT ID’s.”);
 fprintf(stderr,”\n  -Written by Ted Cohn, March, 1988.\n”);

 exit(1);
 }
 /* Try to open resource.  If errors, report and exit. */
 if ((refNum = OpenResFile(argv[1])) == -1) {
 fprintf(stderr, “\nCan’t open the resource file %s.\n”, argv[1]);

 exit(1);
 }
 /* Find out how many to convert. Exit if no picts in file.*/
 if ((pictCount = Count1Resources(‘PICT’)) == 0) {
 fprintf(stderr, “\nThere are no PICTs in this file to convert.\n”);
 CloseResFile(refNum);
 exit(1);
 }

 if (verbose)
  fprintf(stderr, “PICT Count = %d\n”, pictCount);
 /* Now convert each PICT to RGN format */
 for (index = 1; index <= pictCount; index++) {    
 /* Get a picture and lock it down */
 HLock(pictHandle = Get1IndResource(‘PICT’, index));
 /* Must get the picture’s ID */
 GetResInfo(pictHandle, &theID, &theType, &theName);
 /* Get the picture’s frame rectangle */
 frame = *((Rect *) (*pictHandle + 2));
 /* Calculate size of srcMap we need to allocate */
 rowWords = (frame.right-frame.left-1)/16+1;
 srcMap.baseAddr = NewPtr((long) ((frame.bottom-frame.top)*rowWords*2));
 srcMap.rowBytes = rowWords*2;
 srcMap.bounds = frame;

 /* Open offscreen GrafPort and set bitmap to our srcMap */

 OpenPort(&gp);
 SetPortBits(&srcMap);
 RectRgn(gp.clipRgn, &frame);
 RectRgn(gp.visRgn, &frame);
 gp.portRect = frame;
 DrawPicture((PicHandle) pictHandle, &frame);
 ClosePort(&gp);
 /* Now convert the picture from a srcMap to a region */
 theRgn = MakeRgn(&srcMap);
 ReleaseResource(pictHandle);
 DisposPtr(srcMap.baseAddr);
 if (verbose)
 fprintf(stderr, “Converted (%d) PICT ID = %d\n”, index, theID);

 /* Add the new region to the file and dispose of it */
 AddResource(theRgn, RgnType, theID, &theName);
 WriteResource(theRgn);
 ReleaseResource(theRgn);
 }
 /* All done, so close the resource file */
 CloseResFile(refNum);
 exit(0);
}
Listing 3.  Make file for Pict2Rgn.

#   File: Pict2Rgn.make
#   Target: Pict2Rgn
#   Sources:MakeRgn.a Pict2Rgn.c
#   Created:Sunday, April 3, 1988 11:25:18 AM


MakeRgn.a.o ƒ Pict2Rgn.make MakeRgn.a
 Asm MakeRgn.a
Pict2Rgn.c.o ƒ Pict2Rgn.make Pict2Rgn.c
 C Pict2Rgn.c
Pict2Rgn ƒƒ Pict2Rgn.make MakeRgn.a.o Pict2Rgn.c.o
 Link -t MPST -c ‘MPS ‘ 
 “{CLibraries}”CRuntime.o 
 “{CLibraries}”StdCLib.o 
 “{CLibraries}”CSANELib.o 
 “{CLibraries}”CInterface.o 
 MakeRgn.a.o 
 Pict2Rgn.c.o 
 -o Pict2Rgn

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

TextSoap 8.4.8 - Automate tedious text d...
TextSoap can automatically remove unwanted characters, fix up messed up carriage returns, and do pretty much anything else that we can think of to text. Save time and effort. Be more productive. Stop... Read more
Air Video Server HD 2.3.0-beta1u1 - Stre...
Air Video Server HD streams videos instantly from your computer on your iPhone, iPad, iPod touch or Apple TV. No need to worry about converting or transferring files. We took everything that was... Read more
MacFamilyTree 8.4.2 - Create and explore...
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
Chromium 70.0.3538.67 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. Version 70.0.3538.67: This update includes 23... Read more
Opera 56.0.3051.52 - High-performance We...
Opera is a fast and secure browser trusted by millions of users. With the intuitive interface, Speed Dial and visual bookmarks for organizing favorite sites, news feature with fresh, relevant content... Read more
Things 3 3.7.2 - Elegant personal task m...
Things is a task management solution that helps to organize your tasks in an elegant and intuitive way. Things combines powerful features with simplicity through the use of tags and its intelligent... Read more
OmniFocus 3.1.1 - GTD task manager with...
OmniFocus helps you manage your tasks the way that you want, freeing you to focus your attention on the things that matter to you most. Capturing tasks and ideas is always a keyboard shortcut away in... Read more
QuarkXPress 14.1.0.0 - Desktop publishin...
QuarkXPress 2017 is the new version that raises the bar for design and productivity. With non-destructive graphics and image editing directly within your layout, you no longer have to choose between... Read more
Chromium 70.0.3538.67 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. Version 70.0.3538.67: This update includes 23... Read more
Opera 56.0.3051.52 - High-performance We...
Opera is a fast and secure browser trusted by millions of users. With the intuitive interface, Speed Dial and visual bookmarks for organizing favorite sites, news feature with fresh, relevant content... Read more

It's up to you to decide the winner...
Thursday is the day when most of the new releases come out on the App Store. It's also the day when we pick what we think are the best five games that have come out over the last seven days. Then we pose you, our readers, a simple question - which... | Read more »
Grimvalor is last week's 148Apps iP...
What a week it has been here at 148Apps towers. We've been swamped, which means we're a bit late letting you know what last week's game of the week was. Don't worry though, we're here now, and we can reveal that Grimvalor takes away the prize. It... | Read more »
My scariest mobile game - Final Fantasy...
This is going to be a bit of a weird one, but bear with me. The game that has scared me the most isn't a horror experience (don't get me wrong, I won't go outside if it's foggy thanks to Silent Hill 2), it's actually Final Fantasy 7. Sounds... | Read more »
My scariest mobile game - Final Fantasy...
This is going to be a bit of a weird one, but bear with me. The game that has scared me the most isn't a horror experience (don't get me wrong, I won't go outside if it's foggy thanks to Silent Hill 2), it's actually Final Fantasy 7. Sounds... | Read more »
Dragalia Lost Daily Tasks Guide
Part of what makes gacha games compelling (and sometimes annoying) is their grind. You’re always supposed to be advancing something in these games, meaning you need to be checking in on your progress once or multiple times a day to make sure you’re... | Read more »
Why I'm looking forward to Stardew...
Last week I read the words I'd been hoping for and got so excited I almost cried: Stardew Valley is coming to mobile on October 24th. While, my colleagues know of my love for the game I think my reasons behind it have always been a bit of a... | Read more »
The best games for iPhone - The definiti...
Hi there, and welcome to our ever-increasing list of the very best games for iPhone. We're going to be updating this regularly with new content, so make sure you check back often, because you're not going to want to miss out on even one of the... | Read more »
Mad Rocket: Fog of War is the next big b...
Mad Rocket: Fog of War is the latest title from pblisher Four Thirty Three, and it’s a game that will have you rethinking your approach to strategic war games. In this new base-building card battler, you’ll be invading bases enshrouded in thick fog... | Read more »
These are the 5 best iPhone games like N...
There's a Mario game on the App Store nowadays, but if it hasn't quite sated your desires to fiddle with an Italian plumber while you're out and about, we've got some suggestions that might help. That's right, it's a list of games like Mario for... | Read more »
Everything You Need to Know About Dragal...
As of this writing, you’re no longer able to take on Phraeganoth or any of the other content in Loyalty’s Requiem. Dragalia Lost will just go back to its original state at launch… or will it? | Read more »

Price Scanner via MacPrices.net

Apple drops prices on Series 3 GPS Apple Watc...
Apple has restocked Certified Refurbished Series 3 Apple Watch GPS models starting at only $239. Apple’s standard 1-year warranty is included, and shipping is free. Numerous bands are available: –... Read more
Apple now offering Certified Refurbished 2018...
Apple is now offering Certified Refurbished 2018 13″ 2.3GHz Touch Bar MacBook Pros for $270-$300 off the cost of new models, with prices starting at $1529. Apple’s refurbished prices are the lowest... Read more
21″ and 27″ iMacs available starting at only...
Apple has a full line of Certified Refurbished iMacs available for up to $350 off original MSRP. Apple’s one-year warranty is standard, and shipping is free. The following models are available: – 27... Read more
Apple offers a wide range of refurbished iPad...
Apple has Certified Refurbished 2017 10.5″ iPad Pros available for $100-$170 off MSRP, depending on the model. An Apple one-year warranty is included with each model, and shipping is free: – 64GB 10... Read more
Get a new 2018 13″ 2.3GHz Touch Bar MacBook P...
B&H Photo has new 2018 13″ 2.3GHz/256GB Touch Bar MacBook Pros on sale for $100 off MSRP. Shipping is free at B&H, and they charge sales tax for residents of NY & NJ only: – 13″ 2.3GHz/... Read more
Order a new 2018 15″ MacBook Pro from Adorama...
Adorama is offering new 2018 15″ Touch Bar MacBook Pros for up to $300 off MSRP. Shipping is free, and they charge sales tax for residents of NY & NJ only: – 15″ 2.2GHz Touch Bar MacBook Pros (... Read more
2017 15″ 2.9GHz Touch Bar MacBook Pro availab...
Adorama has clearance 2017 high-end 15″ 2.9GHz Space Gray Touch Bar MacBook Pros available for $2099 or $700 off original MSRP. Shipping is free, and Adorama charges sales tax in NJ and NY only: – 15... Read more
Apple restocks factory refurbished 13″ MacBoo...
Apple has Certified Refurbished 2017 13″ MacBook Airs available again starting at $849. An Apple one-year warranty is included with each MacBook, and shipping is free: – 13″ 1.8GHz/8GB/128GB MacBook... Read more
Apple May Have ‘One More Thing…’ To Announce...
NEWS: 10.15.18- Steve Jobs, the late co-founder of Apple, Inc. and its former CEO, was famous for ending his keynote addresses that unveiled the tech giant’s newest products with “one more thing…”... Read more
How to use Apple’s Education discount to save...
Purchase a new Mac using Apple’s Education discount, and take up to $400 off MSRP. All teachers, students, and staff of any educational institution with a .edu email address qualify for the discount... Read more

Jobs Board

LPN/CMA - St. Paul and *Apple* Valley Urgen...
LPN/CMA - St. Paul and Apple Valley Urgent Care + Job ID: 50254 + Department: SP Urgent Care + City: St Paul, MN + Location: HP - St Paul Wabasha St Clinic + Read more
*Apple* Mobile Master - Best Buy (United Sta...
**647233BR** **Job Title:** Apple Mobile Master **Job Category:** Store Associates **Location Number:** 000532-Framingham-Store **Job Description:** **What does a Read more
Best Buy *Apple* Computing Master - Best Bu...
**651117BR** **Job Title:** Best Buy Apple Computing Master **Job Category:** Sales **Location Number:** 000504-Gwinnett-Store **Job Description:** **What does a Read more
Geek Squad *Apple* Master Consultation Agen...
**651575BR** **Job Title:** Geek Squad Apple Master Consultation Agent **Job Category:** Services/Installation/Repair **Location Number:** 001128-Vallejo-Store **Job Read more
Sephora Product Consultant - *Apple* Blosso...
Sephora Product Consultant - Apple Blossom Mall Location:Winchester, VA, United States- Apple Blossom Mall 1850 Apple Blossom Dr Job ID:1056553 Date:October Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.