TweetFollow Us on Twitter

MicroApp 2
Volume Number:6
Issue Number:1
Column Tag:Jörg's Folder

C++ Micro-application

By Jörg Langowski, MacTutor Editorial Board

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

“C++ micro-application, part 2”

We’ll expand the micro-application that I presented last month by adding more functionality to the windows this time. But first, let me review some discussions that started on our Calvacom bulletin board after my first introduction to C++. The way I defined my matrix operations, it seems, wasn’t totally in the C++ spirit; there was a reason for this, which I forgot to explain.

The problem is that our matrix operators must return a result somehow. If you define the operator the intuitive way:

// 1

matrix  matrix::operator* (matrix& a)
{
 if (cols != a.rows)
 error(“class matrix: size mismatch in *”);
 matrix c(rows,a.cols);
 for (register int i=0 ; i<rows; i++)
 for (register int j=0 ; j<a.cols; j++)
 {
 register float sum = 0;
 for (register int k=0 ; k<cols; k++)
 sum = sum + elem(i,k)*a.elem(k,j);
 c(i,j) = sum;
 }
 return c;
}

the result matrix is allocated locally first, the product computed and stored into the local object, and the whole matrix is copied as soon as it is assigned to another variable of type matrix- like in matrix x = a*b, where x is newly created in the assignment, or in x = a*b, where x has been defined previously. That the local object is destroyed as soon as one leaves the operator’s scope and a copy be made for use in the scope that called the operator is required by C++. But the copy operation may take a long time with big arrays, and in most cases it won’t be necessary because the result has already been computed and the memory allocated.

One solution - which I chose - was not to return an object as a result, but a reference to it:

//2

matrix& matrix::operator* (matrix& a)
{
 if (cols != a.rows)
 error(“class matrix: size mismatch in *”);
 matrix& c = *new matrix(rows,a.cols);
 for (register int i=0 ; i<rows; i++)
 for (register int j=0 ; j<a.cols; j++)
 {
 register float sum = 0;
 for (register int k=0 ; k<cols; k++)
 sum = sum + elem(i,k)*a.elem(k,j);
 c(i,j) = sum;
 }
 return c;
}

Here, the space for the result is allocated through the new() operation, which creates memory space that is not automatically destroyed as one leaves the operator’s context. Now, however, the system will never know when to free the space associated with the matrix, unless you tell it to do so by calling delete(). This precludes usage of those operators in any complex formulas, because intermediate results will be stored in matrix-type objects that are never accessible and can therefore never be deleted.

Alain Richard (on Calvacom) has raised these points, and others:

“ Constructors/destructors allow the use of data structures without having to care about initialization/ termination code. For instance, a first version of a class X might not need such code while the second version might need it; a program using class X can be recompiled without modification in both cases.

When a result of type matrix is produced, a 500*500 matrix is not passed back through the stack; only the data structure which defines it and contains a pointer to the data. The only problem is that the constructor will often copy the data unnecessarily; but the current definition of C++ doesn’t allow a better solution.”

Alain proposes to use procedures instead of operators for functions in which the programmer has to clean up intermediate results explicitly. One possibility, but this gives up the last advantage of operators, shortness of notation.

He has some more comments on bugs and deficiencies:

“ In C++, the only way to pass a result is through the return statement, even though the result is a function parameter. However, since one doesn’t know its name, one has to go through an intermediate variable R and then copy R into the actual result.

One should also note that the code that CFront generates isn’t very well optimized (a euphemism), or that the preprocessor relies too much on the efficiency of the C compiler, in our case MPW C 3.1b1. Some observations I made in the code generated by CFront:

CFront doesn’t optimize the use of intermediate variables and creates them for each new expression. Then, these variables are freed only at the end of the block containing the expression, which is stupid because it blocks memory.

A lot of dead code is generated by CFront. Usually, such code should be removed by the C compiler, but that is unfortunately not the case. For instance:

//3

struct A { A() {} };

struct B:A { B() {} };

main()
{
 B b;
}

The declaration of b causes 30 lines of assembler code to be generated which don’t do anything [in fact, when I checked it there seemed to be even more dead code - JL].

For the maintenance of virtual methods of a class A, CFront creates a method dispatch table. The table, named __A_vtbl, is stored together with the application code. In addition, CFront creates a global variable __A_ptbl, a pointer to __A_vtbl. This global is later used to initialize a hidden instance of each variable of type A. __A_vtbl and __A_ptbl are stored as globals, which prohibits the use of classes for DAs, CDEFs, LDEFs, etc.

