TweetFollow Us on Twitter

Diamond WDEF
!see also "Diamond WDEF Correction"
Volume Number:7
Issue Number:10
Column Tag:C Workshop

Related Info: Window Manager

Diamond WDEF

By Marisano James, Lancaster, PA

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks. See also Diamond WDEF Correction for code correction.

[Marisano James is a senior at Franklin and Marshall College where he works under the supervision of Dr. Jay Anderson, head of the Computer Science program, without whose early encouragement and support this article would not have been possible.]

Introduction

Over the years since MacTutor’s introduction, several window definition routines have been discussed by its authors. To my knowledge, none of these WDEFs have focused on non-rectangular windows. I believe this is because non-rectangular windows are often created for amusement instead of serious application. If this observation is correct, it identifies an interesting objection since MacTutor is read by many hobbyists. However, another justification for the aforementioned scarcity may be that non-rectangular windows do not operate as quickly as rectangular ones. This is because they must manipulate regions as opposed to rectangles. In this article I will address these issues and propose solutions. I think that this document and the code it discusses contain an element of discovery - discovery of new methods of approaching problems that allow us to see how we sometimes create our own restrictions. I believe this to be the best justification for this excursion.

Following is a discussion of the most significant difficulties I encountered while composing a WDEF for the manipulation of diamond shaped windows. Whenever a new technique is introduced I have explained why such a modification is useful. These explanations are designed to allow one to deduce the utility of my solutions, including in what other situations they might be useful.

Before proceeding I will describe the main characteristics of diamond windows. Diamond windows are shaped like rectangular windows tilted 45°. Because of this rotation their titles are drawn on a 45° slant. They expand and shrink from around their centers and may or may not contain any of the following: a go-away region, a grow region, and a zoom region.

Auxiliary Data

Non-rectangular windows will almost certainly use auxiliary data, and since this information is likely to be window specific, it should not be stored in the WDEF itself. This is where the predefined message wNew can be used to advantage.1 Within the routine designed to respond to this message, you can allocate memory for a window’s data. It is important that you also create a structure for your auxiliary data and include it wherever your non-rectangular windows are used. This way your code will compile and your debugger will interpret your structure’s members correctly. Below is a listing of the structure used in the diamond window WDEF.

/* 1 */

typedef struct {
 Rect   myRect, stdRect;
 Booleanresizable, zoomedOut;
 PolyHandle goAwayPoly, growPoly, zoomPoly;
 RgnHandletitleRgn, goAwayRgn, growRgn, zoomRgn;
 short  midX, midY, halfTitleSpace, leftStop,
 numChars;
} DataRecord, DataRecordHdl;

Illustration 1: a Diamond Window

static variables

The A5 register normally points to an application’s global variables. However, WDEFs are not applications and so the register is unavailable for use in them. This means the QuickDraw globals are not directly accessible to WDEFs. The A4 register can be used to reference the QuickDraw globals, or it can point to the WDEF’s own global variables. Diamond windows make use of the second approach. This methodology coupled with the use of static variables, allows the QuickDraw patterns to be redefined with the same names and used in precisely the same manner as within applications. This is possible because static variables allow ‘local’ globals to have the same names, but different data, as true globals. If a file redefines globals using static variables, then the variable with the larger scope is unavailable in that file.

main()

The first thing the diamond window WDEF does is set up the A4 register so that the WDEF can use global variables Thereafter main() determines whether or not the WDEF was called to create a new window. If so, the actions taken by it are discussed in the section dedicated to the wNew message. If not, the affected window’s dataHandle is transferred to the global variable dataRecordHdl. Then this handle’s data is transferred into another global called dataRecord. This prevents the WDEF from having to double dereference the data’s handle every time it needs to alter a window’s auxiliary information. At the completion of the dispatching routine, the current data is BlockMoved() into the memory location held by the previous information.

wNew

When the diamond window WDEF encounters wNew messages it does not transfer data from the window’s dataHandle. That procedure would be time consuming and possibly dangerous since the uninitialized handle could be referencing sensitive memory locations. Instead, control is passed to InitNewWindow(). This function sets many of the window’s characteristics, such as the shape of its goAway box -- if it has one. Later, when a diamond window is resized, or its position is changed, the WDEF simply offsets the regions created by InitNewWindow() instead of actually recalculating them since their shapes and sizes do not change. However, this is not true of the content, structure, or title regions, which have no such guarantees about their sizes and therefore must be recalculated. Finally, InitNewWindow() provides a valid handle to memory where the auxiliary information can be stored after the WDEF has been exited. Because of this, the BlockMove() executed at the end of the WDEF performs a useful service by storing the window’s auxiliary data in memory referenced by this handle.

wGrowMsg

Diamond windows grow and shrink around their centers. This means that whenever the grow icon is dragged, all four corners move that same distance away from or toward the center of the window. This behavior ensures that diamond windows retain their shape. It also creates an interesting problem. When a window is being resized, the Window Manager repeatedly calls the WDEF with the message parameter equal to wGrowMsg until the mouse button is released. During this time, a pointer to the global coordinates of a modified portRect are passed to the routine that draws the growImage. I say modified portRect because when a window is resized the effected rectangle is actually a copy of the window’s portRect. Then, if so directed, QuickDraw will replace the values stored in the portRect with those of the modified copy. Finally the content and structure regions of the resized window are rebuilt accordingly. At any rate, the Rect pointer was intended for use with rectangular windows. In rectangular windows, the top left hand corner is kept stationary while the bottom right hand one is allowed to pivot. This enables such windows to be resized both horizontally and vertically. However, diamond windows only respond to mouse movement along the y-axis when being resized. In order to extract information only pertaining to the vertical direction, GrowWindowGrow() subtracts the y-coordinate of the middle of the window from the y-coordinate of the bottom of the dereferenced Rect pointer. The resultant value is then used as the length of each side.

A diamond window with a grow region will also have a slider area which is drawn in response to the wDrawGIcon message. To prevent drawing from occurring within this area a clipRgn is used. For the sake of speed and simplicity, this clipRgn is automatically created and maintained by the WDEF itself. This method creates some complications of its own however, to be discussed in the External Window Support section.

wNEW_TITLE

Title drawing is also more complicated for diamond windows than for rectangular ones. The WDEF must decide if the whole title can be displayed, whether or not it will fit down the diagonal of one half the window, etc. These things depend on the size of the window, but for a given title, the WDEF can determine threshold window sizes. However, if the title is changed, the WDEF must be informed so that it can recalculate the transitional window sizes. To this affect, the function SetDiamondWTitle() calls the WDEF with the diamond window specific message wNEW_TITLE. The WDEF then installs the new title into the window record’s titleHandle member and checks to see if the window is visible. If so, the WDEF makes the Window Manager port the current port and stores the present clip region into it. Then the clip is set to the window’s titleRgn and ClipAbove() is called to determine what portion of the titleRgn is visible. Finally, DrawWindow() is called to redraw the window with the new clipRgn enforced.

wDispose

In order to operate efficiently, auxiliary memory must be released when a diamond window is dismissed. This is done in response to the wDispose message. The function WindowDisposal() releases memory occupied by the members of the dataRecord structure. At the end of the function the dataHandle itself is released. This is permissible because the WDEF is exited prematurely when a wDispose message is serviced, thus preventing the final BlockMove() from corrupting memory by moving data into memory referenced by an invalid handle.

External Window Support

Diamond windows require greater support outside the WDEF than do rectangular ones. In a program supporting both rectangular and diamond shaped windows, I have found it useful to store descriptive numbers in the refCon members of all window records in order to differentiate between the two types. The program can either include a separate window handling routine for diamond shaped windows, or the refCon member can be tested within each case statement where it is necessary to provide alternative instructions for diamond shaped windows.

The Slider Area

Additional support is required when using sliders with diamond shaped windows because no drawing will occur if the clipRgn is not suspended before Draw1Control() is called for each slider. Despite this, it is desirable to have the WDEF maintain the clipRgn automatically, since all of the window’s other controls should be drawn with the clipRgn enforced. Therefore, a diamond window’s sliders should be clearly distinguishable from other controls, so that they can be drawn without the clipRgn’s range restrictions. This can be accomplished by coding each slider’s refCon member.

