Using Regions
Volume Number: 1
Issue Number: 3
Column Tag: QuickDraw from MacPascal
Using the Region
By Chris Derossi
In the last column, we were introduced to the simple access to QuickDraw from
MacPascal. We found that the procedures for graphic drawing were easily called, using
predefined routines and data structures. The concepts of cartesian coordinates, points,
and lines were very important when dealing with QuickDraw. In this month’s column,
we will begin to explore the next step of QuickDraw complexity: the region.
Whereas a line (actually, a line segment) is a subset of points in one dimension,
a region is a subset of points in two dimensions. When you draw a line with QuickDraw,
the points from one endpoint of the line to the other are said to be part of the line.
Points lying past either endpoint are not part of the line. Points off to the side of the
line can never be part of the line, and are ignored; they are not part of the line.
A similar concept is true for regions. When you have a region in a plane, the
QuickDraw coordinate plane for example, some of the points are part of the region and
the rest are not part of the region. There are no points that are both, and no points that
are neither. Points that are part of the region are said to be inside the region, while
the rest are outisde the region.
The points inside a region do not have to be contiguous. That is, points or groups
of points that comprise the region do not have to be adjacent. For the time being, we
will call a group of points in the QuickDraw plane an area. A region may consist of
zero, one, or several distinct areas.
For the most part, regions can be manipulated in the same manner as any other
QuickDraw object. Just like circle and rectangles, regions can be framed, painted,
erased, inset, offset, and filled. However, the marvelous aspect of regions is their
shape. Regions can be any shape or combination of shapes, large, small, or empty. A
region is empty when there are no points inside of it.
To describe or represent a region, its outline is defined. For example, to describe
a circular region, one would only need to indicate the outline of the circle, not all of its
interior points. Similarly, a rectangular region is represented as a framed rectangle.
More complex shapes for regions can be defined using various combinations of simple
shapes. A ‘T’ shaped regions could be described as the outline of two rectangles that
just touch. It is important to realize, though, that the actual boundaries of a region are
infinitely thin.
Because a region divides the plane into only two sets of points, those inside the
region, and those outside the region, there can be no points that lie on the boundary of
the region. For that reason, there is a distinction between coordinate points and
graphic points. Coordinate points lie between graphic points and vice versa. Lines from
one coordinate point to another have no width, so the graphic points it separates are
actually adjacent.
Illustration #1 shows some graphic points on a coordinate plane. Notice that a
graphic point is to the ‘right’ and ‘below’ its corresponding mathematical coordinate.
As mentioned before, any points with adjacent coordinates will be drawn on the screen
as a single, solid area. The coordinate line separating them is only mathematical, and
does not actually exist. A region’s boundary is defined in terms of coordinate points,
and no graphics points in the plane lie on the boundary.
When regions are defined in MacPascal, the procedure OpenRgn is first called to
allocate the memory needed for the region. Then, the boundary of the region is defined
by calling normal QuickDraw drawing routines, such as FrameRect, FrameOval, and
FrameRoundRect. Only the outlines of the shapes are important; i.e. PaintRect acts just
like FrameRect.
The outlines are summed together to form the boundary of the region. No drawing
is performed because the boundaries are only mathematical, and do not involve real
graphic points. When the entire outline is defined, a call to CloseRgn is made to stop the
region definition. CloseRgn creates a handle to the new region, and passes it back in a
variable of type RgnHandle. (Note: the variable must have first been initialized with a
call to NewRgn.) All subsequent references to the region are done through its handle.
After OpenRgn has been called to start a new region, the region is empty. Then,
areas are added to the region as the boundaries for those areas are ‘drawn’. But, if a
boundary encloses an area that is already part of the region, that area is changed to be
outside of the region. If it is enclosed again, it is re-added to the region, and so on. In
other words, areas are exclusive-ored with the exisitng region. Areas enclosed an odd
number of times are part of the region, while areas enclosed an even number of times
are not part of the region.
Illustration #2 shows a situation in which overlapping areas caused ‘holes’ in
the region. Illustration #2a shows the region shaded, with the rest not shaded.
Illustration #2b breaks the areas down. Area #0 was never enclosed, so it is not part
of the region. Areas #1 were enclosed once each, and are part of the region. The areas
numbered #2 were each enclosed twice, once from each of two circles; they are not
part of the region. Finally, area #3 was enclosed three times and is part of the region.
It is frequently easier to define a region in terms of one area minus another
instead of a sum of areas. For example, illustration #3 can be described as a series of
four rectangles, or as one large rectangle minus the smaller, inside rectangle. The
second way is easier and more intuitive. QuickDraw’s method of exclusive-oring areas
allows area to be added to and subtracted from regions.
Let us now put aside regions to talk about something else: clipping. Clipping is a
graphics term that refers to drawing within certain boundaries. The easiest way to
learn about clipping is to think of an example: anything drawn inside one window on the
Macintosh should stay within that window and not get drawn outside of it. If the window
is too small, the part of the drawing that is beyond the current edges of the window
should not be drawn on the screen. The part of the drawing that is not actually drawn is
said to have been clipped.
Clipping can be thought of as looking through the viewfinder of a camera. You can
only see a portion of the world even though there is stuff beyond the edges of your
sight. In order to emulate reality, and to create the effect of windows and such,
everything drawn on the Mac is clipped, making each window and even the Mac screen a
viewfinder on the whole picture.
There are two ways to do clipping. First, whoever is doing the drawing makes
sure that nothing gets drawn beyond the appropriate boundaries. Second, anything
desired is drawn without regards to boundaries, and clipping is controlled by the low
level draw routines. This means that every point that is drawn is checked for boundary
limitations. Because this is done for every single point, it happens very often. If the
clipping operation were slow, the graphic output on the Mac would take forever. The
name QuickDraw is partially derived from its ability to handle operations like this
very rapidly.
In general, this means that each separate window or drawing area on the Mac may
consider itself the entire coordinate plane. QuickDraw makes sure that only the
appropriate things are actually displayed, and that they fit within the proper bounds.
Many times, though, the clipping area is not rectangular like a window. (Clipping
Area or Clipping Region refers to the areas where drawing occurs. The stuff outside of
the clipping area is what is actually clipped.) Many times a window may be
‘underneath’ several other windows, and have only an unusually shaped portion
visible. Nevertheless, the drawing in that window must be clipped to that unusual area.
That’s where regions come in.
Each window (or QuickDraw port) has an associated Clipping Region. It is this
region that defines what will be displayed, and what will be clipped. For most normal
windows, this region is simply rectangular, but when the window is partially
obscured, the region may become more complicated. In addition, the clipping region of
a window may be changed to suit the needs of the situation.
For example, you might want to fill or erase a region of a window without
affecting anything else in the window. This could be done in pieces, or by setting the
clipping region to the desired region and filling or erasing the whole window. Note that
the clipping region only affects subsequent drawing, and has no effect on previously
drawn graphics.
This month’s MacPascal program is a demonstration of the use of regions, and the
effects of using clipping regions. It shows clearly how to define regions, how to set the
clipping region, and what happens when drawing is clipped.
Before we take a brief step-by-step look at the program, there are some general
comments that should be made. First, in order to remain as compatible as possible with
other Pascal/QuickDraw interfaces, calls that normally require a Rect parameter are
not supplied four integers. Instead, SetRect is used to assign values to the rectangle’s
coordinates.
Second, when you type this program into your Mac and try to execute it, you
might run out of memory; the data structures for regions take up lots of room. If this
happens, try deleting the comments, closing all the windows, and ejecting unneeded
diskettes to free up some memory. Users of 512K Macs should not have any problems.
The program begins by doing a ‘uses QuickDraw2’. The library QuickDraw1
contains all the routines and data structures that we have used so far and is ‘used’
automatically. The routines and data structures for regions, however, reside in
QuickDraw2 and must be included explicitly.
The RgnHandle that we use throughout the program is called My_Rgn. Also, a Rect
called Big_Rect is declared. The constants WordsPerLine, NumLines, and LineHite are
declared and set. These values will be used later to determine that amount and density
of text to draw.
The main program calls only two procedures: SetUp and MakeRgns. SetUp puts
away all of the MacPascal windows with HideAll, puts away the cursor with
HideCursor, and displays the drawing window after setting its coordinates with
SetDrawingRect. In addition, SetUp draws three lines, dividing the window into six
areas. SetUp also initializes My_Rgn with NewRgn and assigns the coordinates of the
drawing window to Big_Rect.
MakeRgns is simply a series of calls to the six separate region demonstration
procedures. The program was structured this way so that each region could be its own
procedure and so modifications were easier. When all six region procedures have
finished, the memory space used by My_Rgn is deallocated with DisposeRgn, and the
clipping region of the drawing window set back to full size.
The six region procedures each call upon three utility procedures called
DrawWords, Use_Region, and ClearRgn. DrawWords uses DrawString to draw the word
‘Regions’ several times according to the constants declared at the beginning. The final
display of the words is clipped according to each different clipping region. ClearRgn
sets the window’s clipping region back to the full window so that drawing of titles, etc
won’t be clipped. Use_Region draws the outline of the current My_Rgn with FrameRgn
and then shrinks it so that the outline lies outside of the region. This is to prevent later
drawing from drawing over the outline. Then, the cliiping region of the window is set
to equal My_Rgn with SetClip.
Five of the six region procedures follow the same general outline. First, ClearRgn
is called to reset the clipping region. Next, a title is drawn for the region. Finally, the
region is defined and used to clip the text created with DrawWords. Several aspects of
regions and clipping are demonstrated.
The final region procedure is slightly different. As before, it resets the clipping
region and draws a title. Then, it shades in the sixth rectangle with gray to provide for
contrast later. Next, a region is defined and used in the same manner as the other five
procedures. This region is then cleared to white, yielding a binocular-type window
effect. After this is done, a small circle is animated. The circle is bounced in an
imaginary rectangle that is somewhat larger than the region. The animation routine
just continues the circle on its present course until it strikes a side of the imaginary
rectangle. Then, a new course is chosen at random for it, and it continues.
Because the circle is sometimes not within the region, it is automatically clipped.
This gives the effect of multiple planes that are stacked, with a window in the top one
looking through to the bouncing ball. The clipping is performed automatically, and it is