TweetFollow Us on Twitter


Demonstration Program Windows1

Goto Contents

// *******************************************************************************************
// Windows1.c                                                              CLASSIC EVENT MODEL
// *******************************************************************************************
// This program:
// o  Allows the user to open any number of kWindowFullZoomGrowDocumentProc windows, up to the
//    maximum specified by the constant assigned to the symbolic name kMaxWindows, using the 
//    File menu Open Command or its keyboard equivalent.
// o  Allows the user to close opened windows using the close box/button, the File menu Close
//    command or the Close command's keyboard equivalent.
// o  Adds menu items representing each window to a Windows menu as each window is opened.
//    (A keyboard equivalent is included in each menu item for windows 1 to 9.)
// o  Deletes menu items from the Windows menu as each window is closed.
// o  Fills each window with a plain colour pattern as a means of proving, for demonstration
//    purposes, the window update process.
// o  Facilitates activation of a window by mouse selection.
// o  Facilitates activation of a window by Windows menu selection.
// o  Correctly performs all dragging, zooming and sizing operations.
// o  On Mac OS 8/9, demonstrates the provision of balloon help for static windows.
// The program utilises the following resources:
// o  A 'plst' resource.
// o  An 'MBAR' resource, and 'MENU' resources for Apple/Application, File, Edit and Windows 
//    menus, (preload non-purgeable).  
// o  A 'WIND' resource (purgeable) (initially not visible).  
// o  A 'STR#' resource containing error strings and the window title (purgeable).
// o  An 'hrct' resource and an 'hwin' resource for balloon help (both purgeable).
// o  Ten 'ppat' (pixel pattern) resources (purgeable), which are used to draw a plain colour
//    pattern in the windows.
// o  A 'SIZE' resource with the acceptSuspendResumeEvents, canBackground, 
//    doesActivateOnFGSwitch, and isHighLevelEventAware flags set.
// *******************************************************************************************

// .................................................................................. includes

#include <Carbon.h>

// ................................................................................... defines

#define rMenubar          128
#define mAppleApplication 128
#define  iAbout           1
#define mFile             129
#define  iNew             1
#define  iClose           4
#define  iQuit            12
#define mWindows          131
#define rNewWindow        128
#define rStringList       128
#define  sUntitled        1
#define  eMaxWindows      2
#define  eFailWindow      4
#define  eFailMenus       5
#define  eFailMemory      6
#define rPixelPattern     128
#define kMaxWindows       10
#define kScrollBarWidth   15
#define MAX_UINT32        0xFFFFFFFF
#define MIN(a,b)          ((a) < (b) ? (a) : (b))
#define topLeft(r)        (((Point *) &(r))[0])

// .......................................................................... global variables

Boolean   gRunningOnX = false;
Boolean   gDone;
SInt32    gUntitledWindowNumber = 0;
SInt32    gCurrentNumberOfWindows = 0;
WindowRef gWindowRefArray[kMaxWindows + 2];

// ....................................................................... function prototypes

void    main                      (void);
void    doPreliminaries           (void);
OSErr   quitAppEventHandler       (AppleEvent *,AppleEvent *,SInt32);
void    eventLoop                 (void);
void    doEvents                  (EventRecord *);
void    doMouseDown               (EventRecord *);
void    doUpdate                  (EventRecord *);
void    doUpdateWindow            (EventRecord *);
void    doActivate                (EventRecord *);
void    doActivateWindow          (WindowRef,Boolean);
void    doOSEvent                 (EventRecord *);
void    doMenuChoice              (SInt32);
void    doFileMenu                (MenuItemIndex);
void    doWindowsMenu             (MenuItemIndex);
void    doNewWindow               (void);
void    doCloseWindow             (void);
void    doInvalidateScrollBarArea (WindowRef);
void    doConcatPStrings          (Str255,Str255);
void    doErrorAlert              (SInt16);
Boolean eventFilter               (DialogPtr,EventRecord *,SInt16 *);

// ************************************************************************************** main

void  main(void)
  MenuBarHandle menubarHdl;
  SInt32        response;
  MenuRef       menuRef;
  SInt16        a;

  // ........................................................................ do preliminaries


  // ............................................................... set up menu bar and menus
  menubarHdl = GetNewMBar(rMenubar);
  if(menubarHdl == NULL)

  if(response & gestaltMenuMgrAquaLayoutMask)
    menuRef = GetMenuRef(mFile);
    if(menuRef != NULL)
      DeleteMenuItem(menuRef,iQuit - 1);

    gRunningOnX = true;

  // ....................................................... initialize window reference array

    gWindowRefArray[a] = NULL;

  // ......................................................................... enter eventLoop