Establishing a clipRgn further restricting drawing in the content region of a diamond window also deserves to be discussed. It should be sufficient to save the former clipRgn, create and install a new one for use within the drawing routine, and finally, to reinstall the original clipRgn. Note that SetClip() creates and uses a copy of the region passed to it. It is therefore necessary to dispose of the original region after a call to SetClip().

Illustration 2: a Diamond’s portRect

The portRect

The portRect does not encompass the entire contentRgn of a diamond shaped window. Although this in itself is not problematic because the Window Manager sets aside enough memory for all onscreen drawing, offscreen drawing is another issue. Normally, offscreen buffers are set to the dimensions of the portRect. This is sufficient for diamond shaped windows possessing growRgns because the clipRgn used with such windows is completely enveloped by the portRect. However, when a programmer wishes to establish an offscreen BitMap or GrafPort for a diamond window without a grow region, the portBits.bounds member of the buffer should be of the same dimensions as the window’s portRect inset -26 pixels on each side. This will also have bearing on the rowBytes member of the BitMap and the amount of memory necessary for the actual buffer.

DragWindow()

Directly before calling DragWindow(), the titleWidth member of the window record is set to TRUE. If part of a window which was previously offscreen is moved onscreen as a result of a drag, DragWindow() will call the appropriate WDEF with the wDraw argument. The diamond window WDEF checks the value of theWindow->titleWidth each time wDraw is called for a visible window. If theWindow->titleWidth is TRUE, the WDEF will recalculate the window’s regions so that any newly visible portions of the window will be drawn. This recalculation must occur before any drawing takes place. If DragWindow() calls the diamond window WDEF, theWindow->titleWidth is set to FALSE.

Upon returning from DragWindow(), the calling routine checks to see if the titleWidth member is still set to TRUE. If so, the window’s regions are recalculated. This allows DoHit() to operate properly. If the region’s position’s were not recalculated at this time, it would be necessary to do so every time the mouse button is pressed with the cursor inside the window. This is not an efficient use of time and the resultant pause would be very noticeable because the updating would occur before a requested operation instead of after one. However, there is no need to recalculate the region’s positions if the titleWidth member of the window is FALSE, because this means the window’s regions were already updated when DragWindow() called the WDEF.

The titleWidth member is used in this manner because it is not used for any other purpose and otherwise it would be necessary to extract the information from the window’s dataHandle - a task requiring considerably more dereferencing.

GrowWindow()

A size restriction should always be passed when GrowWindow() is called to resize a diamond window. Otherwise a user will be able to pull the bottom of the window over its top. In order for size restrictions to work properly, the value passed to GrowWindow() must be adjusted to account for the rate at which diamond windows grow and shrink.

Initially windHeight holds the hi word of the value returned by GrowWindow() -- the low word is inconsequential since only movement along the vertical axis effects a diamond window’s size. If the variable windHeight were passed to SizeWindow() without modification, the window would be incorrectly resized. The reason for this becomes clear if you think carefully about what is actually being stored in the variable. When a diamond window is resized, the new size is only adjusted from the bottom. However, diamond windows grow and shrink around their centers. It is therefore necessary to alter the window’s size at its top by the same amount it was changed at its bottom. This amounts to subtracting the difference in sizes between the size of the old portRect and the value stored in windHeight (the difference can be positive or negative). This value, called offset, is also used to properly offset the window in the horizontal and vertical directions.

SetDiamondWTitle()

Instead of calling SetWTitle() to change a diamond window’s title, call SetDiamondWTitle(). This function in turn calls the WDEF, passing the new title as an argument.

Final Notes

The CallPascalL() routine

When making a WDEF that is called using the CallPascalL() routine, be careful not to call the WDEF using the standard predefined messages. These have special significance to the Window Manager, and will generally not operate as intended. Instead, define your own message and have the WDEF respond to it. Simply stack the two case statements so that they apply to the same instructions.

contRgn and strucRgn

One of the most difficult aspects of creating WDEFs is making the clipRgns and strucRgns correspond correctly to one another. To help solve this difficulty I found it useful to make an application, open a standard window using it, and to draw the clipRgn and strucRgn within it. The application should erase the clipRgn after drawing the window’s frame because this is what the Window Manager does when it first draws a window, or any part of a window that was just uncovered. For this reason, the window will not have an outline if the strucRgn is not larger than the contRgn. Also, in order for a window to have a drop shadow, the strucRgn should to be large enough to contain that graphic. During this stage of window development it is important to remember that the QuickDraw pen draws one pixel down and one pixel to the right of the actual pen location.

Entering the WDEF source code

WDEFs are CODE resources. Before you can actually compile a CODE resource, you need to tell the compiler that that is your intention. If you are using THINK C, under the Project menu select “Set Project Type ”. When the dialog box appears fill it in as follows:

Illustration 3: the Set Project Type Dialog Box

Once you have successfully created your WDEF resource you will need to make a new, standard project in which to place WorkDiamondWinds.c, the program that helps control the diamond windows. Do not forget to open the resource containing the WDEF code. When THINK C opens a project it looks in that folder for a resource file having the same name as the project but with “.rsrc” appended to it. If it finds one, it will automatically open that file. Note that any special characters used to indicate that a file is a project are considered part of its name.

Footnote

1 The Window Manager requests actions from a WDEF by sending it messages. Depending on the nature of the request, the WDEF may return a meaningful message of its own. If this does not sound familiar, take a cursory glance at Inside Macintosh Volume 1, Chapter nine, “Defining Your Own Windows”.

/* ============================================================

File: Diamond.h
Function: Header file for Diamond Windows.
History: Last modification -- 04/25/91 -- Marz.

============================================================ */

#include <stddef.h>

#define MAKE_EVEN0xFFFE

typedef struct   {
 Rect   myRect, stdRect;
 Booleanresizable, zoomedOut;
 PolyHandle goAwayPoly, growPoly, zoomPoly;
 RgnHandletitleRgn, goAwayRgn, growRgn, zoomRgn;
 short  midX, midY, halfTitleSpace, leftStop, numChars;
} DataRecord, **DataRecordHdl;

/* ==========================================================

File: DiamondDef.c
Function: Defines the Diamond Window.
History: 7/4/90  &  8/26/90 - 12/1/90  &  2/15/91 - 4/22/91 :
 Marz. 

============================================================ */

#include “DiamondDef.h”
#include <SetUpA4.h>


#define wJUST_DRAGGED50
#define wNEW_TITLE 51
#define DRAW_WINDOW_FRAME 0

#define ZOOM_MASK8
#define NO_GROW_MASK 4

#define SCREEN_MARGIN3
#define FRAME_WIDTH25
#define SHADOW   3
#define LEFT_SIDETRUE
#define FULL_RESERVE 51
#define TOP_RESERVE30
#define BOTTOM_RESERVE    13

#define FIRST_CHAR 1


static Pattern   white = {0}, black = {0xFF, 0xFF, 0xFF,
 0xFF,  0xFF,0xFF, 0xFF, 0xFF}, gray = {0xAA, 0x55, 0xAA,
 0x55, 0xAA, 0x55, 0xAA, 0x55};

DataRecorddataRecord;
DataRecordHdl    dataRecordHdl;

/* ========================================================= */