I have found one or two bugs: it is not always possible to declare a variable inside an expression (produces a syntax error). There is also a problem with pointers to base class member functions in the case of multiple inheritance. That error is easy to circumvent but causes a run time, not a compilation error.

This is not an exhaustive list, but unfortunately shows that the MPW compilers are not quite mature yet. But even with the bad code quality, CFront does at least exist. At any rate, C++ is going to be the most important development language for the next years.”

I almost agree with the last statement - however, I am also getting very curious about Eiffel, a new OOP-language which is rumored to be available for the Mac next year.

Zoom, grow and scroll for MacTutorApp

The skeleton application that I presented last month did not do much; the window could not be resized or zoomed, and there were no controls such as scroll bars present. This month we’ll expand the application by adding these functions. We’ll use the definitions that we made last time, and create a new subclass of MacTutorDocument, MacTutorGrow.

The interest of the object-oriented approach is, of course, that we can reuse most of the code that we have already defined in the previous example. Only those functions which are specific to our new document will have to be redefined.

Placeholders for these functions exist already in the TDocument class definition, which is part of the C++ examples that come with Apple’s C++ system. That definition is quite long, an we don’t need to reprint it here; all I show (listing 1) is the header file that constitutes the interface. You see that entries exist for methods such as DoContent, DoGrow and DoZoom. These methods will be called from the main event loop, so if you define your own document class with a non-empty DoContent method and a mouse click occurs inside the content region of the document window, that method will be called automatically.

Therefore, the changes we have to do to previous month’s example are quite simple: the main program will still be an object of type TMacTutorApp, but the document opened will be of a new class, which we call TMacTutorGrow. Then we only have to change a few lines in the main program definition of TMacTutorApp, as you see in listing 3. If someone had already defined a document class for us that handles scrolling and resizing, that is all we would have to do to make the application work with that new type of document window.

Unfortunately, we still have to do that work, and I won’t claim I did a perfect job of scrolling the display message around in the example window; window resizing and drawing of the controls works OK, but the scrolling still leaves something to be desired. Only when the window actually gets redrawn on an update event is the contents displayed correctly. You’re, of course, invited to improve on my example.

Listing 2 shows the definition of the TMacTutorGrow class - the header file - followed by the actual code. We derive TMacTutorGrow from TMacTutorDocument (see last column), adding some private variables and methods, and overriding some of the public methods in TDocument.

The first thing to note is that we define some functions that are not methods of any particular class for scroll bar handling (this is the approach Apple took for its TEDocument example). To indicate to the compiler that these functions are defined in C, their prototype definitions are enclosed in curly brackets and prefixed by extern “C”. This is a feature of the 2.0 implementation of C++ and not mentioned in Stroustrup’s book.

The class implementation follows, first we need to define the constructor and destructor. The constructor of a subclass is called after the constructor of its ancestor; therefore all that is left to do is to get the scroll bar resources, insert the controls into the window, and initialize their values. The display string (our document’s “contents”) is passed on to the ancestor’s constructor. The destructor will dispose the controls; disposing of the window is taken care of by the superclass.

For the DoUpdate method, we replicate the definition from the TMacTutorDocument class, because our DrawWindow method has changed. In this case, the display string and the controls are redrawn. I had to change the fDisplayString variable from the TMacTutorDocument class from private to protected, so that the derived class could access it. The other possibility would have been to go through the interface that I provided and use the method GetDisplayString.

The DoActivate method invalidates the control and grow rectangles when the window is activated, so that they get redrawn on the next update event. On deactivation, the controls are hidden.

Several methods are provided for redrawing the scroll bars in their correct position; they are needed by the DoGrow and DoZoom methods. The main work is done by the routine AdjustScrollSizes, which calculates the control positions from the port rectangle of the window and moves the controls into their places. AdjustScrollValues simply resets the controls to their initial values; in a real-world application, one would insert code here that calculates the correct maximum, minimum and control settings from the properties of the window’s contents (e.g. number of lines in a text, size of a picture).

DoZoom zooms the window, then repositions the scroll bars and invalidates all of the window’s contents except for the control rectangles. The update event will then take care of redrawing. DoGrow works in the same way, only the update region is calculated through an intersection of the old and the new window’s port rectangles, the standard method that’s already been described in IM Vol.I.