// *************************************************************************** doPreliminaries

void  doPreliminaries(void)
  OSErr osError;


  osError = AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,
                            NewAEEventHandlerUPP((AEEventHandlerProcPtr) quitAppEventHandler),
  if(osError != noErr)

// **************************************************************************** doQuitAppEvent

OSErr  quitAppEventHandler(AppleEvent *appEvent,AppleEvent *reply,SInt32 handlerRefcon)
  OSErr    osError;
  DescType returnedType;
  Size     actualSize;

  osError = AEGetAttributePtr(appEvent,keyMissedKeywordAttr,typeWildCard,&returnedType,NULL,0,

  if(osError == errAEDescNotFound)
    gDone = true;
    osError = noErr;
  else if(osError == noErr)
    osError = errAEParamMissed;

  return osError;

// ********************************************************************************* eventLoop

void  eventLoop(void)
  EventRecord eventStructure;

  gDone = false;


// ********************************************************************************** doEvents

void  doEvents(EventRecord *eventStrucPtr)
    case kHighLevelEvent:

    case mouseDown:

    case keyDown:
      if((eventStrucPtr->modifiers & cmdKey) != 0)

    case updateEvt:

    case activateEvt:

    case osEvt:

// ******************************************************************************* doMouseDown

void  doMouseDown(EventRecord *eventStrucPtr)
  WindowRef      windowRef;
  WindowPartCode partCode, zoomPart;
  BitMap         screenBits;
  Rect           constraintRect, mainScreenRect;
  Point          standardStateHeightAndWidth;

  partCode = FindWindow(eventStrucPtr->where,&windowRef);

    case inMenuBar:

    case inContent:
      if(windowRef != FrontWindow())

    case inDrag:

    case inGoAway:
      if(TrackGoAway(windowRef,eventStrucPtr->where) == true)

    case inGrow:   = 75; 
      constraintRect.left = 205;
      constraintRect.bottom = constraintRect.right = 32767;

    case inZoomIn:
    case inZoomOut:
      mainScreenRect = GetQDGlobalsScreenBits(&screenBits)->bounds;
      standardStateHeightAndWidth.v = mainScreenRect.bottom;
      standardStateHeightAndWidth.h = 460;

        zoomPart = inZoomIn;
        zoomPart = inZoomOut;


// ********************************************************************************** doUpdate

void  doUpdate(EventRecord *eventStrucPtr)
  WindowRef windowRef;

  windowRef = (WindowRef) eventStrucPtr->message;




// **************************************************************************** doUpdateWindow

void  doUpdateWindow(EventRecord *eventStrucPtr)
  WindowRef    windowRef;
  RgnHandle    visibleRegionHdl;
  Rect         theRect;
  SInt32       windowRefCon;
  PixPatHandle pixpatHdl;
  RGBColor     whiteColour = { 0xFFFF,0xFFFF,0xFFFF };
  SInt16       a;
  windowRef = (WindowRef) eventStrucPtr->message;

  visibleRegionHdl = NewRgn();

  theRect.right  -= kScrollBarWidth;
  theRect.bottom -= kScrollBarWidth;

  windowRefCon = GetWRefCon(windowRef);
  pixpatHdl = GetPixPat(rPixelPattern + windowRefCon);




      DrawString("\pHot Rectangle");

// ******************************************************************************** doActivate

void  doActivate(EventRecord *eventStrucPtr)
  WindowRef windowRef;
  Boolean   becomingActive;

  windowRef = (WindowRef) eventStrucPtr->message;

  becomingActive = ((eventStrucPtr->modifiers & activeFlag) == activeFlag);


// ************************************************************************** doActivateWindow

void  doActivateWindow(WindowRef windowRef,Boolean becomingActive)
  MenuRef windowsMenu;
  SInt16  menuItem, a = 1;

  windowsMenu = GetMenuRef(mWindows);

  while(gWindowRefArray[a] != windowRef)
  menuItem = a;

// ********************************************************************************* doOSEvent

void  doOSEvent(EventRecord *eventStrucPtr)
  switch((eventStrucPtr->message >> 24) & 0x000000FF)
    case suspendResumeMessage:
      if((eventStrucPtr->message & resumeFlag) == 1)

// ****************************************************************************** doMenuChoice

void  doMenuChoice(SInt32 menuChoice)
  MenuID        menuID;
  MenuItemIndex menuItem;
  menuID = HiWord(menuChoice);
  menuItem = LoWord(menuChoice);

  if(menuID == 0)

    case mAppleApplication:
      if(menuItem == iAbout)
    case mFile:
    case mWindows:


// ******************************************************************************** doFileMenu

void  doFileMenu(MenuItemIndex menuItem)
    case iNew:

    case iClose:

    case iQuit:
      gDone = true;

// ***************************************************************************** doWindowsMenu

void  doWindowsMenu(MenuItemIndex menuItem)
  WindowRef windowRef;

  windowRef = gWindowRefArray[menuItem];

// ******************************************************************************* doNewWindow

void  doNewWindow(void)
  WindowRef windowRef;
  Str255    untitledString;
  Str255    numberAsString = "\p1";
  Rect      availableBoundsRect, portRect;
  SInt16    windowHeight;
  MenuRef   windowsMenu;

  if(gCurrentNumberOfWindows == kMaxWindows)

  if(!(windowRef = GetNewCWindow(rNewWindow,NULL,(WindowRef) -1)))

  gUntitledWindowNumber += 1;
  if(gUntitledWindowNumber > 1)


  windowHeight = (availableBoundsRect.bottom - - 3;
    windowHeight -= 27;


  if(gUntitledWindowNumber < 10)
  windowsMenu = GetMenuRef(mWindows);


  gCurrentNumberOfWindows ++;
  gWindowRefArray[gCurrentNumberOfWindows] = windowRef;  

  if(gCurrentNumberOfWindows == 1)

// ***************************************************************************** doCloseWindow

void  doCloseWindow(void)
  WindowRef windowRef;
  MenuRef   windowsMenu;
  SInt16    a = 1;

  windowRef = FrontWindow();
  gCurrentNumberOfWindows --;

  windowsMenu = GetMenuRef(mWindows);
  while(gWindowRefArray[a] != windowRef)
  gWindowRefArray[a] = NULL;

    if(gWindowRefArray[a] == NULL)
      gWindowRefArray[a] = gWindowRefArray[a+1];
      gWindowRefArray[a+1] = NULL;

  if(gCurrentNumberOfWindows == 0)

// ***************************************************************** doInvalidateScrollBarArea

void  doInvalidateScrollBarArea(WindowRef windowRef)
  Rect tempRect;


  tempRect.left = tempRect.right - kScrollBarWidth;

  GetWindowPortBounds(windowRef,&tempRect); = tempRect.bottom - kScrollBarWidth;

// ************************************************************************** doConcatPStrings

void  doConcatPStrings(Str255 targetString,Str255 appendString)
  SInt16 appendLength;

  appendLength = MIN(appendString[0],255 - targetString[0]);

  if(appendLength > 0)
    BlockMoveData(appendString+1,targetString+targetString[0]+1,(SInt32) appendLength);
    targetString[0] += appendLength;

// ****************************************************************************** doErrorAlert

void  doErrorAlert(SInt16 errorType)
  AlertStdAlertParamRec paramRec;
  ModalFilterUPP        eventFilterUPP;
  Str255                labelText;
  Str255                narrativeText;
  SInt16                itemHit;

  eventFilterUPP = NewModalFilterUPP((ModalFilterProcPtr) eventFilter);

  paramRec.movable       = true;
  paramRec.helpButton    = false;
  paramRec.filterProc    = eventFilterUPP;
  paramRec.defaultText   = (StringPtr) kAlertDefaultOKText;
  paramRec.cancelText    = NULL;
  paramRec.otherText     = NULL;
  paramRec.defaultButton = kAlertStdAlertOKButton;
  paramRec.cancelButton  = 0;
  paramRec.position      = kWindowAlertPositionMainScreen;


  if(errorType == eMaxWindows)
    GetIndString(narrativeText,rStringList,errorType + 1);

// ******************************************************************************* eventFilter

Boolean  eventFilter(DialogPtr dialogPtr,EventRecord *eventStrucPtr,SInt16 *itemHit)
  Boolean handledEvent = false;
  if((eventStrucPtr->what == updateEvt) && 
     ((WindowRef) eventStrucPtr->message != GetDialogWindow(dialogPtr)))

  return handledEvent;

// *******************************************************************************************

Demonstration Program Windows1 Comments

When this program is run, the user should:

o Open and close windows using both the Open and Close commands from the File menu and their
  keyboard equivalents, noting that, whenever a window is opened or closed, a menu item
  representing that window is added to, or deleted from, the Windows menu.

o Note that keyboard equivalents are added to the menu items in the Windows menu for the first
  nine windows opened.

o Activate individual windows by both clicking the content region and pressing the keyboard
  equivalent for the window.

o Send the application to the background and bring it to the foreground, noting window

o Zoom, close, and resize windows using the zoom box/button, close box/button and size
  box/resize control, noting window updating and activation.

o On Mac OS X, note that, when a window is zoomed to the standard state, the zoom is
  constrained by the current height of the Dock.

o On Mac OS 8/9, choose Show Balloons from the Help menu and move the cursor over the hot
  rectangles in the frontmost window.

If an attempt is made to open more than 10 windows, a movable modal alert appears.


The first nine #defines establish constants representing menu IDs and resources, and window and
menu bar resources.  The next six establish constants representing the resource ID of a 'STR#'
resource and the various strings in that resource.  rPixelPattern represents the resource ID of
the first of ten 'ppat' (pixel pattern) resources.  kMaxWindows controls the maximum number of
windows allowed to be open at one time.

MAX_UINT32 is defined as the maximum possible UInt32 value.  (This will be assigned to
WaitNextEvent's sleep parameter.)  The two fairly common macros which follow are required by,
respectively, the string concatenation function doConcatPStrings and the window creation
function doNewWindow.

Global Variables

The global variable gRunningOnX will be set to true if the program is running on Mac OS X. 
gDone, when set to true, causes the main event loop to be exited and the program to terminate.

gUntitledWindowNumber keeps track of the window numbers to be inserted into the window's title
bar.  This number is incremented each time a new window is opened.  gCurrentNumberOfWindows
keeps track of how many windows are open at any one time.

In this program, CreateStandardWindowMenu is not used to create the Window menu.  The Window
menu is created in the same way as the other menus, and managed ny the program. 
gWindowRefArray[] is central to the matter of maintaining an association between item numbers
in the Window menu and the windows to which they refer, regardless of how many windows are
opened and closed, and in what sequence.  When, for example, a Window menu item is chosen, the
program must be able to locate the window object for the window represented by that menu item
number so as to activate the correct window.

The strategy adopted by this program is to assign the references for each opened window to the
elements of gWindowRefArray[], starting with gWindowRefArray[1] and leaving gWindowRefArray[0]
unused.  If, for example, six windows are opened in sequence, gWindowRefArray[1] to
gWindowRefArray[6] are assigned the references to the window objects for each of those six
windows.  (At the same time, menu items representing each of those windows are progressively
added to the Window menu.)

If, say, the third window opened is then closed, gWindowRefArray[3] is set to NULL and the
window object references in gWindowRefArray[4] to gWindowRefArray[6] are moved down in the
array to occupy gWindowRefArray[3] to gWindowRefArray[5].  Since the Window menu item for the
third window is deleted from the menu when the window is closed, there remains five windows and
their associated menu items, the "compaction" of the array having maintained a direct
relationship between the number of the array element to which each window reference is assigned
and the number of the menu item for that window. 


The first action is to call doPreliminaries, which performs certain preliminary actions common
to most applications. 

The next block sets up the menus.  Note that error handling involving the invocation of alerts
is introduced in this program.  If an error occurs, the function doErrorAlert is called to
display either a stop or caution movable modal alert advising of the nature of the error.

In the final three lines, gWindowRefArray[] is initialised  and the main event loop is entered.


Note that MoreMasterPointers is called with 224 passed in the inCount parameter to provide
sufficient master pointers for this program.


eventLoop will exit when gDone is set to true, which occurs when the user selects Quit from the
File menu.  (As an aside, note that the sleep parameter in the WaitNextEvent call is set to
MAX_UINT32, which is defined as the maximum possible UInt32 value.)


doEvents switches according to the event type received.

mouseDown, updateEvt, activateEvt and osEvt events are of significance to the windows aspects
of this demonstration.  keyDown events are significant only with regard to File and Window menu
keyboard equivalents.


doMouseDown continues the processing of mouseDown events, switching according to the part code.

The inContent case results in a call to SelectWindow if the window in which the mouse-down
occurred is not the front window.  SelectWindow:

o Unhighlights the currently active window, brings the specified window to the front and
  highlights it.

o Generates activate events for the two windows.

o Moves the previously active window to a position immediately behind the specified window.

The inDrag case results in a call to DragWindow, which retains control until the user releases
the mouse button.  The third parameter in the DragWindow call establishes the limits, in global
screen coordinates, within which the user is allowed to drag the window.  In Carbon, NULL may
be passed in this parameter.  This has the effect of setting the third parameter to the
bounding rectangle of the desktop region (also known as the "gray region").

The inGoAway case results in a call to TrackGoAway, which retains control until the user
releases the mouse button.  If the pointer is still within the close box/button when the mouse
button is released, the function doCloseWindow is called.

At the inGrow case, the first three lines establish the resizing constraints.  The top and left
fields of the Rect variable constraintRect are assigned values representing the minimum height
and width to which the window may be resized.  The bottom and right fields, which establish the
maximum height and width, are assigned the maximum possible SInt16 value.  (Since the mouse
cursor cannot be moved beyond the edges of the screen (or screens in a multi-monitor system),
these values mean that the window can be resized larger to the limits of mouse cursor

ResizeWindow retains control until the user releases the mouse button.  When the mouse button
is released, ResizeWindow redraws the window frame (that is, all but the content region) in the
new size and, where window height and/or width has been increased, adds the newly-exposed areas
of the content region to update region (on Mac OS 8/9).  (Note that, in Carbon, the fourth
(newContentRect) parameter may be set to NULL if the new dimension of the window's content
region is not required.)

The call to ResizeWindow is bracketed by two calls to the function doInvalidateScrollBarArea. 
In this program, scroll bars are not used but it has been decided to, firstly, limit update
drawing to the window's content region less the areas normally occupied by scroll bars and,
secondly, to use DrawGrowIcon to draw the draw scroll bar delimiting lines.  (For Mac OS 8/9,
this is the usual practice for windows with a size box but no scroll bars.  The DrawGrowIcon
call is ignored on Mac OS X.)

The first call to doInvalidateScrollBarArea is necessary to cater for the case where the window
is resized larger.  If this call is not made, the scroll bar areas prior to the resize will not
be redrawn by the window updating function unless these areas are programmatically added to the
new update region created by the Window Manager as a result of the resizing action.

The second call to doInvalidateScrollBarArea is necessary to cater for the case where the
window is resized smaller.  This call works in conjunction with the EraseRgn call in the
function doUpdateWindow.  The call to doInvalidateScrollBarArea results in an update event
being generated, and the call to EraseRgn in the doUpdateWindow function causes the update
region (that is, in this case, the scroll bar areas) to be erased.  (Remember that, on Mac OS
8/9, between the calls to BeginUpdate and EndUpdate, the visible region equates to the update
region and that QuickDraw limits its drawing to the update region.)

At the inZoomIn/inZoomOut case, the first action is to assign the desired height and width of
the windows's standard state content region to the fields of a Point variable.  This variable
is then passed in the second parameter of a call to IsWindowInStandardState, which sets the
variable zoomPart to either true or false depending on whether the window is currently in the
standard state or the user state.  TrackBox is then called, taking control until the user
releases the mouse button.  If the mouse button is released while the pointer is still within
the zoom box, ZoomWindowIdeal is called to zoom the window in accordance with human interface
guidelines.  The second parameter tells ZoomWindow whether to zoom out to the standard state or
in to the user state.


On Mac OS 8/9 and Mac OS X, an update event will be received:

o When the window is created.

o When the window is resized larger.

o When the window is resized smaller (because of calls to InvalWindowRect in the function

o When the window is zoomed.

On Mac OS 8/9, update events will also be received when a window has a non-empty update region.

doUpdate attends to basic window updating.  On Mac OS 8/9, the call to BeginUpdate clips the
visible region to the intersection of the visible region and the update region.  The visible
region is now a sort of proxy for the update region.  The graphics port is then set before the
function doUpdateWindow is called to redraw the content region.  On Mac OS 8/9, the EndUpdate
call restores the window's true visible region.  (The calls to BeginUpdate and EndUpdate are
ignored on Mac OS X.)


doUpdateWindow is concerned with redrawing the window's contents less the scroll bar areas.

The first action is to retrieve the window object reference from the message field of the event

The next block retrieves the handle to the window's visible region, following which EraseRgn is
called for reasons explained at doMouseDown, above.

The window's graphics port's bounding rectangle is then retrieved, following which the right
and bottom fields are adjusted to exclude the scroll bar areas.  The next four lines fill this
rectangle with a plain colour pattern provided by a 'ppat' resource, simply as a means of
proving the correctness of the window updating process.

Note the call to GetWRefCon, which retrieves the window's reference constant stored in the
window object.  As will be seen, whenever a new window is opened, a value between 1 and
kMaxWindows is stored as a reference constant in the window object.  In this function, this is
just a convenient number to be added to the base resource ID (128) in the single parameter of
the GetPixPat call, ensuring that FillCRect has a different pixel pattern to draw in each

The call to DrawGrowIcon draws the scroll bar delimiting lines (on Mac OS 8/9).  Note that this
call, the preceding EraseRgn call, and the calls to doInvalidateScrollbarArea are made for
"cosmetic" purposes only and would not be required if the window contained scroll bars.

If the program is running on Mac OS 8/9, the remaining lines draw two rectangles and some text
in the windows to visually represent to the user the otherwise invisible "hot rectangles"
defined in the 'hrct' resource and associated with the window by the 'hwin' resource.  When
Show Balloons is chosen from the Help menu, the help balloons will be invoked when the cursor
moves over these rectangles.


doActivate attends to those aspects of window activation not handled by the Window Manager.

The modifiers field of the event structure is tested to determine whether the window in
question is being activated or deactivated.  The result of this test is passed as a parameter
in the call to the function doActivateWindow.


In this demonstration, the remaining actions carried out in response to an activateEvt are
limited to placing/removing checkmarks in/from items in the Window menu.

The first step is to associate the received WindowRef with its item number in the Window menu. 
At the while loop, the array maintained for that purpose is searched until a match is found. 
The array element number at which the match is found correlates directly with the menu item
number; accordingly, this is assigned to the variable menuItem, which is used in the following
CheckMenuItem calls.  Whether the checkmark is added or removed depends on whether the window
in question is being activated or deactivated, a condition passed to the call to
doActivateWindow as its second parameter.

The call to DrawGrowIcon ensures that the scroll bar area delimiting lines will be drawn in
gray when the window is deactivated (on Mac OS 8/9).


doOSEvent handles operating system events.  In this demonstration, action is taken only in the
case of resume events.  If the event is a resume event, the cursor is set to the arrow shape.

doMenuChoice and doFileMenu

doMenuChoice switches according to the menu choices of the user.  doFileMenu switches according
to the File menu item choice of the user.


doWindowsMenu takes the item number of the selected Window menu item and, since this equates to
the number of the array element in which the associated window object reference is stored,
extracts the window object reference associated with the menu item.  This is used in the call
to SelectWindow, which generates the activateEvts required to activate and deactivate the
appropriate windows.


doNewWindow opens a new window and attends to associated tasks.

In the first block, if the current number of open windows equals the maximum allowable
specified by kMaxWindows, a caution movable modal alert is called up via the function
doErrorAlert (with the string represented by eMaxWindows displayed) and an immediate return is
executed when the user clicks the alert's OK button.

At the next block, the new window is created by the call to GetNewCWindow.  The third parameter
specifies that the window is to be opened in front of all other windows.  If the call is not
successful for any reason, a stop movable modal alert is called up via the function
doErrorAlert (with the string represented by eFailWindow displayed) and the program terminates
when the user clicks the alert's OK button.

The next seven lines create the string which will be used to set the window's title.  The code
reflects the fact that Aqua Human Interface Guidelines require that a number only be appended
to "untitled" for the second and later windows.  Accordingly, concatenating a number to the
string "untitled" is not effected for the first window created.

GetIndString retrieves the string "untitled " from the specified 'STR#' resource and the global
variable which keeps track of the numbers for the title bar is incremented.  If this is not the
first window to be created, NumToString converts that number to a Pascal string and this string
is concatenated to the "untitled " string.  The SetWTitle call then sets the window's title.

The next block sets adjusts the size of the window before it is displayed.  The width is set to
460 pixels and the height is adjusted according to the available screen real estate.

The call to GetAvailableWindowPositioningBounds returns, in global coordinates, the available
real estate on the main screen (device).  This excludes the menu bar and, on Mac OS X, the
Dock.  The call to SetPortWindowPort sets the window's graphics port as the current port, a
necessary precursor to the call to LocalToGlobal, which converts the top-left (local)
coordinates of the port rectangle to global coordinates.  The height of the rectangle returned
by GetAvailableWindowPositioningBounds is then reduced by the distance of the top of the port
rectangle from the top of the screen, and then further reduced by three.  On Mac OS X, this
will cause the bottom of the window to be just above the top of the Dock.  If the program is
running on Mac OS 8/9, the height is reduced by a further 27 pixels to accommodate the height
of the control strip.  The call to SizeWindow sets the window's size.  (The window's location
is determined by the positioning specification in the window's 'WIND' resource.)

The ShowWindow call makes the window visible.

The next block adds the metacharacter \ and the window number to the string used to set the
window title (thus setting up the Command key equivalent) before InsertMenuItem is called to
create a new menu item to the Window menu.  Note that the Command-key equivalent is only added
for the first nine windows opened.)

The SetWRefCon call stores the value represented by gCurrentNumberOfWindows in the window
object as the window's reference constant.  As previously stated, in this demonstration this is
used to select a pixel pattern to draw in each window's content region.

At the next two lines, the variable which keeps track of the current number of opened windows
is incremented and the appropriate element of the window reference array is assigned the
reference to newly opened window's window object.

The last block enables the Window menu and the Close item in the File menu when the first
window is opened.


The function doCloseWindow closes an open window and attends to associated tasks.

At the first two lines, a reference to the frontmost window's window object is retrieved and
passed in the call to DisposeWindow.  DisposeWindow removes the window from the screen, removes
it from the window list, and discards all its data storage.  With the window closed, the global
variable that keeps track of the number of windows currently open is decremented.

The next block deletes the associated menu item from the Window menu.  At the first four lines,
the array element in which the window object reference in question is located is searched out,
the element number (which correlates directly with the menu item number) is noted and the
element is set to NULL.  The call to DeleteMenuItem then deletes the menu item.

The for loop "compacts" the array, that is, it moves the contents of all elements above the
NULLed element down by one, maintaining the correlation with the Windows menu.

The last block disables the Windows menu and the Close item in the File menu if no windows
remain open as a result of this closure.


doInvalidateScrollBarArea invalidates that part of the window's content area which would
ordinarily be occupied by scroll bars.  The function simply retrieves the coordinates of the
content area into a local Rect and reduces this Rect to the relevant scroll bar area before
invalidating that area, that is, adding it to the window's update region.


The function doConcatPStrings concatenates two Pascal strings.

doErrorAlert and eventFilter

doErrorAlert displays either a caution alert or a stop alert with a specified string (two
strings in the case of the eMaxWindows error) extracted from the 'STR#' resource identified by
rStringList.  eventFilter supports doErrorAlert.

The creation of alerts using the StandardAlert function, and event filter functions, are
addressed at Chapter 8.

Community Search:
MacTech Search:

Software Updates via MacUpdate

Apple Remote Desktop Client 3.9 - Client...
Apple Remote Desktop Client is the best way to manage the Mac computers on your network. Distribute software, provide real-time online help to end users, create detailed software and hardware reports... Read more
Art Text 3.2.2 - $49.99
Art Text is graphic design software specifically tuned for lettering, typography, text mockups and various artistic text effects. Supplied with a great variety of ready to use styles and materials,... Read more
WhatRoute 2.0.15 - Geographically trace...
WhatRoute is designed to find the names of all the routers an IP packet passes through on its way from your Mac to a destination host. It also measures the round-trip time from your Mac to the router... Read more
Sparkle 2.1.1 - $79.99
Sparkle will change your mind if you thought building websites wasn't for you. Sparkle is the intuitive site builder that lets you create sites for your online portfolio, team or band pages, or... Read more
Dash 4.0.1 - Instant search and offline...
Dash is an API documentation browser and code snippet manager. Dash helps you store snippets of code, as well as instantly search and browse documentation for almost any API you might use (for a full... Read more
TextSoap 8.3.2 - Automate tedious text d...
TextSoap can automatically remove unwanted characters, fix up messed up carriage returns, and do pretty much anything else that we can think of to text. Save time and effort. Be more productive. Stop... Read more
Apple Remote Desktop 3.9 - Remotely cont...
Apple Remote Desktop is the best way to manage the Mac computers on your network. Distribute software, provide real-time online help to end users, create detailed software and hardware reports, and... Read more
Paragraphs 1.1.4 - Writing tool just for...
Paragraphs is an app just for writers. It was built for one thing and one thing only: writing. It gives you everything you need to create brilliant prose and does away with the rest. Features... Read more
Amazon Chime 4.0.5528 - Amazon-based com...
Amazon Chime is a communications service that transforms online meetings with a secure, easy-to-use application that you can trust. Amazon Chime works seamlessly across your devices so that you can... Read more
Apple Final Cut Pro X 10.3.2 - Professio...
Apple Final Cut Pro X is a professional video editing solution.Completely redesigned from the ground up, Final Cut Pro adds extraordinary speed, quality, and flexibility to every part of the post-... Read more

Blasty Bubs is a colorful Pinball and Br...
QuickByte Games has another arcade treat in the works -- this time it's a mishmash of brick breaking and Pinball mechanics. It's called Blasty Bubs, and it's a top down brickbreaker that has you slinging balls around a board. [Read more] | Read more »
Corsola and Heracross are the new region...
Generation 2 finally launched in Pokémon GO, unleashing a brand new batch of Pokémon into the wild. Even before the update went live people were speculating on how to catch elusive Pokémon like the legendary "dogs", Unknown, and whether or not... | Read more »
The Warlock of Firetop Mountain (Games)
The Warlock of Firetop Mountain 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: An epic adventure through a mysterious mountain filled with monsters, magic and mayhem! “ looks downright... | Read more »
Fantasy MMORPG MU Origin’s receives a hu...
Developer Webzen are looking to take their highly popular fantasy battler MU Origin to the next level this month, with its most ambitious overhaul yet. The latest update introduces the long sought after Server Arena, new treasure dungeons, and much... | Read more »
RPG Djinn Caster (Games)
RPG Djinn Caster 1.0.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0.0 (iTunes) Description: SPECIAL PRICE 38% OFF(USD 7.99 -> USD 4.99)!!!A Fantasy Action RPG of far foreign lands! Summon the Djinns and rise to... | Read more »
Alto's Odyssey gets its first trail...
There's finally video evidence of Alto's Odyssey, the follow up to the 2015 App Store hit, Alto's Adventure. It looks just as soothing and atmospheric as Alto's last outing, but this time players will be journeying to the desert. Whereas Alto's... | Read more »
Last week on Pocket Gamer
What’s going on in the wider world of portable gaming? Each week we ask that question of our sister website Pocket Gamer. The PG team covers iOS gaming, just like 148Apps, but it also strays into the world of Android games and handheld consoles... | Read more »
Pokémon GO Generation 2 evolution guide
At long last, Niantic Labs finally unleashed the Generation 2 Pokémon into the wild. Pokémon GO trainers are scrambling to grab up this new set of 80 Pokémon. There are some special new tricks required to catch all of these new beasties, though.... | Read more »
The best new games we played this week
It feels as though the New Year got off to a creaking start as far as mobile games go, but that's changed over the past few weeks. The last few days alone have seen the debut of a number of wonderful games, so we thought we'd take the time to... | Read more »
Recruit more scallywags and discover new...
Get ready to show off your sea legs all over again in Oceans & Empires’ new grand update, which aims to make the act of rising to the role of seven seas ruler even more fresh and appealing, thanks to a richness of new content on both iOS and... | Read more »

Price Scanner via

27-inch Apple iMacs on sale for up to $200 of...
B&H Photo has 27″ Apple iMacs on sale for up to $200 off MSRP, each including free shipping plus NY sales tax only: - 27″ 3.3GHz iMac 5K: $2099.99 $200 off MSRP - 27″ 3.2GHz/1TB Fusion iMac 5K: $... Read more
15-inch 2.2GHz Retina MacBook Pro on sale for...
Amazon has 2015 15″ 2.2GHz Retina MacBook Pros (MJLQ2LL/A) available for $1849.99 including free shipping. Apple charges $1999 for this model, so Amazon’s price is represents a $150 savings. Read more
Apple refurbished iPad Air 2s available start...
Apple has Certified Refurbished iPad Air 2 WiFis available for starting at $319 including free shipping. A standard Apple one-year warranty is included: - 16GB iPad Air 2 WiFi: $319 $60 off original... Read more
Apple refurbished iPad Pros available for up...
Apple has Certified Refurbished 9″ and 12″ Apple iPad Pros available for up to $160 off the cost of new iPads. An Apple one-year warranty is included with each model, and shipping is free: - 32GB 9″... Read more
Apple restocks refurbished 2015 and 2016 13-i...
Apple has Certified Refurbished 2015 and 2016 13″ MacBook Airs available starting at $759. An Apple one-year warranty is included with each MacBook, and shipping is free: - 2016 13″ 1.6GHz/8GB/128GB... Read more
13-inch 2.5GHz MacBook Pro (Apple refurbished...
Apple has Certified Refurbished 13″ 2.5GHz MacBook Pros (MD101LL/A) available for $829, or $270 off original MSRP. Apple’s one-year warranty is standard, and shipping is free: - 13″ 2.5GHz MacBook... Read more
QuickerTek Announces 5TB Apple AC AirPort Tim...
QuickerTek Inc. has announced their new 5TB hard drive upgrade for Apple’s AC AirPort Time Capsule. By customer request, this upgrade also features six external antennas and offers the highest... Read more
Apple Certified Refurbished iMacs available f...
Apple has Certified Refurbished 2015 21″ & 27″ iMacs available for up to $350 off MSRP. Apple’s one-year warranty is standard, and shipping is free. The following models are available: - 21″ 3.... Read more
Apple offering Certified Refurbished Series 1...
Apple is now offering Certified Refurbished Series 1 and Series 2 Apple Watches for 14-16% off MSRP, starting at $229. An Apple one-year warranty is included with each watch. Shipping is free: Series... Read more
1.4GHz Mac mini on sale for $449, save $50
B&H Photo has the 1.4GHz Mac mini on sale for $50 off MSRP including free shipping plus NY sales tax only: - 1.4GHz Mac mini: $449 $50 off MSRP Read more

Jobs Board

*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Manager *Apple* Systems Administration - Pu...
Req ID 3315BR Position Title Manager, Apple Systems Administration Job Description The Manager of Apple Systems Administration oversees the administration and Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Manager *Apple* Systems Administration - Pu...
Req ID 3315BR Position Title Manager, Apple Systems Administration Job Description The Manager of Apple Systems Administration oversees the administration and Read more
*Apple* Technician - nfrastructure (United S...
Let’s Work Together Apple Technician This position is based in Portland, ME Life at nfrastructure At nfrastructure, we understand that our success results from our Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.