void    CalcRgns(WindowPeek   theWindow)
{
/* Calculates the structure, content, and title regions of diamond windows 
when they are created or after they have been dragged or resized.
*/
GrafPtr savedPort;
Rect    theRect, strucRect, polyRect;
short   halfPort, halfStruc, xOffset, yOffset;

 theRect = theWindow->port.portRect;
/* The contentRgn extends beyond the portRect.  This means origin is 
automatically offset so that it begins just outside the scroll bar area, 
regardless of whether or not the window actually has a grow region.
*/
 halfPort = halfStruc = (theRect.right - theRect.left) >> 1;
 halfStruc += 26;
/* This routine needs the portRect in Global coordinates for drawing 
in the WMgr port. By switching the current port to the window’s port 
and pretending a rectangle is two points this can be achieved.
*/ 
 GetPort(&savedPort);
 SetPort(theWindow);
 LocalToGlobal(&topLeft(theRect));
 LocalToGlobal(&botRight(theRect));
 SetPort(savedPort); 
 if (EqualRect(&theRect, &dataRecord.stdRect))
 {
 /* window was resized by being zoomed, don’t change dataRecord.myRect, 
it holds the previous size of the portRect for use with inZoomIn.
 */
 strucRect = theRect;
 dataRecord.zoomedOut = TRUE;
 }
 else
 {
 /* window has been resized w/o being zoomed, save the new window size 
for later inZoom-ing.
 */
 dataRecord.myRect = strucRect = theRect;
   dataRecord.zoomedOut = FALSE;
  }
/* Get the strucRect.  dataRecord.midX and dataRecord.midY are the Global 
coordinates of the middle of the window.
*/
 InsetRect(&strucRect, -26, -26);
 dataRecord.midX = (strucRect.left + strucRect.right) >> 1;
 dataRecord.midY = (strucRect.top + strucRect.bottom) >> 1;
/* Get the strucRgn*/
 OpenRgn();
 MoveTo(strucRect.left, dataRecord.midY);
 Line(halfStruc, -halfStruc);
 Line(2, 0);
 Line(halfStruc, halfStruc);
 Line(0, 1);
 Line(-halfStruc, halfStruc);
 Line(-2, 0);
 Line(-halfStruc, -halfStruc);
 Line(0, -1);
 CloseRgn(theWindow->strucRgn);

/* Define the titleRgn.  There are a couple of notes of interest here.
 1)ErasePoly() actually calls NewRgn() and makes a region out of the 
polygon in order to know what to erase.
 2)I only used titlePoly to erase the title area anyway so why not just 
make it a region and save time?
*/
 OpenRgn();
 MoveTo(theRect.left - 26, dataRecord.midY);
 Line(26, 0);
 Line(halfPort, halfPort);
 Line(halfPort, -halfPort);
 Line(26, 0);
 Line(-halfStruc, halfStruc);
 Line(-halfStruc, -halfStruc);
 CloseRgn(dataRecord.titleRgn);
/* Define the content region. */
 halfStruc --;
 OpenRgn();
 MoveTo(dataRecord.midX, theRect.top - 25);
 Line(halfStruc, halfStruc);
 Line(-25, 0);
 Line(-halfPort, halfPort);
 Line(-halfPort, -halfPort);
 Line(-25, 0);
 Line(halfStruc, -halfStruc);
 CloseRgn(theWindow->contRgn);
/* The following lines offset various window parts to the updated locations. 
 The window parts are only updated if they are present.
*/
 if (theWindow->goAwayFlag)
 {
 HLock(dataRecord.goAwayPoly);
 polyRect = (**(dataRecord.goAwayPoly)).polyBBox;
 HUnlock(dataRecord.goAwayPoly);
 xOffset = -polyRect.left + strucRect.left + 18;
 yOffset = -polyRect.top + dataRecord.midY + 5;
 OffsetPoly(dataRecord.goAwayPoly, xOffset, yOffset);
 OffsetRgn(dataRecord.goAwayRgn, xOffset, yOffset);
 }
 if (theWindow->spareFlag)
 {
 HLock(dataRecord.zoomPoly);
 polyRect = (**(dataRecord.zoomPoly)).polyBBox;
 HUnlock(dataRecord.zoomPoly);
 xOffset = -polyRect.left + strucRect.right - 34;
 yOffset = -polyRect.top + dataRecord.midY + 5;
 OffsetPoly(dataRecord.zoomPoly, xOffset, yOffset);
 OffsetRgn(dataRecord.zoomRgn, xOffset, yOffset);
 }
 if (dataRecord.resizable)
 {
 HLock(dataRecord.growPoly);
 polyRect = (**(dataRecord.growPoly)).polyBBox;
 HUnlock(dataRecord.growPoly);
 xOffset = -polyRect.left + dataRecord.midX - 8;
 yOffset = -polyRect.top + strucRect.bottom - 24;
 OffsetPoly(dataRecord.growPoly, xOffset, yOffset);
 OffsetRgn(dataRecord.growRgn, xOffset,yOffset);
/* Make the clipRgn which will prevent drawing from occuring within the 
slider area.  This region will later have to be suspended to allow for 
the drawing of the sliders themselves.
When Working with clipRgns it is important to remember how the Mac coordinate 
system works. Recall that the pen hangs down and to the right one pixel 
of the actual location of the pen.  The following few lines compensate 
for this
*/
 SetPort(theWindow);
 OpenRgn();
 theRect = theWindow->port.portRect;
 MoveTo(theRect.left, theRect.top + halfPort);
 Line(1, 0);
 Line(halfPort - 1, -halfPort + 1);
 Line(halfPort - 1, halfPort - 1);
 Line(1, 0);
 Line(-halfPort, halfPort);
 Line(-halfPort, -halfPort);
 CloseRgn(theWindow->port.clipRgn);
 SetPort(savedPort);
 }
/* Find how much space is available in each window half for writing the 
title in.
*/
 dataRecord.halfTitleSpace = halfStruc - FULL_RESERVE;
}


void    ToggleGoAwayBox()
{
/* Indicates when the close region of a diamond window is selected by 
drawing an asterisk-like symbol within the region.  First the image is 
drawn into an offscreen BitMap using StuffHex(), then the image is tranferred 
to the WMgrPort by means of the CopyBits() procedure.
*/
BitMap  closeBitMap;
GrafPtr windMngrPort;
Rect    tempRect, myRect;

 closeBitMap.baseAddr = NewPtr(0x34);
 StuffHex(closeBitMap.baseAddr, “002000200020012400A80000”);
 StuffHex(closeBitMap.baseAddr + 12,
 “0F8F800000A801240020002000200”);
 closeBitMap.rowBytes = 2;
 closeBitMap.bounds.top = closeBitMap.bounds.left = 0;
 closeBitMap.bounds.bottom = closeBitMap.bounds.right = 13;
 myRect = closeBitMap.bounds;
 tempRect = (**dataRecord.goAwayPoly).polyBBox;
 OffsetRect(&myRect, tempRect.left + 2, tempRect.top + 2);
 GetWMgrPort(&windMngrPort);
 CopyBits(&closeBitMap, &windMngrPort->portBits,
 &closeBitMap.bounds,
 &myRect, srcXor, NULL);
 DisposPtr(closeBitMap.baseAddr);
}


void    ToggleZoomBox()
{
/* As ToggleGoAwayBox().
*/
BitMap  zoomBitMap;
GrafPtr windMngrPort;
Rect    tempRect, myRect;

 zoomBitMap.baseAddr = NewPtr(0x34);
 StuffHex(zoomBitMap.baseAddr, “0020002000A0016400A80010”);
 StuffHex(zoomBitMap.baseAddr + 12,
 “0F8F801000A8016400A0002000200”);
 zoomBitMap.rowBytes = 2;
 zoomBitMap.bounds.top = zoomBitMap.bounds.left = 0;
 zoomBitMap.bounds.bottom = zoomBitMap.bounds.right = 13;
 myRect = zoomBitMap.bounds;
 tempRect = (**dataRecord.zoomPoly).polyBBox;
 OffsetRect(&myRect, tempRect.left + 2, tempRect.top + 2);
 GetWMgrPort(&windMngrPort);
 CopyBits(&zoomBitMap, &windMngrPort->portBits, &zoomBitMap.bounds,
 &myRect, srcXor, NULL);
 DisposPtr(zoomBitMap.baseAddr);
}


void    EraseTitleSpace(Boolean   leftSide, short   length)
{
/* Clears space for the window’s title to be drawn in.
*/
RgnHandle theRgn;

 theRgn = NewRgn();
 OpenRgn();
 if (leftSide)
 {
 Line(length, length);
 Line(11, -11);
 Line(-length, -length);
 Line(-11, 11);
 }
 else
 {
 Line(length, -length);
 Line(-11, -11);
 Line(-length, length);
 Line(11, 11);
 }
 CloseRgn(theRgn);
 EraseRgn(theRgn);
 DisposeRgn(theRgn);
}


