TweetFollow Us on Twitter

Text Window
Volume Number:1
Issue Number:6
Column Tag:C WORKSHOP

Windows for Text Editing

By Robert B. Denny

Windows for Text Editing

One of the most comon uses of windows in Macintosh applications is for manipulation of text. The user interface for text editing is one of the cornerstones of Mac technology.

This month’s C Workshop deals with implementing editing windows. We’ll bring together much of what was presented in previous columns, and add new informa- tion on TextEdit’s services. We’ll also show some specifics on using the Control Manager to handle scroll bars, and their use in scrolling our view of text managed by TextEdit.

One rather important issue that will not be covered is file I/O. It’s important to realize that TextEdit manages opera- tions on text in memory. If you want to work with text in a file, you must provide the services for getting text into and out of memory in manageable chunks for TextEdit to work with.

TextEdit Power

TextEdit is one of the most powerful of Macintosh’s system service packages. The Mac designers realized that editing text is probably the most pervasive user operation of all, and that standardizing the editing interface would make the Mac easy to use. Therefore, they have pro- vided us with a remarkably flexible and user-friendly editing package.

TextEdit consists of a set of system services for displaying and manipulating text. Text is stored in coded form in a linear array hooked to a master data structure called a TERec. The TERec is to TextEdit as the WindowRecord is to the Window Manager.

The display services of TextEdit handle drawing of text in the window, line breaking with optional word wrap, blink- ing the caret and showing selected ranges of text. The manipulating services handle text selection, insertion, deletion, and the scrap services of copy, cut and paste, operating on the actual text stored in memory and on the clipboard. It is a good idea to keep the concepts of display and manipulation separate in your mind.

TextEdit is reasonably documented in Inside Macintosh. It can be difficult to keep an overall perspective on things, though, when an editing window involves so many of Macintosh’s services and their data structures. Figure 1 shows a bird’s eye view of most of the data structures involved in an editing window.

Using TextEdit: Statics

There are three main things to get set up in preparation for using TextEdit with a window. First, you must create a TERec with a filled-in handle to the array where the text will be stored. Next, you must define two very important rectangles, the ViewRect and the DestRect. First, let’s look at the TERec. As usual, its structure will tell us some important things about TextEdit. The names of the structure members have been taken directly from the Lisa Pascal interface to TextEdit in the file TOOLINTF.TEXT.

The meaning of most of the fields is shown in IM. We’ll document some of the others, though you won’t normally use them. “selPoint” is the mouseLoc of the current selection point. “active” is a boolean telling whether the related window is active. This is used to control caret blinking and highlighting of selected text during window updates. “wordBreak” is a pointer to the routine that calculates word breaks (this has interesting possi- bilities). “clickLoop” is a pointer to the routine called when the mouse is clicked in text. It handles tracking the mouse and highlighting the selected text on the fly while the mouse is pressed. “clickTime” and “clickLoc” mark the place and time where & when the mouse was first clicked. Presumably, they are the property of the clickLoop routine. “recalBack” is a boolean that controls whether line breaks will be continuously recalculated in background or not and “recalLines” is a boolean that indicates whether a recalculation is under way. Finally, “caretState” indicates whether the caret is on or not, and “caretTime” contains the time for the next caret blink.

struct TERec
 {
 Rect destRect;
 Rect viewRect;
 Rect selRect;
 short  lineHeight;   
 short  firstBL;
 Point  selPoint;
 short  selStart;
 short  selEnd;
 short  active;
 long wordBreak;
 long clikLoop;
 long clickTime;
 short  clickLoc;
 long caretTime;
 short  caretState;
 short  just;
 short  TElength;
 Handle hText;
 short  recalBack;
 short  recalLines;
 short  clikStuff;
 short  crOnly;
 short  txFont;
 Style  txFace;
 short  txMode;
 short  txSize;
 GrafPtrinPort;
 Ptr  highHook;
 Ptr  caretHook;
 short  nLines;
 short  lineStarts[1];
 };

Before doing anything, your application must call TEInit(). This allocates a single common scrap area for use by TextEdit.

To allocate a TERec and a text array for a given window, call SetPort() for that window, then call TENew(), which returns a handle to the TERec. TENew() doesn’t take a windowPtr or a grafPtr, rather, it works on the current port, hence the need to call SetPort() before TENew().

The two parameters to TENew are the destRect and the viewRect. These two rectangles determine the line width and displayed portion of text. Remember the text is stored in a linear array hooked to the TERec. Refer again to Fig. 1. Notice that the TERec contains a set of pointers (actually offsets) to the places in the text where line breaks occur. How are these calculated?

