TweetFollow Us on Twitter

Text Window
Volume Number:1
Issue Number:6

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;
 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”:


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”);

  * 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.left = 4;
 destRect.bottom = 1000;
 destRect.right = 500; =;
 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.
  */ = 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.bottom,
 scrollBarProc, 1);

  * Same for the horizontal scroller
  */ = 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.right   scrollBarProc, 1);

  * Finally, draw in the “grow icon” & 
  * return the window pointer

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.
 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.
 in_text = PtInRect(&event.Where,

  * If in text, enter the “click loop” 
  * otherwise, handle scroller or bleed 
  * click.
 TEClick(&Event.where, 0, te_handle);
 part = 
 (*te_handle)->inPort, &ch);
 case inUpButton:
 TrackControl(ch, &Event.where,

 case inDownButton:
 TrackControl(ch, &Event.where,

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

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

 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 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
   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)
 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
 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 -
 amount = (vr->right - vr->left)/2;

 amount *= dir;

  * Act in accordance with Interface
  * Guidelines.
 if((short)TestControl(ch, &cur_pt)
    != part)
 SetCtlValue(ch, GetCtlValue() +      amount);
 } 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;

 TEUpdate(&((*(wp->visRgn))->rgnBBox), th);

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
WindowPtr wp;
 Handle ch;


 ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
 ch = 

WindowPtr wp;
 Handle ch;


 ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
 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:

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

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.

Apple Inc.
Microsoft Corpora
Google Inc.

MacTech Search:
Community Search:

Software Updates via MacUpdate

Monosnap 2.2.2 - Versatile screenshot ut...
Monosnap allows you to save screenshots easily, conveniently, and quickly, sharing them with friends and colleagues at once. It's the ideal choice for anyone who is looking for a smart and fast... Read more
Tunnelblick 3.4beta36 - GUI for OpenVPN...
Tunnelblick is a free, open source graphic user interface for OpenVPN on OS X. It provides easy control of OpenVPN client and/or server connections. It comes as a ready-to-use application with all... Read more
SoftRAID 5.0.4 - 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
Audio Hijack Pro 2.11.3 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Airfoil 4.8.9 - Send audio from any app...
Airfoil allows you to send any audio to AirPort Express units, Apple TVs, and even other Macs and PCs, all in sync! It's your audio - everywhere. With Airfoil you can take audio from any... Read more
WhatRoute 1.13.0 - 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... Read more
Chromium 37.0.2062.122 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. FreeSMUG-Free OpenSource Mac User Group build is... Read more
Attachment Tamer 3.1.14b9 - Take control...
Attachment Tamer gives you control over attachment handling in Apple Mail. It fixes the most annoying Apple Mail flaws, ensures compatibility with other email software, and allows you to set up how... Read more
Duplicate Annihilator 5.0 - Find and del...
Duplicate Annihilator takes on the time-consuming task of comparing the images in your iPhoto library using effective algorithms to make sure that no duplicate escapes. Duplicate Annihilator detects... Read more
jAlbum Pro 12.2 - Organize your digital...
jAlbum Pro has all the features you love in jAlbum, but comes with a commercial license. With jAlbum, you can create gorgeous custom photo galleries for the Web without writing a line of code!... Read more

Latest Forum Discussions

See All