void    DrawChars(startSpot, stopSpot, theTitle)
short   startSpot, stopSpot;
PtrtheTitle;
{
/* Draws the characters of the window’s title on a diagonal slant.  If 
(start == FIRST_CHAR) then text is drawn on a downward slant, otherwise 
text is drawn on an upward slant beginning with the character specified 
by startSpot.
*/
char    ch;
short   yOffset, index, charWidth, xAdjust;

 if (startSpot == FIRST_CHAR)
 yOffset = 8;
 else
 yOffset = -8;
 index = startSpot;
 while (index <= stopSpot)
 {
 ch = *(theTitle + index);
 charWidth = CharWidth(ch); 
 xAdjust = charWidth >> 1;
 Move(-xAdjust, 0);
 DrawChar(ch);
 Move(-(charWidth - xAdjust) + 8, yOffset);
 index ++;
 }
}


void    DrawTitle(WindowPeek   theWindow, Rect   strucRect)
{
/* Decides how text should appear, depending on the size of the window 
and its title. Positions the pen and oversees text drawing.
*/
PtrtheTitle;
short   totalWidth, oneSide, adjust, penOffset,
 mostChars, leftChars;
StringHandletitleHandle;

 titleHandle = theWindow->titleHandle;
 HLock(titleHandle);
 theTitle = (Ptr) *titleHandle;
 totalWidth = (dataRecord.numChars << 3) + 10;
 oneSide = (strucRect.right - strucRect.left) >> 1;
 if (totalWidth <= dataRecord.halfTitleSpace)
 {
 adjust = ((oneSide - totalWidth) >> 1) + 7;
 MoveTo(strucRect.left + adjust, dataRecord.midY + adjust);
 EraseTitleSpace(LEFT_SIDE, totalWidth);
 Move(16, 7);
 DrawChars(FIRST_CHAR, dataRecord.numChars, theTitle);
 }
 else
 {
 mostChars = dataRecord.numChars - dataRecord.leftStop;
 if (mostChars < dataRecord.leftStop)
 mostChars = dataRecord.leftStop;
 if ((mostChars << 3) < (dataRecord.halfTitleSpace))
 {
 /* word break on space   */
 penOffset = (dataRecord.leftStop << 3) + 5;
 MoveTo(dataRecord.midX - BOTTOM_RESERVE - 3,
  strucRect.bottom - BOTTOM_RESERVE - 3);
 Move(-penOffset, -penOffset);
 EraseTitleSpace(LEFT_SIDE, penOffset);
 Move(14, 5);
 DrawChars(FIRST_CHAR, dataRecord.leftStop, theTitle);
 /* don’t forget to remove the excess space */
 penOffset = (dataRecord.numChars - dataRecord.leftStop -
 1) << 3;
 MoveTo(dataRecord.midX + BOTTOM_RESERVE + 3,
 strucRect.bottom - BOTTOM_RESERVE - 3);
 EraseTitleSpace(!LEFT_SIDE, penOffset + 5);
 Move(1, -8);
 DrawChars(dataRecord.leftStop + 2, dataRecord.numChars,
 theTitle);
 }
 else
 {
 /* no word break on space*/
 leftChars = dataRecord.halfTitleSpace >> 3;
 penOffset = dataRecord.halfTitleSpace + 4;
 MoveTo(dataRecord.midX - BOTTOM_RESERVE - 3,
 strucRect.bottom - BOTTOM_RESERVE - 3);
 Move(-penOffset, -penOffset);
 EraseTitleSpace(LEFT_SIDE, penOffset);
 Move(14, 5);
 DrawChars(FIRST_CHAR, leftChars, theTitle);
 MoveTo(dataRecord.midX + BOTTOM_RESERVE + 3,
 strucRect.bottom - BOTTOM_RESERVE - 3);
 mostChars = leftChars << 1;
 if (mostChars > dataRecord.numChars)
 {
 mostChars = dataRecord.numChars;
 penOffset = ((dataRecord.numChars - leftChars) << 3) +
 4;
 }
 EraseTitleSpace(!LEFT_SIDE, penOffset);
 Move(0, -7);
 DrawChars(leftChars + 1, mostChars, theTitle);
 }
 }
 HUnlock(titleHandle);
}


void    DrawWindow(WindowPeek   theWindow, long   param)
{
/* Draws diamond window frames and titles as appropriate.
*/
Rect    strucRect;
short   halfPort, halfStruc, index;

 if (theWindow->visible)
 switch(LoWord(param))
 {
 case wInGoAway:
 ToggleGoAwayBox();
 break;
 case wInZoomIn:
 case wInZoomOut:
 ToggleZoomBox();
 break;
 default:
/* Draw window frame.*/
 if (theWindow->titleWidth)
 {
 CalcRgns(theWindow);
 theWindow->titleWidth = FALSE;
 }
 if (dataRecord.zoomedOut)
 strucRect = dataRecord.stdRect;
 else
 strucRect = dataRecord.myRect;
 InsetRect(&strucRect, -26, -26);
 halfStruc = halfPort = (strucRect.right -
 strucRect.left) >> 1;
 halfPort -= 26;
 MoveTo(strucRect.left, dataRecord.midY);
 Line(halfStruc, -halfStruc);
 PenSize(3, 1);
 Line(halfStruc, halfStruc);
 Line(-halfStruc, halfStruc);
 PenSize(1, 1);
 Line(-halfStruc, -halfStruc);
/* Draw content stuff*/
 EraseRgn(dataRecord.titleRgn);
/* Outline the content region {and the title region}  */
 Line(26, 0);
 Line(halfPort, halfPort);
 Line(halfPort, -halfPort);
 Line(25, 0);
 if (theWindow->hilited)
 {
 MoveTo(strucRect.left + 23, dataRecord.midY + 2);
 index = halfStruc - 3;
 for (halfStruc = index - 20; halfStruc < index;
 halfStruc += 4)
 {
 Line(halfStruc, halfStruc);
 Line(halfStruc, -halfStruc);
 Move(-(halfStruc << 1) - 4, 0);
 }
 if (theWindow->goAwayFlag)
 {
 PenPat(&white);
 PenSize(1, 1);
 MoveTo(strucRect.left + 17, dataRecord.midY +
 12);
 Line(8, -8);
 Move(0, 20);
 Line(10, -10);
 PenPat(&black);
 EraseRgn(dataRecord.goAwayRgn);
 FramePoly(dataRecord.goAwayPoly);
 }
 if (theWindow->spareFlag)
 {
 PenPat(&white);
 PenSize(1, 1);
 MoveTo(strucRect.right - 17, dataRecord.midY +
 12);
 Line(-8, -8);
 Move(0, 20);
 Line(-10, -10);
 PenPat(&black);
 EraseRgn(dataRecord.zoomRgn);
 FramePoly(dataRecord.zoomPoly);
 }
 if (dataRecord.resizable)
 {
 InsetRgn(dataRecord.growRgn, -2, 0);
 EraseRgn(dataRecord.growRgn);
 InsetRgn(dataRecord.growRgn, 2, 0);
 FramePoly(dataRecord.growPoly);
 }
 } /* if window is hilited*/
 DrawTitle(theWindow, strucRect);
 break;
 } /* end switch */
}