Figure 2 above shows the relationship between the two rectangles. You can look at the destRect as the dimensions of the “chalkboard” where the text is to be displayed. TextEdit automatically mea- sures the length of the text in the storage array (given its font parameters) and calculates the location of the line breaks, normally employing word breaks instead of character breaks. The destRect is specified in the coordinate system of the owning window’s grafPort. Don’t forget this, it has important implications. In Figure 2, the top left corner of the destRect has negative v & h coordinate values.

The viewRect specifies the portion of the text that is actually visible. It is sort of a “clip” rectangle for the text display. Why the distinction? Consider the case of displaying text as it would print on 8-inch wide paper. The destRect would have a width of 576 pixels (72 x 8). This sets the line breaks for the paper in use.

But the window itself can be resized and scrolled around on the 8-inch wide “chalkboard”. The viewRect is used to tell TextEdit the dimensions and location in the grafPort of the “view-port” to the text display being constructed on the chalk- board.

Normally, the viewRect is set to completely enclose the content region of the window, less the scroll bar and size box areas. It too is specified in grafPort coordinates.

One final word about setting up a window for text editing. It’s a good idea to provide a 3 or 4 pixel “bleed” on the top and left of the page image. There are two schools of thought on this. One says that the bleed should be present regardless of the location of the viewRect in the destRect. The other (to which I sub- scribe says that the bleed should be present only if the destRect is at the left and/or top of the window port. The latter makes it visually easy to tell whether there is text to the left and above the viewRect by showing fragments of letters at the window’s edge.

Using TextEdit: Dynamics

Once you have set up a window for editing, you can start manipulating and displaying text. Keep in mind the following facts about TextEdit:

1. It works only on memory images of text. No file I/O is provided.

2. It does not support multiple of character fonts, styles or sizes in a single environment.

The simplest operation is insertion of text. This can be done one character at a time with TEKey() and en masse with TEinsert(). It is most common to use TEKey() in response to a keypress event. TextEdit sticks the new text into the linear array, recalculates the downstream line breaks, then posts an update event for the window, if needed.

Simple deletion is also easy. To delete the character to the left of the current insertion point or to delete the current selection, call TEKey() with the “backspace” key code. To delete the current selection (if any), call TEDelete(). TextEdit removes the deleted text from the linear array, closing up the space, recalculates the the downstream line breaks, then posts an update event for the window, if needed.

Mass operations of cut, copy and paste are hardly more difficult. Normally, you should provide both menu options and “menu keys” to trigger these operations, in accordance with the Macintosh interface guidelines. Call TECut(), TECopy() or TEPaste() to perform the operation. If there is no text currently selected, these functions are no-ops. Otherwise, the indicated opera- tion is performed, including transfers to or from the scrap allocated by TEInit(), and the already described manipulations of the linear text array and display.

How do we select text with the mouse? Recall that the TERec contains a pointer to the “clickLoop” routine, the routine responsible for tracking the mouse while it is kept pressed and highlighting selected text on the fly as the mouse is moved. How does this process get started? By calling TEClick().

So whenever your application detects a mouse press inside the viewRect of an editing window, it should call TEClick(). You can determine whether the mouse was pressed in the viewRect by calling the QuickDraw ptInRect() service with the clicked mouse location and the viewRect. If it returns TRUE, then call TEClick(). The “clickLoop” routine is entered and continues to execute until the mouse is released, at which time control is returned to the statement following the call to TEClick().

To implement the “shift-click” method of extended selection, you must determine whether the shift key was pressed at the time the mouse was clicked and pass TRUE for the “ext” parameter to the TEClick() call. For more informa- tion, see IM.

To scroll the text display in the viewRect, simply call TEScroll(). This function takes as parameters the distance (in pixels) to scroll horizontally and vertically. A zero means no scrolling in that direction.

Now let’s test your understanding of TextEdit’s coordinate system. The first person write in with the correct answer to the following question will receive a free copy of the MacTutor “source disk”:

QUESTION:

Suppose there was no TEScroll() function. How would you scroll the displayed text? Provide a C language implementation of TEScroll():

 tescroll(dh, dv, th)
   short int dh; /* Horiz amount */
   short int dv; /* Vert amount */
   TEHandle th;  /* Handle to TERec */
 {
 (.. your code ..)
 }

You must answer the question completely, i.e., furnish a complete implementation of TEScroll(), given the parameters dh and dv whose sense of positive are text motion of right and down, respectively.

There are several other TextEdit routines which can be used to perform special (unusual) operations. Also, you can make changes to some of the TERec’s fields yourself. In either case, take care to call TEUpdate() to force display changes, and/or TECalText() to force recalculation of line breaks as required.

Using Scroll Bars

Windows used for text editing generally have at least one scroll bar present (the vertical scroller). A scroll bar is a Macintosh “control”, supported by the services provided by the Control Manager. A general discussion of the control manager is beyond the scope of this article. We’ll restrict coverage to that necessary to use scroll bars. Actually, the scroll bar is the most complex of the “standard” controls, so once you understand it, you’ll have no trouble going back to understand the other controls.

Each scroll bar has associated with it a ControlRecord, which is a data structure containing the information needed by the Control manager to handle the control. Most importantly, each control has a value at a given instant. The whole purpose of a control is to visually manipulate the value of the control. Keep this in mind at all times!

Refer to Figure 1. Note that the ControlRecords for the vertical and horizontal scrollers are linked (by handles) off the WindowRecord. Also, they contain back pointers to the Window Record.

The appearance and structural makeup of a particular kind of control is determined by a “defProc”, a control definition procedure. We discussed defProcs last month in reference to windows. When you create a control, its “flavor” is determined by the defProc. The control manager is a collection of general-purpose routines; the specifics are handled by calling the defProc.

Scroll bars are handled by a defProc named “scrollBarProc”. This defProc is fairly smart. For example, when creat- ing a scroller, you pass the location and dimensions (in window local coordinates) of the enclosing rectangle. The defProc is smart enough to look at the dimensions and automatically determine if the scroller is to be a horizontal or vertical flavor (I’ve never tried to pass a square rect).

The defProc for the “document window” (documentProc) assumes that the scrollers will occupy 16-pixel strips along the right and bottom edges, with a one-pixel overlap of the window’s border. The grow image assumes this, and the size and location given to the size box assumes this. The scrollers are in the window’s content region. We detailed this in a previous edition of MacTutor.

When you detect a mouseDown event in the content region of a document window, call findControl(). If the click was in a control, the handle to the control is returned along with a “part code” indicat- ing what part of the control the mouse was clicked in. These part codes are shown symbolically in Figure 3. We’ll deal with actions to be performed later.

A frequently misunderstood area involves the display states that scrollers can take. When an edit window is inactive, the scrollers are invisible; only the scroller outlines drawn by the window’s defProc show. There are three visible states, however, as shown in Figure 4.

You’ll probably never have occasion to highlight parts of a scroller yourself. However, you may want to make the scroller “inactive” if there is nothing beyond the limits of the viewRect, if there is no reason to scroll. To make the scroller look inactive, call the highlighting function HiLiteControl() with a “part code” of 254 or 255. Using 254 leaves the scroller sensitive to mouse presses & calling FindControl(), 255 will not.

Putting It Together: Creating a Document Window

Here is some C code for creating a document window. It assumes that there is a window template resource, just for simplicity here. You can substitute NewWindow() for GetNewWindow():

/*
 * EDIT_WINDOW() - Create an “edit window”
 *
 * Inputs:
 * dest:-> destination rect
 *
 * Outputs:
 * Fills in vs_handle and hs_handle
 * with scroller handles.
 * Fills in te_handle with handle to 
 * TERec.
 * Returns the WindowPtr
 *
 * WARNING: Untested extract.
 */
WindowPtr edit_window(dest)
Rect *dest;
 {
 Rect view_rect; 
 Rect bounds_rect;
 Rect dest_rect;
 Rect drag_rect;
 Rect grow_rect;
 Rect *pr;
 WindowPtr wp;

 /*
  * Create window record on heap from
  * resource ID = “WINDOW_ID”. We use
  * some vanilla values for the window
  * drag and grow rects.
  */
 wp = GetNewWindow(WINDOW_ID,0,-1);
 SetWTitle(wp,”\013Edit Window”);
 SetRect(&drag_rect,4,24,508,338);
 SetRect(&grow_rect,100,60,512,302);
 SetPort(wp);

 /*
  * Set up TextEdit rects.  Make the
  * destRect fixed here for example.
  * Co-locate the viewRect’s top right
  * corner with the destRect’s for 4
  * pixel bleed. Leave room for scrollers
  */
 pr = &(wp->portRect);
 destRect.top = destRect.left = 4;
 destRect.bottom = 1000;
 destRect.right = 500;
 viewRect.top = destRect.top;
 viewRect.left = destRect.left;
 viewRect.bottom = pr->bottom - 15;
 viewRect.right = pr->bottom - 15;

 /*
  * Now create the TERec & text area
  */
 te_handle = TENew(&dest_rect,     &view_rect);

 /*
  * Calculate the vertical scroller rect
  * and add the scroller to the window.
  */
 bounds_rect.top = pr->top - 1;
 bounds_rect.left = pr->right - 15;
 bounds_rect.bottom = pr->bottom - 14;
 bounds_rect.right = pr->right + 1;
 vs_handle = NewControl(dwp->wp,   &bounds_rect,               “”, TRUE,
 dest_rect.top,  dest_rect.top, dest_rect.bottom,
 scrollBarProc, 1);
 ValidRect(&bounds_rect);

 /*
  * Same for the horizontal scroller
  */
 bounds_rect.top = pr->bottom - 15;
 bounds_rect.left = pr->left - 1;
 bounds_rect.bottom = pr->bottom + 1;
 bounds_rect.right = pr->right - 14;
   hs_handle = NewControl(dwp->wp, &bounds_rect,               “”, TRUE, 
dest_rect.left,
 dest_rect.left, dest_rect.right   scrollBarProc, 1);
 ValidRect(&bounds_rect);

 /*
  * Finally, draw in the “grow icon” & 
  * return the window pointer
  */
 DrawGrowIcon(wp);
 return(wp);
 }

There are some fine points to be aware of here. The scrollers are created with bounds rectangles which are calculated from the window’s portRect. The viewRect for TextEdit is also calculated from the window’s portRect. This means that the window template resource can be any reasonable size and this routine will still work.

NewControl() not only initializes the ControlRecord, it also draws the control (set to its initial value). The calls to ValidRect() prevent unnecessary drawing in response to an update event. The call to SetWTitle() passes a “Pascal” (counted) string generated the quick way.

Finally, note that the scrollers are initialized with values drawn from the TextEdit destRect. More about this later.

Event Handling: MouseDown

If your application detects a mouse- down event in the content region of a document window, it must determine if the click was in the viewRect, one of the scrollers, the grow region or a “bleed” area. I suggest you call PtInRect() first, with the viewRect. If it returns something other than FALSE (0), then the click was in a TextEdit-controlled region. If not, call FindControl(). If it returns some- thing other than NULL (0), it was in a control. If not, the click was in a bleed area and can be ignored. Here is some C code for handling a content-area click.

/*
 * content_click()
 *
 * Event record “event” is global. Shift
 * click selection not supported.
 *
 * WARNING: Untested extract.
 */
content_click()
 {
 ControlHandle ch;
 unsigned short part;
 int in_text;
 /*
  * Declare assembler action
  * routines for TrackControl().
  */
 int scroll_up();
 int scroll_down();

 /*
  * Convert event loc to current grafPort
  * local coordinates & test if in text.
  */
 GlobalToLocal(&Event.where);
 in_text = PtInRect(&event.Where,
 &((*(te_handle))->viewRect));

 /*
  * If in text, enter the “click loop” 
  * otherwise, handle scroller or bleed 
  * click.
  */
 if(in_text)
 TEClick(&Event.where, 0, te_handle);
 else
 {
 part = 
 (short)FindControl(&Event.where,
 (*te_handle)->inPort, &ch);
 switch(part)
 {
 case inUpButton:
 TrackControl(ch, &Event.where,
 scroll_up);
 break;

 case inDownButton:
 TrackControl(ch, &Event.where,
 scroll_down);
 break;

 case inPageUp:
 page_scroll(part, ch, -1);
 break;

 case inPageDown:
 page_scroll(part, ch, 1);
 break;
 
 case inThumb:
 TrackControl(ch, &Event.where,
 0);
 edit_scroll();

 default: /* In bleed */
 }
 }
 }

How to Handle Scrolling

The Easy Way

There are several mystery functions in the code given above. First, and most important, is edit_scroll(). It is the basis for all of the other mystery functions. But before we go into the mechanics of “easy scrolling”, lets look at the basic method.

The key to the method is the relationship between the scroll bar’s “control value” and the position of the displayed text. Recall that TEScroll takes relative horizontal and vertical scroll distances, movement amounts. To nail things down, we first define a coordinate pair (a Point) which will contain the distance in pixels that we have scrolled from the original top left. We’ll call this te_origin.

Now for the main thing. The scroller “values” are used to control the values of te_origin’s vertical and horizontal coord- inates. The range of values for the horizontal scroller is destRect.left to destRect.right. Likewise, the range of values for the vertical scroller is destRect.top to destRect.bottom. Think about that one ...

Any time a scroller’s value changes, the new value is compared with the corresponding value of te_origin. The difference is used to call TEScroll() to do the actual scrolling, then the new value replaces the old value in te_origin. Here is the C code to implement this basic scrolling function (please don’t criticize this for tightness, it’s an example):

/*
 * edit_scroll()
 *
 * Inputs:
 * Current value of te_origin
 * Current values of the scrollers
 *
 * Outputs:
 * te_origin is updated
 * Window is scrolled to new loc
 *
 * WARNING - untested extract
 */
edit_scroll()
   {
   short int nh, nv, dh, dv;
 
   nh = GetCtlValue(hs_handle);
   if(nh < 4) nh = 4;
   dh = te_origin.h - nh;
   te_origin.h -= dh;

   nv = GetCtlValue(vs_handle);
   if(nv < 4) nv = 4;
   dv = te_origin.v - nv;
   te_origin.v -= dv;

   #TEScroll(dh, dv,te_handle);
   }

This function is all we need to handle the “inThumb” case of scrolling in the content_click() routine above. A click in the thumb causes us to call TrackControl(), which keeps control until the mouse is released. At that point we get control back and immediately call edit_scroll(), which reads the control values and scrolls as required.

The next case to handle is clicking in the up and down buttons. For the vertical scroller, the proper action is to repeatedly scroll one “lineHeight” until the mouse is released. For the hori- zontal scroller, you might choose a “jump” scroll of 1/8 of the window width or something like that.

The proper way to accomplish this repeated scrolling action is to do so with an action routine supplied to the TrackControl() function. These are the mystery scroll_up() and scroll_down() functions used in content_click() above. Unfortunately, they cannot be written in C. This is because they are “called back” from the TrackControl() function, and the callback uses the LisaPascal linkage interface. Here is the assembly code for the vertical scroller’s scroll_up():

;
; scroll_up()
;
; TrackControl callback action routine for
; vertical scroller’s scroll-up one line
; function.  Called when up-arrow is
; pressed.
;
; Inputs:
;   4(sp) Part code (short int)
;   6(sp) ControlHandle (32-bit address)
;
scroll_up:
 Link A6,#0 ; Link env.
 Move.W 8(A6),D0 ; D0 = part code (W)
 Beq  @1; (not in arrow now)
 Move.L 10(A6),-(SP) ; Save handle
 Clr.W  -(sp)  ; Gets control value
 Move.L 10(A6),-(SP) ; Pass handle
 _GetCtlValue  ; Get the value
 ; ------------------
 Jsr  get_lh; D0 = line height
 Sub.W  D0,(SP)  ; (SP) = new ctl val
 Bge  @0; (OK, its positive)
 Clr.W  (SP); Limit at 0
@0:; ------------------
 _SetCtlValue  ; Set new value
 Jsr  edit_scroll ; Now scroll
@1:
 Unlk a6; Pascal exit
 Move.L (SP)+,A0
 Addq #6,SP
 Jmp  (A0)

Note the statements between the dashed lines. This is the only difference between the horizontal and vertical scroller’s callback routines for up and down. The difference is in the amount and direction of change to the scroller’s value in (SP). The example above makes use of a mystery routine get_lh(), which reads the line height from the TERec. It also calls our edit_scroll() routine to scroll the window once the scroller’s value has been changed. The call to _SetCtlValue changes the value of the scroller and moves the thumb box accordingly.

The final thing we need is a routine for page scrolling. This time, we won’t use TrackControl(). Since we are not being called back, the routine can be written in C, and can take a “direction” parameter so one routine is all that is needed.

The Macintosh Interface Guidelines specify a particular type of “action” that we must implement in the page_scroll() routine. That is, the page scroll must be done at least once, and repeated as long as the mouse is held down and the point is inside the original page scroll area. If the mouse is moved out of that page scroll area, page scrolling should stop, until it is moved back into the area, at which time page scrolling should resume.

The following page scrolling routine does this and scrolls different amounts for vertical and horizontal scrollers. See if you can figure out what is happening:

/*
 * page_scroll()
 *
 * Inputs:
 *  partPart code where first clicked
 *  ch  ControlHandle
 *  dir Direction: -1=Up  1=Down
 *
 * Locks the TERec temporarily
 */
page_scroll(part, ch, dir)
short part;
ControlHandle ch;
short dir;
 {
 Point cur_pt;
 short amount;
 Rect *vr;

 HLock(te_handle); /* Lock & deref */

 vr = &((*(te_handle))->viewRect);
 if(ch = vs_handle)
 amount = vr_bottom - vr->top -
 (short)get_lh();
 else
 amount = (vr->right - vr->left)/2;

 amount *= dir;

 /*
  * Act in accordance with Interface
  * Guidelines.
  */
 do{
 GetMouse(&cur_pt);
 if((short)TestControl(ch, &cur_pt)
    != part)
 continue;
 SetCtlValue(ch, GetCtlValue() +      amount);
 edit_scroll();
 } while(StillDown());
 
 HUnlock(ch);  /* Release TERec */
 }

That’s about it for scrolling. There’s a lot of hidden information in the routines given. If you’ll take the time to understand them (and the associated toolbox traps), you will have a great start at one of the most complex areas of Mac application design.

Event Handling: Updates

Handling update events for document windows is surprisingly simple. TextEdit and the Control Manager do most of the work. Update events call for redrawing the window’s contents. BeginUpdate() and EndUpdate() restrict the actual drawing to that which is necessary. Here is an example of an update event handler for document window:

/*
 * Upd_wind() - Update document window
 *
 * Inputs:
 * wp = WindowPointer
 * th = TEHandle
 */
upd_wind(wp, th)
WindowPtr wp;
TEHandle th;
 {
 
 BeginUpdate();
 SetPort(wp);

 DrawGrowIcon(wp);
 DrawControls(wp);
 TEUpdate(&((*(wp->visRgn))->rgnBBox), th);
 
 EndUpdate();
 }

That’s it. Notice the rectangle passed to TEUpdate(). Instead of drawing the entire ViewRect, this method uses the visRgn, which has been temporarily hacked to be the update region by BeginUpdate(). This is one case where it is easy to manually restrict drawing to the update region. Doing this can result in substantial speed improvements for TEUpdate. Notice how easy it is to redraw the controls.

Event Handling:

Activate and Deactivate

Activation (and deactivation) events are also quite easy to handle for document windows. Activation calls for changing the “look” of the controls and text, and turning on the caret or selection range. Actually, for scrollers, activa- tion means “showing” them, deactivation means “hiding” them.

There is no “ShowControls()” function so we “show” each one by tracing down the linked list. This method makes it unnecessary to pass control handles:

/*
 * act_wind()/deact_wind()
 *
 * Activate event handlers
 */
act_wind(wp)
WindowPtr wp;
 {
 Handle ch;

 SetPort(wp);

 DrawGrowIcon(wp);
 TEActivate(dp->te_handle)
 ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
 {
 ch = 
   (*((ControlHandle)(ch)))->nextControl)
 ShowControl(ch);
 }
 }