DoContent is where scrolling is handled. I implemented scrolling through a call to ScrollRect and a resetting of the origin of the GrafPort. This means that the controls have to be repositioned after the scrolling, otherwise they are redrawn outside the window (the SetOrigin made them scroll with the rest of the contents). Therefore, a call to AdjustScrollSizes() is made after the control value has changed and the window has been scrolled.

The thumb region and up/down arrows with page regions are handled separately; for the thumb region, the window adjustment can be made after the control has been released, while the arrows and page fields have to respond continuously while the mouse button is down. This is done through a control action procedure, which is defined as an external routine and not a class method. (This is the way Apple implemented it in their example; I don’t know whether a pointer to a class method can be passed as a filter procedure to a toolbox routine). The control action routines, whose prototypes had been defined at the start of the program, are implemented at the end of listing 2.

There are certainly a few bugs left in my example, and the scrolling leaves much to be desired but take this as a challenge for improving the example. We’ll expand this application with other features as we proceed in our tutorials. Until then.

Listing 1:  Apple’s TDocument class standard definitions

class TDocument : HandleObject {
protected:
 WindowPtr fDocWindow;

public:
 TDocument(short resID);  virtual ~TDocument();
 // you will need to override these in your subclasses,
 // since they are do-nothing routines by default...
 virtual void DoZoom(short partCode) {}
 virtual void DoGrow(EventRecord* theEvent) {}
 virtual void DoContent(EventRecord* theEvent) {}
 virtual void DoKeyDown(EventRecord* theEvent) {}
 virtual void DoActivate(Boolean becomingActive) {}
 virtual void DoUpdate(void) {}
 // file handling routines
 virtual void DoOpen(void) {};
 virtual void DoClose(void) { delete this; };
 // by default, we just delete ourself 
 // & let destructor do cleanup
 virtual void DoSave(void) {};
 virtual void DoSaveAs(void) {};
 virtual void DoRevert(void) {};
 virtual void DoPrint(void) {};
 // do standard edit menu actions
 virtual void DoUndo(void) {};
 virtual void DoCut(void) {};
 virtual void DoCopy(void) {};
 virtual void DoPaste(void) {};
 virtual void DoClear(void) {};
 virtual void DoSelectAll(void) {};

 // idle time routines: 
 // you can use these to do cursor handling,
 // TE caret blinking, marquee effects, etc...
 virtual void DoIdle(void) {};
 virtual unsigned long CalcIdle(void) 
 { return kMaxSleepTime; };
 // by default, we don’t need idle
 virtual void AdjustCursor(Point where) {};
 // where is in local coords

 // query state of document - 
 // useful for adjusting menu state
 virtual Boolean HaveUndo(void) { return false; };
 virtual Boolean HaveSelection(void) { return false; };
 virtual Boolean HavePaste(void) { return false; };
 virtual Boolean CanClose(void) { return true; };
 virtual Boolean CanSave(void) { return false; };
 virtual Boolean CanSaveAs(void) { return true; };
 virtual Boolean CanRevert(void) { return false; };
 virtual Boolean CanPrint(void) { return false; };

 // utility routine to get window pointer for document
 inline WindowPtr GetDocWindow(void) 
 { return fDocWindow; }
};
Listing 2: Our MacTutorGrow class, overriding some of TDocument’s methods

// MacTutorGrow definitions
// subclass of MacTutorDocument that adds 
// scroll, grow and zoom

#define rVScroll 128 /* vertical scrollbar control */
#define rHScroll 129 /* horizontal scrollbar control*/
class TMacTutorGrow : public TMacTutorDocument {
 
  private:
 ControlHandle fDocVScroll; // vertical scrollbar
 ControlHandle fDocHScroll; // horizontal scrollbar
 void AdjustViewRect(void);
 void ResizeWindow(void);
 void AdjustScrollSizes(void);
 void AdjustScrollbars(Boolean needsResize);
 void AdjustScrollValues(Boolean mustRedraw);
 void DrawWindow(void);
 
  public:
 TMacTutorGrow(short resID,StringPtr s);
 ~TMacTutorGrow(void);
 // new methods, override previous ones
 void DoZoom(short partCode);
 void DoGrow(EventRecord* theEvent);
 void DoContent(EventRecord* theEvent);
 void DoUpdate(void);
 void DoActivate(Boolean becomingActive);
};