void    NewTitle(WindowPeek   theWindow, Ptr   theTitle)
{
/* Resets the handle size for the window’s title, then BlockMove()s the 
new information into it.  Next the space closest to the true center of 
the title is found and recorded in the variable leftStop {if no space 
is found the entire title’s length is stored in leftStop}.  This information, 
coupled with the window’s current size, is used to determine how the 
the window’s title should be drawn {all on the left side, split at a 
space and part drawn on each side, etc.}.
 NewTitle() should only be called when the window is given a new title.
*/
char    ch;
GrafPtr savedPort;
PtrmiddleChar;
RgnHandle theRgn;
short   leftChars, index;
StringHandletitleHandle;
WindowPeekwindMgrPort;

 dataRecord.numChars = *theTitle;
 titleHandle = theWindow->titleHandle;
 SetHandleSize(titleHandle, dataRecord.numChars + 1);
 BlockMove(theTitle, *titleHandle, dataRecord.numChars + 1);
 HLock(titleHandle);
 leftChars = dataRecord.numChars >> 1; /* divide in half */
 middleChar = theTitle + leftChars;
 for (index = 0; index <= leftChars; index ++)
 {
 ch = *(middleChar - index);
 if (ch == 0x20)
 {
 dataRecord.leftStop = leftChars - index - 1;
 break;
 }
 else
 {
 ch = *(middleChar + index);
 if (ch == 0x20)
 {
 dataRecord.leftStop = leftChars + index - 1;
 break;
 }
 }
 }
 if (index > leftChars)
 dataRecord.leftStop = dataRecord.numChars;
 HUnlock(titleHandle);
 /* When dataRecord.titleRgn == NULL, the window 
 is new and therefore its
 titleRgn has not yet been properly set up by 
 CalcRgns(). Setting a clipRgn
 to an uninitialized region is a fatal error so 
 SetClip() should NOT be called
 under this circumstance.
 */
 if ((theWindow->visible) && (dataRecord.titleRgn != NULL))
 {
 GetPort(&savedPort);
 GetWMgrPort(&windMgrPort);
 SetPort(windMgrPort);
 theRgn = NewRgn();
 GetClip(theRgn);
 /* The visRgn does not include any of the window’s strucRgn, only the 
visible portion of its contRgn. There’s no point in dealing with the 
entire visible strucRgn, just the part of it used to display the window’s 
title since that’s all that’s being altered.  So the WDEF just sets the 
window manager’s clipRgn to the window’s titleRgn and calls ClipAbove() 
to subtract the strucRgns of all visible window’s in front of the window 
whos title has been changed.
 */
 SetClip(dataRecord.titleRgn);
 ClipAbove(theWindow);
 DrawWindow(theWindow, DRAW_WINDOW_FRAME);
 SetClip(theRgn);
 /* SetClip() copies the specified region into the clipRgn member of 
the current port.  It’s up to the programmer to release the memory occupied 
by the original region.
 */
 DisposeRgn(theRgn);
 SetPort(savedPort);
 }
}


void    DrawGrowIcon(WindowPeek   theWindow)
{
/* Draws the part of the grow icon that is in the content region of the 
window. It is not feasible to draw the gIcon as part of the window frame 
because, although the icon is properly drawn with much less effort, it 
is often times incorrectly erased by the Window Manager when the window 
is resized {the WManager has to erase the content region to ensure that 
no desktop slop shows through}.
*/
GrafPtr savedPort;
PenStatesavedPenState;
Rect    portRect;
RgnHandle clipRgn;
short   halfPort;

 if (dataRecord.resizable)
 if (theWindow->visible)
 {
 GetPort(&savedPort);
 SetPort(theWindow);
 GetPenState(&savedPenState);
 PenNormal();
 clipRgn = NewRgn();
 GetClip(clipRgn);
 /* Must take into consideration the coordinates of the origin in case 
SetOrigin() has been called with values other than (0, 0).  Remember, 
this drawing occurs within the window’s own grafport.
 */
 portRect = theWindow->port.portRect;
 halfPort = (portRect.right - portRect.left) >> 1;
 MoveTo(portRect.left, portRect.top + halfPort);
 portRect.top -= 26;
 ClipRect(&portRect);
 Line(halfPort, -halfPort);
 Line(0, -25);
 Move(0, 25);
 Line(halfPort, halfPort);
 SetPenState(&savedPenState);
 SetClip(clipRgn);
 DisposeRgn(clipRgn);
 SetPort(savedPort);
 }
}


void    GrowWindowGrow(theWindow, rectPtr)
WindowPeektheWindow;
Rect    *rectPtr;
{
/* Draws the grow image for the window.  Diamond windows grow and shrink 
at twice the normal rate and only movement in the y-direction effects 
them when they are being resized.
 To find the new length of each side, (*rectPtr).bottom is subtracted 
from dataRecord.midY, the y-coordinate of the middle of the window.
*/
short   length, longLength;

 length = longLength = rectPtr->bottom - dataRecord.midY - 1;
 longLength += 26;
 MoveTo(dataRecord.midX - length, dataRecord.midY);
 PenPat(&white);
 Line(length, -length);
 Line(length, length);
 Line(-length, length);
 Line(-length, -length);
 PenPat(&gray);
 Line(-26, 0);
 Move(longLength, -length);
 Line(0, -26);
 Move(length, longLength);
 Line(26, 0);
 PenPat(&white);
 Line(-longLength, longLength);
 Line(-longLength, -longLength);
 Line(longLength, -longLength);
 Line(longLength, longLength);
/* The Window Manager automatically resets the pen pattern to black when 
it stops calling this function.
*/
}


void    SetUpStdZoom(void)
{
/* Sets up the stdState Rect so the window will be zoom ready.  This 
rectangle is always centered onscreen and does not take into account 
any maximum window size you may entend to enforce using GrowWindow().
*/
GrafPtr windMPort;
Rect    theRect;
short   xDistance, yDistance;

 GetPort(&windMPort);
 theRect = windMPort->portRect;
 InsetRect(&theRect, SCREEN_MARGIN, SCREEN_MARGIN +
 FRAME_WIDTH);
 theRect.top += MBarHeight;
 theRect.right -= SHADOW;
 theRect.bottom -= 2;
/* Make sure x and yDistance are even. */
 xDistance = (theRect.right - theRect.left) & MAKE_EVEN;
 yDistance = (theRect.bottom - theRect.top) & MAKE_EVEN;
 if (xDistance > yDistance)
 {
 OffsetRect(&theRect, (xDistance - yDistance) >> 1, 0);
 theRect.right = theRect.left + yDistance;
 }
 else if (yDistance > xDistance)
 {
 OffsetRect(&theRect, 0, (yDistance - xDistance) >> 1);
 theRect.bottom = theRect.top + xDistance;
 }
 dataRecord.stdRect = theRect;
}


void    InitNewWindow(WindowPeek   theWindow)
{
/*   Sets up various window regions and allocates memory necessary for 
the operation of diamond shaped windows.
*/
Rect    theRect;
Str255  theTitle;

 theWindow->strucRgn = NewRgn();
 theWindow->contRgn = NewRgn();
 if (theWindow->goAwayFlag)
 {
 dataRecord.goAwayPoly = OpenPoly();
 MoveTo(0, 0);
 Line(8, -8);
 Line(8, 8);
 Line(-8, 8);
 Line(-8, -8);
 ClosePoly();
 dataRecord.goAwayRgn = NewRgn();
 OpenRgn();
 FramePoly(dataRecord.goAwayPoly);
 CloseRgn(dataRecord.goAwayRgn);
 }
 if (dataRecord.resizable)
 {
 dataRecord.growPoly = OpenPoly();
 MoveTo(0, 0);
 Line(8, -8);
 Line(8, 8);
 Line(-8, 8);
 Line(-8, -8);
 Line(5, -5);
 Line(-2, -2);
 Line(5, -5);
 Line(5, 5);
 Line(-1, 1);
 ClosePoly();
 dataRecord.growRgn = NewRgn();
 OpenRgn();
 MoveTo(0, 0);
 Line(5, -5);
 Line(-2, -2);
 Line(5, -5);
 Line(5, 5);
 Line(-2, 2);
 Line(5, 5);
 Line(-8, 8);
 Line(-8, -8);
 CloseRgn(dataRecord.growRgn);
 }
 if (theWindow->spareFlag)
 {
 dataRecord.zoomPoly = OpenPoly();
 MoveTo(5, -5);
 Line(3, -3);
 Line(8, 8);
 Line(-8, 8);
 Line(-8, -8);
 Line(5, -5);
 Line(5, 5);
 Line(-5, 5);
 ClosePoly();
 dataRecord.zoomRgn = NewRgn();
 OpenRgn();
 FramePoly(dataRecord.goAwayPoly);
 CloseRgn(dataRecord.zoomRgn);
 SetUpStdZoom();
 dataRecord.zoomedOut = FALSE;
 }
/* Initialize the global variable dataRecordHdl so data can be transferred 
from the global variable dataRecord into the window’s private storage 
area.
*/
 dataRecordHdl = (DataRecordHdl) 
 NewHandle(sizeof(DataRecord));
 theWindow->dataHandle = (Handle) dataRecordHdl;
 theRect = theWindow->port.portRect;
 if (theRect.bottom > theRect.right)
 {
 /* To ensure that each side of a window’s portRect is even, the value 
is ANDed with MAKE_EVEN, that is 0xFFFE.
 */
 theRect.right &= MAKE_EVEN;
 theRect.bottom = theRect.right;
 }
 else
 {
 theRect.bottom &= MAKE_EVEN;
 theRect.right = theRect.bottom;
 }
 theWindow->port.portRect = theRect;
/* Save title information that will allow diamond window title to be 
drawn more quiclky.
*/
 BlockMove(*(theWindow->titleHandle), theTitle, 0xFF);
 dataRecord.titleRgn = NULL;
 NewTitle(theWindow, (Ptr) theTitle);
 dataRecord.titleRgn = NewRgn();
}


