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
$111.78
Apple Inc.
-0.87
MSFT
$47.66
Microsoft Corpora
+0.14
GOOG
$516.35
Google Inc.
+5.25

MacTech Search:
Community Search:

Software Updates via MacUpdate

NeoOffice 2014.6 - Mac-tailored, OpenOff...
NeoOffice is a complete office suite for OS X. With NeoOffice, users can view, edit, and save OpenOffice documents, PDF files, and most Microsoft Word, Excel, and PowerPoint documents. NeoOffice 3.x... Read more
LibreOffice 4.3.5.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
CleanApp 5.0.0 Beta 5 - Application dein...
CleanApp is an application deinstaller and archiver.... Your hard drive gets fuller day by day, but do you know why? CleanApp 5 provides you with insights how to reclaim disk space. There are... Read more
Monolingual 1.6.2 - Remove unwanted OS X...
Monolingual is a program for removing unnecesary language resources from OS X, in order to reclaim several hundred megabytes of disk space. It requires a 64-bit capable Intel-based Mac and at least... Read more
NetShade 6.1 - Browse privately using an...
NetShade is an Internet security tool that conceals your IP address on the web. NetShade routes your Web connection through either a public anonymous proxy server, or one of NetShade's own dedicated... Read more
calibre 2.13 - Complete e-library manage...
Calibre is a complete e-book library manager. Organize your collection, convert your books to multiple formats, and sync with all of your devices. Let Calibre be your multi-tasking digital librarian... Read more
Mellel 3.3.7 - Powerful word processor w...
Mellel is the leading word processor for OS X and has been widely considered the industry standard since its inception. Mellel focuses on writers and scholars for technical writing and multilingual... Read more
ScreenFlow 5.0.1 - Create screen recordi...
Save 10% with the exclusive MacUpdate coupon code: AFMacUpdate10 Buy now! ScreenFlow is powerful, easy-to-use screencasting software for the Mac. With ScreenFlow you can record the contents of your... Read more
Simon 4.0 - Monitor changes and crashes...
Simon monitors websites and alerts you of crashes and changes. Select pages to monitor, choose your alert options, and customize your settings. Simon does the rest. Keep a watchful eye on your... Read more
BBEdit 11.0.2 - Powerful text and HTML e...
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

Make your own Tribez Figures (and More)...
Make your own Tribez Figures (and More) with Toyze Posted by Jessica Fisher on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
So Many Holiday iOS Sales Oh My Goodness...
The holiday season is in full-swing, which means a whole lot of iOS apps and games are going on sale. A bunch already have, in fact. Naturally this means we’re putting together a hand-picked list of the best discounts and sales we can find in order... | Read more »
It’s Bird vs. Bird in the New PvP Mode f...
It’s Bird vs. Bird in the New PvP Mode for Angry Birds Epic Posted by Jessica Fisher on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Telltale Games and Mojang Announce Minec...
Telltale Games and Mojang Announce Minecraft: Story Mode – A Telltale Games Series Posted by Jessica Fisher on December 19th, 2014 [ permalink ] | Read more »
WarChest and Splash Damage Annouce Their...
WarChest and Splash Damage Annouce Their New Game: Tempo Posted by Jessica Fisher on December 19th, 2014 [ permalink ] WarChest Ltd and Splash Damage Ltd are teaming up again to work | Read more »
BulkyPix Celebrates its 6th Anniversary...
BulkyPix Celebrates its 6th Anniversary with a Bunch of Free Games Posted by Jessica Fisher on December 19th, 2014 [ permalink ] BulkyPix has | Read more »
Indulge in Japanese cuisine in Cooking F...
Indulge in Japanese cuisine in Cooking Fever’s new sushi-themed update Posted by Simon Reed on December 19th, 2014 [ permalink ] Lithuanian developer Nordcurrent has yet again updated its restaurant simulat | Read more »
Badland Daydream Level Pack Arrives to C...
Badland Daydream Level Pack Arrives to Celebrate 20 Million Downloads Posted by Ellis Spice on December 19th, 2014 [ permalink ] | Read more »
Far Cry 4, Assassin’s Creed Unity, Desti...
Far Cry 4, Assassin’s Creed Unity, Destiny, and Beyond – AppSpy Takes a Look at AAA Companion Apps Posted by Rob Rich on December 19th, 2014 [ permalink ] These day | Read more »
A Bunch of Halfbrick Games Are Going Fre...
A Bunch of Halfbrick Games Are Going Free for the Holidays Posted by Ellis Spice on December 19th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »

Price Scanner via MacPrices.net

13-inch 2.6GHz Retina MacBook Pro on sale for...
Best Buy has lowered their price on the 2014 13″ 2.6GHz/128GB Retina MacBook Pro to $1149.99 on their online store for a limited time. That’s $150 off MSRP and the lowest price available for this... Read more
Kodak Returns to CES With New Consumer Produ...
Former photography colossus Kodak is returning to CES for the first time in three years where the Kodak booth (#21818 South Hall 1) will showcase a wide range of innovative, imaging-related products... Read more
Invaluable Launches New Eponymously -Named A...
Invaluable, the world’s largest online live auction marketplace, hhas announced the official launch of the Invaluable app for iPad, now available for download in the iTunes App Store. Invaluable... Read more
IDC Reveals Worldwide Mobile Enterprise Appli...
International Data Corporation (IDC) last week hosted the IDC FutureScape: Worldwide Mobile Enterprise Applications and Solutions 2015 Predictions Web conference. The session provided organizations... Read more
Hello Vino Wine App Launches “Safe Ride Home”...
Hello Vino has announced addition of a new “Get a Safe Ride Home” feature in its Food & Drink app with a direct connection to Uber, the technology platform that connects users with rides. The... Read more
DEVON-technologies Releases DEVONthink To Go...
Coeur d’Alene, Idaho based DEVON-technologies, LLC has updated DEVONthink To Go, its mobile companion to DEVONthink, to version 1.5. The update includes an iOS 8 extension, compatibility with the... Read more
The Apple Store offering free next-day shippi...
The Apple Store is now offering free next-day shipping on all in stock items if ordered before 12/23/14 at 10:00am PT. Local store pickup is also available within an hour of ordering for any in stock... Read more
It’s 1992 Again At Sony Pictures, Except For...
Techcrunch’s John Biggs interviewed a Sony Pictures Entertainment (SPE) employee, who quite understandably wished to remain anonymous, regarding post-hack conditions in SPE’s L.A office, explaining “... Read more
OtterBox Defender Series Case For iPad mini 3...
With their innovative Touch ID technology and ultrathin profile, the latest tranche of Apple iPads are more desirable than ever, and OtterBox has just announced the Defender Series custom-engineered... Read more
Holiday sales this weekend: MacBook Pros for...
 B&H Photo has new MacBook Pros on sale for up to $300 off MSRP as part of their Holiday pricing. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.2GHz Retina MacBook Pro: $1699... Read more

Jobs Board

*Apple* Store Leader Program (US) - Apple, I...
…Summary Learn and grow as you explore the art of leadership at the Apple Store. You'll master our retail business inside and out through training, hands-on experience, Read more
Project Manager, *Apple* Financial Services...
**Job Summary** Apple Financial Services (AFS) offers consumers, businesses and educational institutions ways to finance Apple purchases. We work with national and 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
*Apple* Retail - Multiple Positions (US) - A...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.