#include <Types.h>
#include <QuickDraw.h>
#include <Fonts.h>
#include <Events.h>
#include <OSEvents.h>
#include <Controls.h>
#include <Windows.h>
#include <Menus.h>
#include <TextEdit.h>
#include <Dialogs.h>
#include <Desk.h>
#include <Scrap.h>
#include <ToolUtils.h>
#include <Memory.h>
#include <SegLoad.h>
#include <Files.h>
#include <OSUtils.h>
#include <Traps.h>
#include <StdLib.h>

#include “TDocument.h”
#include “TApplication.h”
#include “MacTutorApp.h”
#include “MacTutorDoc.h”
#include “MacTutorGrow.h”

// consts for scroll bar and grow box size adjustment
const short kScrollbarAdjust = 15;
const short kGrowboxAdjust = 15;
const short kScrollbarWidth = 16;
const short kScrollTweek = 2;
const short kControlVisible = 0xFF;

extern “C” { 
 // prototypes for functions outside of classes
 void CommonAction (ControlHandle control,
 short* amount);
 pascal void VActionProc(ControlHandle control,
 short part);
 pascal void HActionProc(ControlHandle control,
 short part);
};

// methods for the MacTutorGrow class

// create and delete document windows
// override methods from MacTutorDocument
// The base class creates the window and 
// sets the display string.
// We try to get the controls, and display an error if we can’t
//
TMacTutorGrow::TMacTutorGrow
 (short resID, StringPtr s) : (resID,s)
{
 Boolean good;
 fDocVScroll = GetNewControl(rVScroll, fDocWindow);
 good = (fDocVScroll != nil);
 if ( good)
   {
 fDocHScroll = GetNewControl (rHScroll, fDocWindow);
 good = (fDocHScroll != nil);
   }
 if ( good )// good? -- set & draw the controls
   {
 AdjustScrollValues(true);
   }
 else
   {
 // tell user we failed
 HideWindow(fDocWindow);
 AlertUser(kErrStrings,eNoWindow); 
   }
}

TMacTutorGrow::~TMacTutorGrow(void)
{
 HideWindow(fDocWindow);
 if ( fDocVScroll != nil )
   DisposeControl(fDocVScroll);
 if ( fDocHScroll != nil )
   DisposeControl(fDocHScroll);
}

void TMacTutorGrow::DoUpdate(void)
{

 BeginUpdate(fDocWindow);
 if ( ! EmptyRgn(fDocWindow->visRgn) ) 
   DrawWindow();
 EndUpdate(fDocWindow);
}

void TMacTutorGrow::DrawWindow(void)
{
 Rect tRect;
 SetPort(fDocWindow);
 tRect = fDocWindow->portRect;
 tRect.bottom = tRect.bottom - kScrollbarAdjust;
 tRect.right = tRect.right - kScrollbarAdjust;
 EraseRect(&tRect);
 
 MoveTo(100,100);
 TextSize(18); TextFont(monaco);
 DrawString(fDisplayString);
 DrawControls(fDocWindow);
 DrawGrowIcon(fDocWindow);

} // DrawWindow

void TMacTutorGrow::DoActivate
 (Boolean becomingActive)
{
 if ( becomingActive )
   {
 Rect growRect;
 Rect tRect;

 /* the controls must be redrawn on activation: */
 (*fDocVScroll)->contrlVis = kControlVisible;
 (*fDocHScroll)->contrlVis = kControlVisible;
 // copy rectangles to avoid 
 // unsafe object field references!
 tRect = (*fDocVScroll)->contrlRect; 
 InvalRect(&tRect);
 tRect = (*fDocHScroll)->contrlRect; 
 InvalRect(&tRect);
 // the growbox needs to be redrawn on activation:
 growRect = fDocWindow->portRect;
 // adjust for the scrollbars
 growRect.top = growRect.bottom - kScrollbarAdjust;
 growRect.left = growRect.right - kScrollbarAdjust;
 InvalRect(&growRect);
   }
 else
   {    
 /* the controls must be hidden on deactivation: */
 HideControl(fDocVScroll);
 HideControl(fDocHScroll);
 // we draw grow icon immediately, 
 // since we deactivate controls
 // immediately, and the update delay looks funny
 DrawGrowIcon(fDocWindow);
   }
}