long    DoHit(WindowPeek   theWindow, Point   mouseClick)
{
/* Determines if a diamond window was hit by a mouseClick.  If so, returns 
the region in which the click occured.
*/
 if (theWindow->visible)
 if (theWindow->hilited)
 {
 if (theWindow->goAwayFlag)
 if (PtInRgn(mouseClick, dataRecord.goAwayRgn))
 return(wInGoAway);
 if (dataRecord.resizable)
 if (PtInRgn(mouseClick, dataRecord.growRgn))
 return(wInGrow);
 if (theWindow->spareFlag)
 if (PtInRgn(mouseClick, dataRecord.zoomRgn))
 return(dataRecord.zoomedOut ? wInZoomIn :
 wInZoomOut);
 if (PtInRgn(mouseClick, dataRecord.titleRgn))
 return(wInDrag);
 if (PtInRgn(mouseClick, theWindow->contRgn))
 return(wInContent);
 }
 else   /* if window is not hilited  */
 {
 if (PtInRgn(mouseClick, dataRecord.titleRgn))
 return(wInDrag);
 if (PtInRgn(mouseClick, theWindow->strucRgn))
 return(wInContent);
 }
}


void    WindowDisposal(WindowPeek   theWindow)
{
/* Releases memory occupied by auxiliary window data.
*/

 DisposeRgn(dataRecord.titleRgn);
 if (theWindow->goAwayFlag)
 {
 KillPoly(dataRecord.goAwayPoly);
 DisposeRgn(dataRecord.goAwayRgn);
 }
 if (dataRecord.resizable)
 {
 KillPoly(dataRecord.growPoly);
 DisposeRgn(dataRecord.growRgn);
 }
 if (theWindow->spareFlag)
 {
 KillPoly(dataRecord.zoomPoly);
 DisposeRgn(dataRecord.zoomRgn);
 }
 DisposHandle(theWindow->dataHandle);
}


pascal long main(varCode, theWindow, message, param)
short   varCode;
WindowPeektheWindow;
short   message;
long    param;
{
/* Sets up registers, copies dataHandle information into global variables, 
dispatches control to other routines, and copies updated information 
back into the window’s dataHandle.
*/
long    returnVal = 0L;

 RememberA0();
 SetUpA4();
 if (message != wNew)
 {
 dataRecordHdl = (DataRecordHdl) theWindow->dataHandle;
 BlockMove(*dataRecordHdl, &dataRecord, sizeof(DataRecord));
 }
 switch(message)
 {
 case wDraw:
 DrawWindow(theWindow, param);
 break;
 case wHit:
 returnVal = DoHit(theWindow, topLeft(param));
 break;
 case wJUST_DRAGGED:
 theWindow->titleWidth = FALSE;
 case wCalcRgns:
 CalcRgns(theWindow);
 break;
 case wNew:
 theWindow->spareFlag = varCode & ZOOM_MASK;
 dataRecord.resizable = !(varCode & NO_GROW_MASK);
 InitNewWindow(theWindow);
 break;
 case wDispose:
 WindowDisposal(theWindow);
 RestoreA4();
 return(returnVal);
 break;
 case wDrawGIcon:
 DrawGrowIcon(theWindow);
 break;
 case wGrow:
 GrowWindowGrow(theWindow, (Rect *) param);
 break;
 case wNEW_TITLE:
 NewTitle(theWindow, (Ptr) param);
 break;
 }
 HLock(dataRecordHdl);
 BlockMove(&dataRecord, *dataRecordHdl, sizeof(DataRecord));
 HUnlock(dataRecordHdl);
 RestoreA4();
 return(returnVal);
}



/* ============================================================

File: WorkDiamondWinds.c
Function: Controls Diamond Windows.
History: 7/4/90  &  8/26/90 - 1/16/91  &  2/15/91  &  4/15/91 -
 4/22/91 : Marz. 

This file contains additional code illustrating the appropriate methodology 
for operating Diamond Windows.

============================================================ */

#include“WindowMgr.h”
#include“DiamondDef.h”


#define NO_VARIATION 0
#define wJUST_DRAGGED50
#define wNEW_TITLE 51

#define FLUSH_EVENTS 0
#define VISIBLE  TRUE
#define DIAMOND_DOC_PROC_PLUS_ZOOM 16008
#define NO_GROW_DIAMOND_PROC16012
#define PLACE_IN_FRONT    -1L
#define GO_AWAY_BOXTRUE
#define NULL_REF_NUM 0


typedef struct ZoomInfo {
 short  top;
 short  midX;
 short  length;
} ZoomInfo;


EventRecord theEvent;

/* ========================================================= */


void    ZoomDiamondFrame(theWindow, expand)
WindowPeektheWindow;
Boolean expand;
{
/* This function expands or shrinks a series of diamonds around the About 
Diamond when it is being Zoomed.  It’s a very nice effect because it 
takes the user’s mind off how long it’s taking her or his window’s contents 
to be redrawn and it also it looks cool.
*********************** Acknowledgement ***********************
 I found a routine for drawing zoom indicator lines around windows in 
the Febuary 1987 issue of MacTutor.  I modified the original code written 
by Jean Decombe so that it would work well with diamond shaped windows 
and optimized it a touch by performing all division operations as bit 
shifts, using the Line() command instead of LineTo(), and by using the 
% {mod} function to reduce the number of necessary storage areas {normally 
rectangles, ZoomInfos in this case}.
*/
GrafPtr savedPort, deskPort;
Rect    startRect, endRect, zoomRect;
long    unit;
short   index, topDiff, leftDiff, bottomDiff, rightDiff;
ZoomInfozoomSpot[4], holder;

 startRect = ((WStateData*) *(theWindow->dataHandle))
 ->stdState;
 endRect = ((WStateData*) *(theWindow->dataHandle))
 ->userState;
 InsetRect(&startRect, -26, -26);
 InsetRect(&endRect, -26, -26);
 if (expand)
 {
 zoomRect = startRect;
 startRect = endRect;
 endRect = zoomRect;
 }
 topDiff = endRect.top - startRect.top;
 leftDiff = endRect.left - startRect.left;
 bottomDiff = endRect.bottom - startRect.bottom;
 rightDiff = endRect.right - startRect.right;
 GetPort(&savedPort);
 GetWMgrPort(&deskPort);
 InitPort(deskPort);
 PenMode(notPatXor);
 PenPat(&white);
 for (index = 0; index <= 20; index ++)
 {
 if (index >= 4)
 {
 holder = zoomSpot[index % 4];
 MoveTo(holder.midX, holder.top);
 Line(holder.length, holder.length);
 Line(-holder.length, holder.length);
 Line(-holder.length, -holder.length);
 Line(holder.length, -holder.length);
 }
 if (index <= 16)
 {
 zoomRect = startRect;
 unit = ((expand ? index + 1: 33 - index) * index) >> 1;
 zoomRect.top += (unit * topDiff) >> 7;
 zoomRect.left += (unit * leftDiff) >> 7;
 /* zoomRect.bottom never needs to be adjusted because diamond shaped 
windows grow in the horizontal and vertical directions at the same rate.
 */
 zoomRect.right += (unit * rightDiff) >> 7;
 holder.top = zoomRect.top;
 holder.midX = (zoomRect.right + zoomRect.left) >> 1;
 holder.length = (zoomRect.right - zoomRect.left) >> 1;
 MoveTo(holder.midX, holder.top);
 Line(holder.length, holder.length);
 Line(-holder.length, holder.length);
 Line(-holder.length, -holder.length);
 Line(holder.length, -holder.length);
 zoomSpot[index % 4] = holder;
 }
 }
 PenMode(patCopy);
 PenPat(&black);
 SetPort(savedPort);
}


