|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 months C Workshop deals with implementing editing windows. Well bring together much of what was presented in previous columns, and add new informa- tion on TextEdits services. Well 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. Its 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 is one of the most powerful of Macintoshs 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 Macintoshs services and their data structures. Figure 1 shows a birds 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, lets 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. Well document some of the others, though you wont 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.
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() doesnt 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 windows grafPort. Dont 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. Its 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 windows 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 lets test your understanding of TextEdits 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 TERecs 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. Well 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, youll 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 (Ive 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 windows border. The grow image assumes this, and the size and location given to the size box assumes this. The scrollers are in the windows 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. Well 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 windows defProc show. There are three visible states, however, as shown in Figure 4.
Youll 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
* dest:-> destination rect
* Fills in vs_handle and hs_handle
* with scroller handles.
* Fills in te_handle with handle to
* Returns the WindowPtr
* WARNING: Untested extract.
* 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);
* Set up TextEdit rects. Make the
* destRect fixed here for example.
* Co-locate the viewRects top right
* corner with the destRects 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,
* 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.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 windows portRect. The viewRect for TextEdit is also calculated from the windows 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.
* Event record event is global. Shift
* click selection not supported.
* WARNING: Untested extract.
unsigned short part;
* Declare assembler action
* routines for TrackControl().
* 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
TEClick(&Event.where, 0, te_handle);
page_scroll(part, ch, -1);
page_scroll(part, ch, 1);
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 bars 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. Well call this te_origin.
Now for the main thing. The scroller values are used to control the values of te_origins 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 scrollers 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 dont criticize this for tightness, its an example):
* Current value of te_origin
* Current values of the scrollers
* 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;
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 scrollers scroll_up():
; TrackControl callback action routine for
; vertical scrollers scroll-up one line
; function. Called when up-arrow is
; 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
_SetCtlValue ; Set new value
Jsr edit_scroll ; Now scroll
Unlk a6; Pascal exit
Note the statements between the dashed lines. This is the only difference between the horizontal and vertical scrollers callback routines for up and down. The difference is in the amount and direction of change to the scrollers 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 scrollers 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 wont 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:
* partPart code where first clicked
* ch ControlHandle
* dir Direction: -1=Up 1=Down
* Locks the TERec temporarily
page_scroll(part, ch, dir)
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
SetCtlValue(ch, GetCtlValue() + amount);
HUnlock(ch); /* Release TERec */
Thats about it for scrolling. Theres a lot of hidden information in the routines given. If youll 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 windows 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
* wp = WindowPointer
* th = TEHandle
Thats 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.
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:
* Activate event handlers
ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
ch = ((WindowPeek)(wp))->controlList; while(ch != NULL)
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.
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 months 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 wont be publishing sources for complete applications in MacTutor. Rather, well 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:
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 Ill 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 couldnt disagree more. C is a system implementation language. The whole idea of C is to amplify the programmers 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 dont want that to change.