deact_wind(wp)
WindowPtr wp;
 {
 Handle ch;

 SetPort(wp);

 DrawGrowIcon(wp);
 TEDeactivate(dp->te_handle)
 ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
 {
 ch = 
   (*((ControlHandle)(ch)))->nextControl)
 HideControl(ch);
 }
 }

Note that each routine calls DrawGrowIcon(). That function knows whether the window is active or inactive, and fills in the grow box appropriately. In other words, DrawGrowIcon() for an inactive window blanks out the grow box.

Final Words

As promised last month, I have used TextEdit and controls to tie together the information given in the last two issues, and to illustrate applications of basic Mac principles. The routines shown in this month’s column are untested examples! In most cases, the code was lifted out of working applications, then simplified for ease of understanding. The algorithms should be correct, the detail may not be.

Due to the size of even a simple C application, we won’t be publishing sources for complete applications in MacTutor. Rather, we’ll make them available on the MacTutor source disks.

I plan to devote next month to a random collection of operating system hacks, maybe an interface to Standard File or a C implementation of sprintf() for those of us who abhor Unix libraries for Mac applications.

Heinich “Benchmark” Revisited

In the February 1985 edition of MacTutor, we published this program sent in by Mr. Robert Heinich of Boca Raton, FL:

main()
{
union u_storage{
  long a_long;
  struct T_0000{
    short a_short;
    short b_short;
  }S_0000;
}storage;
storage.a_long = 6;
printf(“\na_short = %d”,
  storage.S_0000.a_short);
printf(“\nb_short = %d”,
  storage.S_0000.b_short);
printf(“\n”);
}