void TMacTutorGrow::AdjustScrollSizes(void)
{
 MoveControl(fDocVScroll, 
 fDocWindow->portRect.right - kScrollbarAdjust, 
 fDocWindow->portRect.top);
 SizeControl(fDocVScroll, kScrollbarWidth,
 fDocWindow->portRect.bottom - 
 fDocWindow->portRect.top -
 kGrowboxAdjust + kScrollTweek);
 MoveControl(fDocHScroll, 
 fDocWindow->portRect.left, fDocWindow->portRect.bottom - kScrollbarAdjust);
 SizeControl(fDocHScroll,
 fDocWindow->portRect.right - 
 fDocWindow->portRect.left -
 kGrowboxAdjust + kScrollTweek,
 kScrollbarWidth);
} // AdjustScrollSizes

void TMacTutorGrow::AdjustScrollbars
 (Boolean needsResize)
{
 (*fDocVScroll)->contrlVis = 0;
 (*fDocHScroll)->contrlVis = 0;
 if ( needsResize )  AdjustScrollSizes();
 AdjustScrollValues(needsResize);
 (*fDocVScroll)->contrlVis = 0xff;
 (*fDocHScroll)->contrlVis = 0xff;
} // AdjustScrollbars 

void TMacTutorGrow::AdjustScrollValues
 (Boolean mustRedraw)
// always reset the controls to the same values. In reality,
// you would calculate reasonable control values here 
// from the contents of your document
{
 SetCtlMin(fDocVScroll,0);
 SetCtlMax(fDocVScroll,1000);
 SetCtlValue(fDocVScroll,500);
 SetCtlMin(fDocHScroll,0);
 SetCtlMax(fDocHScroll,1000);
 SetCtlValue(fDocHScroll,500);
 if ( mustRedraw )
 {
 ShowControl(fDocVScroll);
 ShowControl(fDocHScroll);
 }
} // AdjustScrollValues

void TMacTutorGrow::DoZoom(short partCode)
{
 Rect tRect;

 tRect = fDocWindow->portRect;
 EraseRect(&tRect);
 ZoomWindow(fDocWindow, partCode, 
 fDocWindow == FrontWindow());
 AdjustScrollbars(true);  // adjust, redraw anyway 
 InvalRect(&tRect);// invalidate the whole content 
 // revalidate scroll bars 
 tRect = (*fDocVScroll)->contrlRect;
 ValidRect(&tRect);
 tRect = (*fDocHScroll)->contrlRect;
 ValidRect(&tRect);
}

void TMacTutorGrow::DoGrow(EventRecord* theEvent)
{
 long growResult;
 Rect tRect, tRect2;
 
 tRect = qd.screenBits.bounds;
 tRect.left = kMinDocDim;
 tRect.top = kMinDocDim;
 tRect2 = fDocWindow->portRect;
 tRect2.bottom = tRect2.bottom - kScrollbarAdjust;
 tRect2.right = tRect2.right - kScrollbarAdjust;
 growResult = GrowWindow
 (fDocWindow, theEvent->where, &tRect);
 // see if it really changed size 
 if ( growResult != 0 )
   {
 SizeWindow (fDocWindow, 
 LoWrd(growResult), HiWrd(growResult), true);
 AdjustScrollbars(true);
 // calculate & validate the region 
 // that hasn’t changed so it won’t get redrawn
 // Note: we copy rectangles so that we don’t 
 // take address of object fields.
 tRect = fDocWindow->portRect; 
 (void) SectRect(&tRect, &tRect2, &tRect2);
 InvalRect(&tRect); ValidRect(&tRect2);
 tRect2 = (*fDocVScroll)->contrlRect;
 ValidRect(&tRect2);
 tRect2 = (*fDocHScroll)->contrlRect; 
 ValidRect(&tRect2);
 // redraw grow icon
 tRect.top = tRect.bottom - kScrollbarAdjust;
 tRect.left = tRect.right - kScrollbarAdjust;
 InvalRect(&tRect);
   }
}