Kitty Powers’ Matchmaker – Tips, Tricks,...
Hey There, Kittens: | Read more »
Goblin Sword Review
Goblin Sword Review By Andrew Fisher on September 22nd, 2014 Our Rating: :: RETRO GOODNESSUniversal App - Designed for iPhone and iPad Fun visuals, good music, engaging level design, and lots of content make Goblin Sword an... | Read more »
Major New Update for CSR Racing Adds Fer...
Major New Update for CSR Racing Adds Ferrari and Multiplaye​r Posted by Jessica Fisher on September 22nd, 2014 [ permalink ] | Read more »
Veditor Review
Veditor Review By Jennifer Allen on September 22nd, 2014 Our Rating: :: PIMP YOUR VIDEOUniversal App - Designed for iPhone and iPad Want to add stickers and music to your videos? Veditor can do that easily.   | Read more »
1849′s Nevada Silver DLC is Still Search...
A few months ago, I took a look at 1849 from SomaSim. This Gold Rush-themed city builder for iPad had a fair bit going for it, but lacked in a few crucial areas to make it a true stand-out on the App Store. SomaSim has since added in a sandbox mode... | Read more »
Fruit Ninja Will be Reborn With a Massiv...
Fruit Ninja Will be Reborn With a Massive Update and Origins Animation Series Posted by Jessica Fisher on September 22nd, 2014 [ permalink ] Halfbrick Studios is rebuilding | Read more »
CloudMagic Updated for iOS 8 – Adds Inte...
CloudMagic Updated for iOS 8 – Adds Interactive Notifications, Share Extension, and More Posted by Jessica Fisher on September 22nd, 2014 [ | Read more »
Starbase Annex (Games)
Starbase Annex 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: "it’s really very clever... a little bit of Hearthstone and a dash of Eclipse" - From the creator of Starbase... | Read more »
Star Nomad Review
Star Nomad Review By Jordan Minor on September 22nd, 2014 Our Rating: :: BUMPY RIDEiPad Only App - Designed for the iPad Star Nomad will only appeal to the most hardcore space explorers.   | Read more »
Partyrs Review
Partyrs Review By Jordan Minor on September 22nd, 2014 Our Rating: :: LIFE OF THE PARTYUniversal App - Designed for iPhone and iPad Partyrs makes party planning as fun as partying itself.   | Read more »

Price Scanner via

Apple restocks some refurbished 2014 MacBook...
The Apple Store has restocked some Apple Certified Refurbished 2014 MacBook Airs, with prices starting at $769. An Apple one-year warranty is included with each MacBook, and shipping is free. These... Read more
13-inch 128GB MacBook Air on sale for $949, s...
B&H Photo has the new 2014 13″ 1.4GHz/128GB MacBook Air on sale for $949.99 including free shipping plus NY tax only. Their price is $50 off MSRP. B&H will also include free copies of... Read more
Apple offering free $25 iTunes Gift Card with...
The Apple Store is offering a free $25 iTunes Gift Card with the purchase of a $99 Apple TV for a limited time. Shipping is free. Read more
Apple refurbished iPod touch available for up...
The Apple Store has Apple Certified Refurbished 5th generation iPod touches available starting at $149. Apple’s one-year warranty is included with each model, and shipping is free. Most colors are... Read more
iFixIt Tears Down iPhone 6; Awards Respectabl...
iFixit notes that even the smaller 4.7″ iPhone 6 is a giant among iPhones; so big that Apple couldn’t fit it into the familiar iPhone form factor. In a welcome reversal of a recent trend to more or... Read more
Phone 6 Guide – Tips Book For Both iPhone 6...
iOS Guides has announced its latest eBook: iPhone 6 Guide. Brought to you by the expert team at iOS Guides, and written by best-selling technology author Tom Rudderham, iPhone 6 Guide is packed with... Read more
How to Upgrade iPhone iPad to iOS 8 without D...
PhoneClean, a iPhone cleaner utility offered by iMobie Inc., reveals a solution for upgrading iPhone and iPad to iOS 8 without deleting photos, apps, the new U2 album or anything. Thanks to more than... Read more
Inpaint 6 – Photo Retouching Tool Gets Faster...
TeoreX has announced Inpaint 6, a simple retouching tool for end users that helps remove scratches, watermarks, and timestamps as well as more complex objects like strangers, unwanted elements and... Read more
Worldwide PC Monitor Market Sees Growth in To...
Worldwide PC monitor shipments totaled 32.5 million units in the second quarter of 2014 (2Q14), a year-over-year decline of -2.9%, according to the International Data Corporation (IDC) Worldwide... Read more
Updated Price Trackers
We’ve updated our Mac Price Trackers with the latest information on prices, bundles, and availability on systems from Apple’s authorized internet/catalog resellers: - 15″ MacBook Pros - 13″ MacBook... Read more

Jobs Board

Position Opening at *Apple* - Apple (United...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of 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
Position Opening at *Apple* - Apple (United...
**Job Summary** At the Apple Store, you connect business professionals and entrepreneurs with the tools they need in order to put Apple solutions to work in their Read more
Position Opening at *Apple* - Apple (United...
**Job Summary** The Apple Store is a retail environment like no other - uniquely focused on delivering amazing customer experiences. As an Expert, you introduce people Read more
Position Opening at *Apple* - Apple (United...
**Job Summary** As businesses discover the power of Apple computers and mobile devices, it's your job - as a Solutions Engineer - to show them how to introduce these Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.