He was looking for the answers “a_short = 0” and “b_short = 6”. The nature of this program compels me to make some comments.

The union maps 2 16-bit words over a 32-bit longword. The order of addressing the two words in the longword is system-dependent.

The 68000 stores the least significant byte of a word at address n and the most significant half at address n+1. Likewise, it stores the most significant half of a longword at address n and the least significant half at address n+2 . It is this latter property that the program uncovers.

Other machines (such as the DEC PDP-11 and VAX systems) store words and bytes in the reverse order. There are sound reasons for each convention and I’ll not argue either point.

What this program has brought up is the “discussion” of whether or not the C language should hide such machine dependencies from the programmer.

Firstly, the current C languages do not hide machine dependencies. The new ANSI standard does not call for machine independence either.

Some people feel that C is a high-level language and therefore a C program written for machine X should run on any other machine (except for OS specific, of course).

I couldn’t disagree more. C is a “system implementation” language. The whole idea of C is to amplify the programmer’s productivity and enhance maintainability by providing a viable alternative to assembly language.

If C compilers scrambled the addressing of struct members, it would make the language nearly impossible to use for system programming. In fact, there are many people who feel that automatic padding to insure correct alignment of structure members is not good. The Mac C compiler has an option to control structure padding.

C provides a well-defined access to low-level machine specifics. I don’t want that to change.

 
AAPL
$116.31
Apple Inc.
+1.64
MSFT
$48.70
Microsoft Corpora
+0.48
GOOG
$534.83
Google Inc.
-2.16