void TMacTutorGrow::DoContent(EventRecord* theEvent)
{
 Point mouse;
 ControlHandle control;
 short part, value;
 Rect tRect;
 
 SetPort(fDocWindow);
 mouse = theEvent->where;
 GlobalToLocal(&mouse);
 
 tRect = fDocWindow->portRect; 
 tRect.bottom = tRect.bottom - kScrollbarAdjust;
 tRect.right = tRect.right - kScrollbarAdjust;
 part = FindControl(mouse, fDocWindow, &control);
 switch ( part )
 {
 case 0: break;
 case inThumb:
 value = GetCtlValue(control);
 part = TrackControl(control, mouse, nil);
 if ( part != 0 )
 {
 value -= GetCtlValue(control);
 // value now has CHANGE in value; 
 // if value changed, scroll 
 if ( value != 0 )
 {
 if ( control == fDocVScroll )
 {
   ScrollRect (&tRect, 0, value, nil);
   SetOrigin (tRect.left,tRect.top-value);
 }
 else 
 {
   ScrollRect (&tRect, value, 0, nil);
   SetOrigin (tRect.left-value,tRect.top);
 }
 AdjustScrollSizes();
 }
 }
 break; 
 default: // clicked in an arrow, so track & scroll 
 if ( control == fDocVScroll )
 value = TrackControl
 (control, mouse, (ProcPtr) VActionProc);
 else value = TrackControl
 (control, mouse, (ProcPtr) HActionProc);
 AdjustScrollSizes();
 break;
 }
}

// routines that do not belong to any particular class. 

// Common algorithm for changing the value of a control. 
// It returns the value by which the control changed.

void CommonAction(ControlHandle control,short* amount)
{
 short value, max;
 
 value = GetCtlValue(control);
 max = GetCtlMax(control);
 *amount = value - *amount;
 if ( *amount <= 0 ) *amount = 0;
 else if ( *amount >= max ) *amount = max;
 SetCtlValue(control, *amount);
 *amount = value - *amount;
} // CommonAction 

pascal void VActionProc(ControlHandle control,short part)
{
 short  amount;
 WindowPtrwindow;
 Rect tRect;

 if ( part != 0 )
   {
 window = (*control)->contrlOwner;
 tRect = window->portRect; 
 tRect.bottom = tRect.bottom - kScrollbarAdjust;
 tRect.right = tRect.right - kScrollbarAdjust;
 switch ( part )
   {
 case inUpButton:
 case inDownButton:  // 5 pixels
 amount = 5;
 break;
 case inPageUp:  // 50 pixels
 case inPageDown:
 amount = 50;
 break;
   }
 if ((part == inDownButton) || (part == inPageDown))
 amount = -amount;  // reverse direction 
 CommonAction(control, &amount);
 if ( amount != 0 )
 {
 ScrollRect (&tRect, 0, amount, nil);
 SetOrigin(tRect.left,tRect.top-amount);
 }
   }
} // VActionProc 

pascal void HActionProc(ControlHandle control,short part)
{
 short  amount;
 WindowPtrwindow;
 Rect tRect;

 if ( part != 0 )
   {
 window = (*control)->contrlOwner;
 tRect = window->portRect; 
 tRect.bottom = tRect.bottom - kScrollbarAdjust;
 tRect.right = tRect.right - kScrollbarAdjust;
 switch ( part )
   {
 case inUpButton:
 case inDownButton:  // 5 pixels
 amount = 5;
 break;
 case inPageUp:  // 50 pixels
 case inPageDown:
 amount = 50;
 break;
   }
 if ((part == inDownButton) || (part == inPageDown))
 amount = -amount;  // reverse direction 
 CommonAction(control, &amount);
 if ( amount != 0 )
 {
 ScrollRect (&tRect, amount, 0, nil);
 SetOrigin(tRect.left-amount,tRect.top);
 }
   }
} // HActionProc 
Listing 3:  Adjustments to the MacTutorApp.cp and MacTutorApp.r files

Changes in MacTutorApp.cp:

#include “MacTutorGrow.h” 
 // insert behind the other #includes

// change the definition of the main() routine:
TMacTutorApp *gTheApplication;
int main(void)
{
 gTheApplication = new TMacTutorApp;
 if (gTheApplication == nil)return 0;
 gTheApplication->EventLoop();
 return 0;
}

// insert the following definitions to MacTutorApp.r:

#define kErrStrings 129
#define eNoMemory1
#define eNoWindow2

resource ‘CNTL’ (rVScroll, preload, purgeable) {
 {-1, 385, 236, 401},
 0, visible, 0, 0, scrollBarProc, 0, “” };

resource ‘CNTL’ (rHScroll, preload, purgeable) {
 {235, -1, 251, 386},
 0, visible, 0, 0, scrollBarProc, 0, “” };