Boolean DoMouseDown(thePart, theWindow)
short   thePart;
WindowPtr theWindow;
{
/* Handles mouse clicks.  Returns TRUE if the window was clicked in its 
close box.
*/
Boolean disposedWindow = FALSE;
Handle  wDefHdl;
long    newSize;
Rect    growRect, sizeRestrict, theRect;
RgnHandle theRgn, strucRectRgn;
short   adjust, offset, currentSize;
WindowPeekwindPkr;

 if (theWindow != NULL)
 SetPort(theWindow);
 switch(thePart)
 {
 case inDesk:
 case inSysWindow:
 SystemClick(&theEvent, theWindow);
 break;
 case inDrag:
 windPkr = (WindowPeek) theWindow;
/* The Window Manger automatically calls WDEFs passing the wDraw message 
when part of a window is dragged back onscreen after having been offscreen. 
 This segment of code sets the dragged member of the DataRecord structure, 
if the WDEF is called the dragged member will be set to FALSE.  If it 
remains TRUE after the DragWindow() procedure has been executed then 
the window’s regions need to be updated and the WDEF is called to achieve 
this.
 All this is necessary because when a window is dragged offscreen and 
then back on, the WDEF must recalculate its regions BEFORE redrawing 
the window, so that the full visible portion of the window is redrawn.
*/
 windPkr->titleWidth = TRUE;
 DragWindow(theWindow, theEvent.where,
 &screenBits.bounds);
/* The WDEF should only be called here when <dataRecord>dragged == FALSE. 
Otherwise the diamond window’s regions would be recalculated twice {what 
a waste}.  The Diamond WDEF automatically sets <dataRecord>.dragged to 
FALSE when called with the wJUST_DRAGGED message.
*/
 if (windPkr->titleWidth)
 {
 wDefHdl = windPkr->windowDefProc;
 HLock(wDefHdl);
 CallPascalL(NO_VARIATION, windPkr, wJUST_DRAGGED, 0L,
 *wDefHdl);
 HUnlock(wDefHdl);
 }
 if (theWindow != FrontWindow())
 if (!(theEvent.modifiers & cmdKey))
 SelectWindow(theWindow);
 break;
 case inGrow:
 /* The size restriction is actually 50 for the lower limit and 400 for 
the upper limit.  However, due to the nature of Diamond Windows only 
half these values are used.
 */
 growRect = theWindow->portRect;
 currentSize = (growRect.right - growRect.left) >> 1;
 sizeRestrict.top = sizeRestrict.left = currentSize + 28;
 sizeRestrict.bottom = sizeRestrict.right = currentSize +
 200;
 newSize = GrowWindow(theWindow, theEvent.where,
 &sizeRestrict);
/* adjust originally holds a value which is too large, again due to the 
rate at which diamond windows grow and shrink.  This value is ANDed with 
0xFFFE to ensure that the resultant number is even.  The result must 
then be manipulated so that it corresponds to the actual new size the 
window should be.
*/
/* Only HiWord() because movement left or right is inconsequential.
*/
 adjust = HiWord(newSize) & MAKE_EVEN;
 if ((adjust != 0) && (adjust != (currentSize << 1)))
 {
 /* in case the origin has been offset */
 offset = (adjust - (growRect.right - growRect.left));
 LocalToGlobal(&topLeft(growRect));
 ShowHide(theWindow, FALSE);
 SizeWindow(theWindow, adjust + offset, adjust +
 offset, FALSE);
 MoveWindow(theWindow, growRect.left - offset,
 growRect.top - offset, TRUE);
 ShowHide(theWindow, TRUE);
 }
 break;
 case inGoAway:
 if (TrackGoAway(theWindow, theEvent.where))
 {
 DisposeWindow(theWindow);
 disposedWindow = TRUE;
 }
 break;
 case inContent:
 if (theWindow != FrontWindow())
 SelectWindow(theWindow);
 break;
 case inZoomIn:
 case inZoomOut:
 if (TrackBox(theWindow, theEvent.where, thePart))
 {
 ZoomDiamondFrame((WindowPeek) theWindow, thePart ==
 inZoomOut);
 ShowHide(theWindow, FALSE);
 ZoomWindow(theWindow, thePart, TRUE);
 ShowHide(theWindow, TRUE);
 }
 break;
 }
 return(disposedWindow);
}


void    UpdateDiamond(theWindow)
WindowPeektheWindow;
{
Rect    rgnRect = {20, 10, 180, 190};

 PaintRect(&rgnRect);
}


void    SetDiamondWTitle(theWindow, newTitle)
PtrtheWindow;
Str255  newTitle;
{
/* Use the following lines to change a diamond window’s title.
*/
Handle  wDefHdl;

 wDefHdl = ((WindowPeek) theWindow)->windowDefProc;
 HLock(wDefHdl);
 CallPascalL(0, theWindow, wNEW_TITLE, newTitle, *wDefHdl);
 HUnlock(wDefHdl);
}


void  DiamondWindowTest()
{
/* Operates diamond shaped windows demonstrating many of the WDEF’s abilities.
*/
GrafPtr oldPort;
Handle  wDefHdl;
Rect    windRect = {50, 50, 215, 215}, theRect;
short   openWindows, thePart;
Str255  newTitle = “\pThe Only Window”;
WindowPtr theWindow;

 NewWindow(NULL, &windRect, “\pDiamond Window”, VISIBLE,
 DIAMOND_DOC_PROC_PLUS_ZOOM, PLACE_IN_FRONT, GO_AWAY_BOX,
 NULL_REF_NUM);
/* When you wish to define diamond windows from resource definitions, 
everything should be set up normally.  Then, once you are satisfied with 
the configuration, go back and add an offset to the procID member to 
reflect the use of a custom WDEF.  The offset is the ID number assigned 
to the WDEF multiplied by 16.  In this case the ID number was 1000, so 
the offset is (16 * 1000) or 16000.  However, DIAMOND_DOC_PROC_PLUS_ZOOM 
= 16008.  The additional 8 specifies that the window should have one 
of each of the following regions: grow, goAway, and zoom.
*/
/* these will be equalized by the WDEF */
 InsetRect(&windRect, -20, -40);
 OffsetRect(&windRect, 130, 55);
 NewWindow(NULL, &windRect, “\pAnother Diamond Window”,
 VISIBLE, NO_GROW_DIAMOND_PROC, PLACE_IN_FRONT,
 GO_AWAY_BOX, NULL_REF_NUM);
 openWindows = 2;
 do
 {
 WaitNextEvent(everyEvent, &theEvent, 0L, 0L);
 theWindow = (WindowPtr) theEvent.message;
 if (theWindow != NULL)
 SetPort(theWindow);
 switch(theEvent.what)
 {
 case mouseDown:
 thePart = FindWindow(theEvent.where, &theWindow);
 if (DoMouseDown(thePart, theWindow))
 {
 openWindows --;
 if (openWindows == 1)
 {
 theWindow = FrontWindow();
 SetDiamondWTitle(theWindow, newTitle);
 /* Demostration of SetOrigin()    */
 SetPort(theWindow);
 SetOrigin(-30, -50);
 windRect = theWindow->portRect;
 /* Must also offset the clipRgn so that it corresponds with the new 
window coordinates.
 */
 if ( (**((DataRecordHdl) ((WindowPeek)
 theWindow)->dataHandle)).resizable)
 OffsetRgn(theWindow->clipRgn, -30, -50);
 else
 InsetRect(&windRect, -26, -26);
 EraseRect(&windRect);
 InvalRect(&windRect);
 }
 }
 break;
 case activateEvt:
 case updateEvt:
 GetPort(&oldPort);
 SetPort(theWindow);
 DrawGrowIcon(theWindow);
 BeginUpdate(theWindow);
 UpdateDiamond((WindowPeek) theWindow);
 EndUpdate(theWindow);
 SetPort(oldPort);
 break;
 }
 }
 while (openWindows > 0);
}