MacTech Search:
Community Search:

Software Updates via MacUpdate

Herald 5.0.1 - Notification plugin for M...
Note: Versions 2.1.3 (for OS X 10.7), 3.0.6 (for OS X 10.8), and 4.0.8 (for OS X 10.9) are no longer supported by the developer. Herald is a notification plugin for Mail.app, Apple's Mac OS X email... Read more
Firetask 3.7 - Innovative task managemen...
Firetask uniquely combines the advantages of classical priority-and-due-date-based task management with GTD. Stay focused and on top of your commitments - Firetask's "Today" view shows all relevant... Read more
TechTool Pro 7.0.6 - Hard drive and syst...
TechTool Pro is now 7, and this is the most advanced version of the acclaimed Macintosh troubleshooting utility created in its 20-year history. Micromat has redeveloped TechTool Pro 7 to be fully 64... Read more
PhotoDesk 3.0.1 - Instagram client for p...
PhotoDesk lets you view, like, comment, and download Instagram pictures/videos! (NO Uploads! / Image Posting! Instagram forbids that! AND you *need* an *existing* Instagram account). But you can do... Read more
SuperDuper! 2.7.3 - Advanced disk clonin...
SuperDuper! is an advanced, yet easy to use disk copying program. It can, of course, make a straight copy, or "clone" -- useful when you want to move all your data from one machine to another, or do... Read more
MacJournal 6.1.5 - Create, maintain, and...
MacJournal is the world's most popular journaling software for the Mac. MacJournal 6 adds a calendar mode that show entries from any journal, geolocation, word count, and progress tracking, as well... Read more
Skim 1.4.10 - PDF Reader and note-taker...
Skim is a PDF reader and note-taker for OS X. It is designed to help you read and annotate scientific papers in PDF, but is also great for viewing any PDF file. Skim includes many features and has a... Read more
FontExplorer X Pro 4.2.2 - Font manageme...
FontExplorer X Pro is optimized for professional use; it's the solution that gives you the power you need to manage all your fonts. Now you can more easily manage, activate and organize your... Read more
SoftRAID 5.0.5 - High-quality RAID manag...
SoftRAID allows you to create and manage disk arrays to increase performance and reliability. SoftRAID's intuitive interface and powerful feature set makes this utility a must have for any Mac OS X... Read more
DEVONthink Pro 2.8.2 - Knowledge base, i...
Save 10% with our exclusive coupon code: MACUPDATE10 DEVONthink Pro is your essential assistant for today's world, where almost everything is digital. From shopping receipts to important research... Read more