// change the WIND definition:

resource ‘WIND’ (rDocWindow, preload, purgeable) {
 {64, 60, 314, 460},
 zoomDocProc, invisible, goAway, 0x0, 
 “MacTutor C++ demo” };

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Adobe InCopy CC 2018 13.0.0.123 - Create...
InCopy CC 2018 is available as part of Adobe Creative Cloud for as little as $19.99/month (or $9.99/month if you're a previous InCopy customer). Adobe InCopy CC 2018, ideal for large team projects... Read more
OnyX 3.3.8 - Maintenance and optimizatio...
OnyX is a multifunction utility that you can use to verify the startup disk and the structure of its system files, to run miscellaneous maintenance and cleaning tasks, to configure parameters in the... Read more
Merlin Project 4.3.1 - $289.00
Merlin Project is the leading professional project management software for OS X. If you plan complex projects on your Mac, you won’t get far with a simple list of tasks. Good planning raises... Read more
DiskCatalogMaker 7.2.5 - Catalog your di...
DiskCatalogMaker is a simple disk management tool which catalogs disks. Simple, light-weight, and fast Finder-like intuitive look and feel Super-fast search algorithm Can compress catalog data for... Read more
WhatsApp 0.2.6426 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more
Ableton Live 9.7.5 - Record music using...
Ableton Live lets you create and record music on your Mac. Use digital instruments, pre-recorded sounds, and sampled loops to arrange, produce, and perform your music like never before. Ableton Live... Read more
Maintenance 2.3.5 - System maintenance u...
Maintenance is a system maintenance and cleaning utility. It allows you to run miscellaneous tasks of system maintenance: Check the status of the hard disk Repair permissions Run periodic scripts... Read more
OnyX 3.3.8 - Maintenance and optimizatio...
OnyX is a multifunction utility that you can use to verify the startup disk and the structure of its system files, to run miscellaneous maintenance and cleaning tasks, to configure parameters in the... Read more
Merlin Project 4.3.1 - $289.00
Merlin Project is the leading professional project management software for OS X. If you plan complex projects on your Mac, you won’t get far with a simple list of tasks. Good planning raises... Read more
WhatsApp 0.2.6426 - Desktop client for W...
WhatsApp is the desktop client for WhatsApp Messenger, a cross-platform mobile messaging app which allows you to exchange messages without having to pay for SMS. WhatsApp Messenger is available for... Read more

Guns Royale guide - beginner tips and tr...
If you've been itching to find a mobile battle royale game like Player Unknown's Battlegrounds, you're finally in luck. Guns Royale is a new survival shooter that takes all of the things you love about good ol' PUBG and puts it in a tidy mobile... | Read more »
What we know about Animal Crossing on mo...
At last, we'll be receiving some news about the mobile version of Animal Crossing in a special Nintendo Director at11 PM on October 24. There's been little word on the game since it was first announced, having been met with a series of delays.... | Read more »
Darts of Fury guide - how to rise in the...
Darts of Fury is a new, immensely absorbing darts game from indie studio Yakuto. It's darts in its purest form, but collectible darts and other upgrades give this game an addictive edge that's hard to shake. As your progress out of the beginner... | Read more »
ICEY (Games)
ICEY 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: ICEY is a 2D side-scrolling action game. As you follow the narrator's omnipresent voice, you will see through ICEY's eyes and learn the... | Read more »
The best new games we played this week -...
We've made it, folks. Another weekend is upon us. It's time to sit back and relax with the best new releases of the week. Puzzles, strategy RPGs, and arcade games abound this week. There's a lot of quality stuff to unpack this week, so let's hop... | Read more »
Wheels of Aurelia (Games)
Wheels of Aurelia 1.0.1 Device: iOS Universal Category: Games Price: $3.99, Version: 1.0.1 (iTunes) Description: | Read more »
Halcyon 6: Starbase Commander guide - ti...
Halcyon 6 is a well-loved indie RPG with stellar tactical combat and some pretty good writing, too. It's now landed on the App Store, so mobile fans, if you're itching for a good intergalactic adventure, here's your game. Being a strategy RPG, the... | Read more »
Game of Thrones: Conquest guide - how to...
Fans of base building games might be excited to know that yet another entry in the genre has materialized - Game of Thrones: Conquest. Yes, you can now join the many kingdoms of the famed book series, or create your own, as you try to conquer... | Read more »
Halcyon 6: Starbase Commander (Games)
Halcyon 6: Starbase Commander 1.4.2.0 Device: iOS Universal Category: Games Price: $6.99, Version: 1.4.2.0 (iTunes) Description: An epic space strategy RPG with base building, deep tactical combat, crew management, alien diplomacy,... | Read more »
Legacy of Discord celebrates its 1 year...
It’s been a thrilling first year for fans of Legacy of Discord, the stunning PvP dungeon-crawling ARPG from YOOZOO Games, and now it’s time to celebrate the game’s first anniversary. The developers are amping up the festivities with some exciting... | Read more »

Price Scanner via MacPrices.net

27″ 3.4GHz iMac on sale for $1699, save $100
Amazon has the 27″ 3.4GHz iMac (MNE92LL/A) on sale today for $1699 including free shipping. Their price is $100 off MSRP, and it’s the lowest price available for this model (except for Apple’s $1529... Read more
Clearance 2016 15″ MacBook Pros available for...
B&H Photo has leftover 2016 15″ MacBook Pros available for up to $700 off original MSRP. Shipping is free, and B&H charges NY & NJ sales tax only: – 15″ 2.7GHz Touch Bar MacBook Pro Space... Read more
Save $100 on 13″ MacBook Airs, prices start a...
Adorama has 2017 13″ MacBook Airs on sale today for $100 off MSRP including free shipping. Adorama charges NY & NJ sales tax only: – 13″ 1.8GHz/128GB MacBook Air (MQD32LL/A): $899, $100 off MSRP... Read more
1.4GHz Mac mini available for $399, $100 off...
TigerDirect has the 1.4GHz Mac mini on sale today for $399 including free shipping. Their price is $100 off MSRP, and it’s the lowest price available for this model. Although currently out of stock,... Read more
21″ 2.3GHz iMac on sale for $999, save $100
MacMall has the 21″ 2.3GHz iMac (MMQA2LL/A) on sale today for $999 including free shipping. Their price is $100 off MSRP, and it’s the lowest price available for this model. Read more
12″ iPad Pros on sale for $50 off MSRP, no ta...
Adorama has 12″ iPad Pros on sale today for $50 off MSRP. Shipping is free, and Adorama charges sales tax in NY & NJ only: – 12″ 64GB iPad Pro: $749, save $50 – 12″ 256GB iPad Pro: $899, save $50... Read more
9″ iPads on sale for $30 off, starting at $29...
MacMall has 9″ iPads on sale for $30 off including free shipping: – 9″ 32GB iPad: $299 – 9″ 128GB iPad: $399 Read more
Apple restocks full line of refurbished 13″ M...
Apple has restocked a full line of Apple Certified Refurbished 2017 13″ MacBook Pros for $200-$300 off MSRP. A standard Apple one-year warranty is included with each MacBook, and shipping is free.... Read more
13″ 3.1GHz/256GB MacBook Pro on sale for $167...
Amazon has the 2017 13″ 3.1GHz/256GB Space Gray MacBook Pro on sale today for $121 off MSRP including free shipping: – 13″ 3.1GHz/256GB Space Gray MacBook Pro (MPXV2LL/A): $1678 $121 off MSRP Keep an... Read more
13″ MacBook Pros on sale for up to $120 off M...
B&H Photo has 2017 13″ MacBook Pros in stock today and on sale for up to $120 off MSRP, each including free shipping plus NY & NJ sales tax only: – 13-inch 2.3GHz/128GB Space Gray MacBook... Read more

Jobs Board

*Apple* Professional Learning Specialist - A...
Job Summary The Apple Professional Learning Specialist is a full-time position with Apple . This position requires a high caliber work ethic built from respect, Read more
*Apple* Professional Learning Specialist - A...
Job Summary The Apple Professional Learning Specialist is a full-time position for one year with Apple in the Kanawha, WV area. This position requires a high 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
Project Engineer, *Apple* Education Profess...
Project Engineer, Apple Education Professional Services Job Number: 113143353New York City, New York, United StatesPosted: Oct. 17, 2017Weekly Hours: 40.00 Job Read more
Commerce Software Engineer, *Apple* Media P...
Commerce Software Engineer, Apple Media Products Job Number: 113092072New York City, New York, United StatesPosted: Oct. 19, 2017Weekly Hours: 40.00 Job Summary With Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.