void    main()
{
/* Initializes the ToolBox and calls the window handling function.
*/
PtrreservedMem;
Rect    screenRect;
short   index;

 MaxApplZone();
 InitGraf(&thePort);
 InitFonts();
 InitWindows();
 TEInit();
 InitDialogs(NULL);
 InitMenus();
 FlushEvents(everyEvent, FLUSH_EVENTS);
 InitCursor();
 DiamondWindowTest();
 ExitToShell();
}

 
AAPL
$102.42
Apple Inc.
+0.17
MSFT
$45.28
Microsoft Corpora
+0.40
GOOG
$569.86
Google Inc.
+0.66

MacTech Search:
Community Search:

Software Updates via MacUpdate

VueScan 9.4.41 - Scanner software with a...
VueScan is a scanning program that works with most high-quality flatbed and film scanners to produce scans that have excellent color fidelity and color balance. VueScan is easy to use, and has... Read more
Cloud 3.0.0 - File sharing from your men...
Cloud is simple file sharing for the Mac. Drag a file from your Mac to the CloudApp icon in the menubar and we take care of the rest. A link to the file will automatically be copied to your clipboard... Read more
LibreOffice 4.3.1.2 - Free Open Source o...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
SlingPlayer Plugin 3.3.20.505 - Browser...
SlingPlayer is the screen interface software that works hand-in-hand with the hardware inside the Slingbox to make your TV viewing experience just like that at home. It features an array of... Read more
Get Lyrical 3.8 - Auto-magically adds ly...
Get Lyrical auto-magically add lyrics to songs in iTunes. You can choose either a selection of tracks, or the current track. Or turn on "Active Tagging" to get lyrics for songs as you play them.... Read more
Viber 4.2.2 - Send messages and make cal...
Viber lets you send free messages and make free calls to other Viber users, on any device and network, in any country! Viber syncs your contacts, messages and call history with your mobile device,... Read more
Cocktail 7.6 - General maintenance and o...
Cocktail is a general purpose utility for OS X that lets you clean, repair and optimize your Mac. It is a powerful digital toolset that helps hundreds of thousands of Mac users around the world get... Read more
LaunchBar 6.1 - Powerful file/URL/email...
LaunchBar is an award-winning productivity utility that offers an amazingly intuitive and efficient way to search and access any kind of information stored on your computer or on the Web. It provides... Read more
Maya 2015 - Professional 3D modeling and...
Maya is an award-winning software and powerful, integrated 3D modeling, animation, visual effects, and rendering solution. Because Maya is based on an open architecture, all your work can be scripted... Read more
BBEdit 10.5.12 - Powerful text and HTML...
BBEdit is the leading professional HTML and text editor for the Mac. Specifically crafted in response to the needs of Web authors and software developers, this award-winning product provides a... Read more

Latest Forum Discussions

See All

Fire in the Hole Review
Fire in the Hole Review By Rob Thomas on August 29th, 2014 Our Rating: :: WALK THE PLANKUniversal App - Designed for iPhone and iPad Seafoam’s Fire in the Hole looks like a bright, 8-bit throwback, but there’s not enough booty to... | Read more »
Dodo Master Review
Dodo Master Review By Jordan Minor on August 29th, 2014 Our Rating: :: NEST EGGiPad Only App - Designed for the iPad Dodo Master is tough but fair, and that’s what makes it a joy to play.   | Read more »
Motorsport Manager Review
Motorsport Manager Review By Lee Hamlet on August 29th, 2014 Our Rating: :: MARVELOUS MANAGEMENTUniversal App - Designed for iPhone and iPad Despite its depth and sense of tactical freedom, Motorsport Manager is one of the most... | Read more »
Motorsport Manager – Beginner Tips, Tric...
The world of Motorsport management can be an unforgiving and merciless one, so to help with some of the stress that comes with running a successful race team, here are a few hints and tips to leave your opponents in the dust. | Read more »
Baseball Battle Review
Baseball Battle Review By Jennifer Allen on August 29th, 2014 Our Rating: :: SIMPLE HITTINGUniversal App - Designed for iPhone and iPad Simple and cute, Baseball Battle is a fairly fun baseball game for those looking for something... | Read more »
Checkmark 2.1 Update Released, and it’s...
Checkmark 2.1 Update Released, and it’s on Sale for a Limited Time Posted by Jessica Fisher on August 29th, 2014 [ permalink ] | Read more »
The Walking Dead Pinball Review
The Walking Dead Pinball Review By Blake Grundman on August 29th, 2014 Our Rating: :: DECISIONS, DECISIONS...Universal App - Designed for iPhone and iPad Zen Studios is at it again, taking a property that would never seem to work... | Read more »
Stupeflix Has Released a Major Update fo...
Stupeflix Has Released a Major Update for Replay Posted by Jessica Fisher on August 29th, 2014 [ permalink ] iPhone App - Designed for the iPhone, compatible with the iPad | Read more »
ALONE… Review
ALONE… Review By Jennifer Allen on August 29th, 2014 Our Rating: :: MINIMALISTIC AND TOUGHUniversal App - Designed for iPhone and iPad Tough yet satisfying, ALONE… is a challenging endless flyer with some suitably sensitive... | Read more »
Hyperlapse Review
Hyperlapse Review By Jennifer Allen on August 28th, 2014 Our Rating: :: SPEEDY VIDEO SNAPSUniversal App - Designed for iPhone and iPad Want to make a great time-lapse video quickly? Hyperlapse is perfect for that.   | Read more »

Price Scanner via MacPrices.net

13-inch 1.4GHz MacBook Air on sale for $899,...
Adorama has the new 2014 13″ 1.4GHz/128GB MacBook Air on sale for $899.99 including free shipping plus NY & NJ tax only. Their price is $100 off MSRP. Read more
It’s Official: Apple Issues Invitations To Se...
Apple has issued one of its characteristically cryptic press invitations for a special event to be held at the Flint Center for the Performing Arts in hometown Cupertino on Sept. 9, 2014 at 10:00 am... Read more
Tablet Shipments To See First On-year Decline...
TrendForce analyst Caroline Chen notes that when the iPad launched in 2010, it was an instant hit and spurred a tablet PC revolution, with tablets so popular that that notebook PC sales stagnated and... Read more
SOBERLINK Releases Apple iOS Compatible Handh...
Cypress, California based SOBERLINK, Inc., creator of the first handheld Breathalyzer designed to improve recovery outcomes, continues to show prominence in the mobile alcohol monitoring space with... Read more
New 21″ 1.4GHz iMac on sale again for $999, s...
Best Buy has the new 21″ 1.4GHz iMac on sale for $999.99 on their online store. Their price is $100 off MSRP. Choose free shipping or free local store pick up. Price is for online orders only, in-... Read more
Smartphone Outlook Remains Strong for 2014, U...
According to a new mobile phone forecast from the International Data Corporation (IDC) Worldwide Quarterly Mobile Phone Tracker, more than 1.25 billion smartphones will be shipped worldwide in 2014,... Read more
Save up to $60 with Apple refurbished iPod to...
The Apple Store has Apple Certified Refurbished 5th generation iPod touches available starting at $149. Apple’s one-year warranty is included with each model, and shipping is free. Many, but not all... Read more
12-Inch MacBook Air Coming in 4Q14 or 2015 –...
Digitimes’ Aaron Lee and Joseph Tsai report that according to Taiwan-based upstream supply chain insiders, Apple plans to launch a thinner MacBook model either at year end 2014 or in 2015, and that... Read more
Sapphire Screen “Most Wanted” iPhone 6 New Fe...
According to the ‘uSell.com iPhone Most Wanted Survey’ — a representative survey of 1,000 U.S. smartphone users conducted by used iPhone marketplace uSell.com — close to half of all smartphone users... Read more
The iPad’s Real Competitive Challenger (Not S...
It’s been my contention for some time that the iPad is suffering from something of an identity crisis, and I suspect that may be a factor in slackening sales this year. Apple can’t seem to decide... Read more

Jobs Board

*Apple* Retail - Multiple Positions (US) - A...
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
*Apple* Retail - Multiple Positions (US) - A...
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
*Apple* Retail - Multiple Positions (US) - A...
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
Senior Event Manager, *Apple* Retail Market...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global event strategy. Delivering an overarching brand story; in-store, Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.