Latest Forum Discussions

See All

Weather or Not - Reports and Forecasts...
Weather or Not - Reports and Forecasts for your Calendar 1.0.0 Device: iOS iPhone Category: Weather Price: $2.99, Version: 1.0.0 (iTunes) Description: Weather or Not is a beautiful and intuitive way to check the weather and... | Read more »
Sago Mini Road Trip (Education)
Sago Mini Road Trip 1.0 Device: iOS Universal Category: Education Price: $2.99, Version: 1.0 (iTunes) Description: Go for a fun-filled drive with Jinja the cat. Pick a destination, select a vehicle and hit the road. What will Jinja... | Read more »
New Tower Defense Game, Kingdom Rush: Or...
New Tower Defense Game, Kingdom Rush: Origins, is Available Today Posted by Jessica Fisher on November 20th, 2014 [ permalink ] iPad Only App - Designed for the iPad | Read more »
Sunburn! (Games)
Sunburn! 1.0.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0.0 (iTunes) Description: Your ship is gone. Your crew is scattered. One option remains. Gather your crew... and jump into the sun. Reunite your... | Read more »
Tapventures Review
Tapventures Review By Jennifer Allen on November 20th, 2014 Our Rating: :: ODDLY COMPELLINGUniversal App - Designed for iPhone and iPad Tapventures is an increasingly hands-off one-tap RPG, but expect it to hook you despite your... | Read more »
Who Wore it Best? The Hunger Games: Girl...
With The Hunger Games: Mockingjay Part 1 out this weekend, Who Wore it Best? pits two Hunger Games tie-ins, Girl on Fire and Panem Run, against each other in a brutal and pointless fight to the death. I wonder where we got that idea from? | Read more »
Ironkill Review
Ironkill Review By Jennifer Allen on November 20th, 2014 Our Rating: :: LACKLUSTER PUNCHINGUniversal App - Designed for iPhone and iPad Ironkill is a freemium focused fighting game that doesn’t offer particularly thrilling fights... | Read more »
Real-Time Multiplayer Match-3 RPG Crusad...
Real-Time Multiplayer Match-3 RPG Crusaders Quest Set to Launch Next Month Posted by Ellis Spice on November 20th, 2014 [ permalink ] | Read more »
Checkpoint Champion Review
Checkpoint Champion Review By Jennifer Allen on November 20th, 2014 Our Rating: :: SPEEDY DRIFTINGUniversal App - Designed for iPhone and iPad Checkpoint Champion is a drift-focused racing game that’s ideal for short but fun gaming... | Read more »
MediaFire iOS 8 Native Update Brings New...
MediaFire iOS 8 Native Update Brings New “Power Upload” Feature to iPad and iPhone Posted by Jessica Fisher on November 20th, 2014 [ | Read more »

Price Scanner via MacPrices.net

64GB iPod touch on sale for $249, save $50
Best Buy has the 64GB iPod touch on sale for $249 on their online store for a limited time. Their price is $50 off MSRP. Choose free shipping or free local store pickup (if available). Sale price for... Read more
15″ 2.2GHz Retina MacBook Pro on sale for $17...
 B&H Photo has the 2014 15″ 2.2GHz Retina MacBook Pro on sale for $1799.99 for a limited time. Shipping is free, and B&H charges NY sales tax only. B&H will also include free copies of... Read more
New Logitech AnyAngle Case/Stand Brings Flexi...
Logitec has announced the newest addition to its suite of tablet products — the Logitech AnyAngle. A protective case with an any-angle stand for iPad Air 2 and all iPad mini models, AnyAngle is the... Read more
2013 15-inch 2.0GHz Retina MacBook Pro availa...
B&H Photo has leftover previous-generation 15″ 2.0GHz Retina MacBook Pros available for $1499 including free shipping plus NY sales tax only. Their price is $500 off original MSRP. B&H will... Read more
16GB Retina iPad mini on sale today for $199,...
 Staples has 2nd generation 16GB Retina iPad minis on sale for $199 on their online store for a limited time. Their price is $100 off MSRP. Choose free shipping or free local store pickup (if... Read more
Developers Start Designing Apps for Apple Wat...
Apple has announced the availability of WatchKit, software that gives developers a set of tools to easily create experiences designed specifically for Apple Watch. Apple’s developer community can now... Read more
C Spire Launches iPad Air 2 and iPad Mini 3 o...
C Spire has announced that iPad Air 2 with Wi-Fi + Cellular and iPad mini 3 with Wi-Fi + Cellular are now available on its 4G LTE network. C Spire offers both new iPads with a range of data plans... Read more
Are You On Your Last PC? – The ‘Book Mystique
Will your current PC be your last? Quite possibly so if you define “personal computer” as a traditional desktop or laptop form factor machine according to some commentators. So then, the upshot that... Read more
Save up to $180 on MacBook Airs with Apple re...
The Apple Store has Apple Certified Refurbished 2014 MacBook Airs available for up to $180 off the cost of new models. An Apple one-year warranty is included with each MacBook, and shipping is free.... Read more
16GB iPad mini available for $219, save $30
Walmart has 16GB iPad minis (1st generation) available for $219 on their online store. Their price is $30 off MSRP. Choose free shipping or free store pickup (if available). Price for online orders... Read more

Jobs Board

*Apple* Solutions Consultant (ASC)- Retail S...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
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* Store Leader Program - College Gradu...
Job Description: Job Summary As an Apple Store Leader Program agent, you can continue your education as you major in the art of leadership at the Apple Store. You'll Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Senior Event Manager, *Apple* Retail Market...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global event strategy. Delivering an overarching brand story; in-store, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.